基本数据类型及一些注意事项

逻辑类型：boolean

整数类型：byte, short, int, long

字符类型：char

浮点类型：float, double

需要加后缀的有long和float

注意事项

对于局部变量，不存在默认值
只有实例方法才能调用实例变量

PATH和CLASSPATH的配置

PATH的配置: 找到JDK的安装路径（例如：D:\jdk），设置环境变量，在PATH中添加D:\jdk\bin

CLASSPATH的配置: 设置CLASSPATH环境变量，.; D:\jdk\lib

Java特点中面向对象是什么

Java是面向对象编程语言，面向对象编程（OOP）是一种编程范式，使用“对象”作为基本单元。对象包含数据（属性）和行为（方法）。

面向对象编程的三个主要特点：

封装：将对象的属性和方法封装在一起，隐藏对象的内部实现细节，只暴露必要的接口。这样可以保护数据，防止外部干扰。
继承：一种机制，可以创建一个新类，这个新类基于已有的类并继承其属性和方法。新类可以重用父类的代码，还可以添加新的功能。
多态：允许对象以多种形式出现。具体来说，一个父类的引用可以指向子类的实例，并且可以调用子类的方法，实现运行时多态。

各个修饰符修饰的类在各个场景下的访问权限

修饰符	同一个类	同一个包	子类（同包）	子类（不同包）	其他包
public	√	√	√	√	√
protected	√	√	√	√	×
默认 (无修饰符)	√	√	√	×	×
private	√	×	×	×	×

说明：

public：公共访问，任何地方都可以访问。
protected：受保护访问，同包可以访问，不同包的子类可以访问。
默认（无修饰符）：包级私有，同包可以访问，不同包不能访问。
private：私有访问，只有同一个类中可以访问。

类：

顶层类（Outer Class）只能用public或默认修饰，不能用protected或private。
内部类（Inner Class）可以用public、protected、默认或private修饰。

成员变量：

成员变量可以用public、protected、默认或private修饰，遵循上表的访问权限。

GUI中listener的用处

在Java的GUI编程中，listener是用于响应用户交互事件的接口。例如，点击按钮、移动鼠标等。listener可以让程序对用户操作做出响应。

常见的listener接口：

ActionListener: 用于处理动作事件（如按钮点击）。
MouseListener: 用于处理鼠标事件。
KeyListener: 用于处理键盘事件。

实际代码示例

写一个class，写构造方法，并继承：

class Animal {
    String name;

    // 构造方法
    public Animal(String name) {
        this.name = name;
    }

    public void makeSound() {
        System.out.println("Some sound...");
    }
}

class Dog extends Animal {
    // 子类的构造方法
    public Dog(String name) {
        super(name);
    }

    @Override
    public void makeSound() {
        System.out.println("Bark");
    }

    public static void main(String[] args) {
        Dog dog = new Dog("Buddy");
        dog.makeSound(); // 输出 "Bark"
    }
}

写一个接口，并写一个类实现该接口：

// 定义接口
public interface Vehicle {
    void start();
    void stop();
    int getSpeed();
}

// 实现接口的类
public class Car implements Vehicle {
    private int speed;

    @Override
    public void start() {
        System.out.println("Car is starting");
        speed = 10;
    }

    @Override
    public void stop() {
        System.out.println("Car is stopping");
        speed = 0;
    }

    @Override
    public int getSpeed() {
        return speed;
    }

    public static void main(String[] args) {
        Car car = new Car();
        car.start();
        System.out.println("Speed: " + car.getSpeed());
        car.stop();
        System.out.println("Speed: " + car.getSpeed());
    }
}

写一个抽象类以及实现：

abstract class Shape {
    // 抽象方法
    abstract void draw();

    // 非抽象方法
    void description() {
        System.out.println("This is a shape");
    }
}

class Circle extends Shape {
    @Override
    void draw() {
        System.out.println("Drawing a circle");
    }

    public static void main(String[] args) {
        Circle circle = new Circle();
        circle.draw(); // 输出 "Drawing a circle"
        circle.description(); // 输出 "This is a shape"
    }
}

super关键字：

在Java中，super 关键字是一个特殊的引用，它指向当前对象的父类。

class Parent {
    void show() {
        System.out.println("Parent's show()");
    }
    
    int value = 10;
}

class Child extends Parent {
    void show() {
        super.show(); // 调用父类的show()方法
        System.out.println("Child's show()");
    }
    
    int value = 20;
    
    void printValues() {
        System.out.println(super.value); // 访问父类的value字段
        System.out.println(value); // 访问子类的value字段
    }
    
    Child() {
        super(); // 调用父类的构造方法
    }
}

public class Test {
    public static void main(String[] args) {
        Child c = new Child();
        c.show();
        c.printValues();
    }
}

在这个例子中，Child 类继承自 Parent 类。在 Child 类的 show() 方法中，我们使用 super.show() 来调用 Parent 类的 show() 方法。在 printValues() 方法中，我们使用 super.value 来访问父类的字段，而直接使用 value 来访问子类的字段。在 Child 类的构造方法中，我们使用 super() 来调用父类的构造方法。

可变参数：

可变参数可以与普通参数一起使用，但可变参数必须放在参数列表的最后

public void printAll(Object first, int... numbers) {
    System.out.println(first);
    for (int num : numbers) {
        System.out.println(num);
    }
}