JavaSE 核心语法与面向对象编程复习指南

2. 对象的创建和使用

静态变量属于类本身，整个程序中只有一份副本；而对象是通过 new 关键字实例化的。

public class Person {
    String name;
    int age;

    public void action() {
        System.out.println("play");
    }

    public static void main(String[] args) {
        // Person: 类名
        // person: 变量，用来引用 new Person() 创建出来的对象
        Person person = new Person();
        person.name = "baby";
        person.age = 20;
        person.action();
    }
}

3. 构造方法

构造方法用于对象的初始化，它与类名同名，且没有返回值类型。如果没显式定义，编译器会提供一个默认的无参构造；一旦定义了有参构造，默认无参的就会被覆盖，这点在实际开发中要特别注意。

public class Student {
    String name;
    int age;

    // 有参构造方法
    public Student(String name, int age) {
        // 把构造方法的参数 name 的值赋给类的成员变量 name
        this.name = name;
        this.age = age;
    }
}

4. this 关键字

this 代表当前对象的引用。它常用于区分成员变量和局部变量（当名称冲突时），也可以在构造方法中调用其他构造方法，但必须位于第一行。

public class Car {
    String brand; // 品牌
    int price;    // 价格

    public Car(String brand, int price) {
        this.brand = brand;
        this.price = price;
    }

    public Car(String brand) {
        // 调用有参构造方法
        this(brand, 10000);
    }

    public void display() {
        System.out.println(this.brand + this.price);
    }

    public static void main(String[] args) {
        Car car = new Car("宝马");
        car.display();
    }
}

5. 包

Package 是 Java 中组织类的一种方式，主要用于防止类名冲突和提高代码的可维护性。自定义包时，需要遵循目录结构规范。

6. 封装

封装是面向对象的三大特性之一。将类的属性私有化（用 private 修饰），提供公共的 getter 和 setter 方法来访问和修改属性，从而隐藏内部实现细节，提高代码安全性和可维护性。

public class User {
    private String username;
    private String password;

    // 读取用户名
    public String getUsername() {
        return username;
    }

    // 修改用户名
    public void setUsername(String username) {
        this.username = username;
    }

    // 读取密码
    public String getPassword() {
        return password;
    }

    // 修改密码
    public void setPassword(String password) {
        this.password = password;
    }
}

三、继承

继承允许一个类（子类）继承另一个类（父类）的属性和方法，是实现代码复用的重要手段。Java 中类只支持单继承，但可以多层继承。

1. 继承的实现

使用 extends 关键字实现继承。

public class Animal {
    String name;

    public void eat() {
        System.out.println(name + "eating");
    }
}

public class Dog extends Animal {
    public void bark() {
        System.out.println(name + "汪汪汪~");
    }

    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.name = "大黄";
        dog.eat();
        dog.bark();
    }
}

2. 方法重写（Override）

子类可以重写父类的方法，要求方法名、参数列表、返回值类型相同（或者子类的返回值类型是父类的子类型），且访问权限不能比父类更严格。

public class Person {
    public void study() {
        System.out.println("读");
    }
}

public class PersonAdd extends Person {
    @Override
    public void study() {
        System.out.println("写");
    }
}

3. super 关键字

super 用于访问父类的属性、方法和构造方法。在子类构造方法中，super() 或 super(参数列表) 用于调用父类的构造方法，且必须位于子类构造方法的第一行。

public class Father {
    String familyName = "张";

    public Father() {
        System.out.println("父类无参构造方法");
    }

    public void showFamilyname() {
        System.out.println("家族姓氏" + familyName);
    }
}

public class Son extends Father {
    public Son() {
        // 调用父类的无参构造方法
        super();
    }

    public void showInfo() {
        // 调用父类的 showFamilyname 方法
        super.showFamilyname();
        // 访问父类的 familyname 变量
        System.out.println("子类中访问父类姓氏" + super.familyName);
    }
}

四、多态

多态指同一个行为有多种不同表现形式。实现多态需要满足三个条件：继承、方法重写、父类引用指向子类对象。

public class Shape {
    public void draw() {
        System.out.println("绘制图形");
    }
}

public class Circle extends Shape {
    @Override
    public void draw() {
        System.out.println("绘制圆形");
    }
}

public class Rectangle extends Shape {
    @Override
    public void draw() {
        System.out.println("绘制矩形");
    }
}

public class PolymorphismDemo {
    public static void main(String[] args) {
        // 父类的引用指向子类对象
        Shape shape1 = new Circle();
        Shape shape2 = new Rectangle();
        shape1.draw(); // 绘制圆形
        shape2.draw(); // 绘制矩形
    }
}

核心知识点总结：

• 继承：子类复用父类的结构，同时可扩展或修改父类行为（如重写 draw()）。
• 方法重写：子类用与父类'方法名、参数列表、返回值'一致的方法替换父类的实现，实现定制化逻辑。
• 多态：父类引用可以指向子类对象，调用方法时，会根据实际对象的类型执行对应的（子类重写的）方法，让代码更灵活、可扩展。

五、抽象类和接口

抽象类和接口是实现抽象和多态的重要手段，它们定义了行为的规范。

1. 抽象类

用 abstract 修饰，不能实例化，用于定义一组相关子类的共同行为和属性，是子类的模板。它可以包含抽象方法（无方法体，子类必须实现）和普通方法。注意，子类要先构造父类的构造方法。

public abstract class AnimalAdd {
    protected String name; // protected 修饰，子类可直接访问

    public abstract void makeSound(); // 抽象方法，无方法体

    // 普通成员方法，设置名字
    public void setName(String name) {
        this.name = name;
    }
}

public class DogAdd extends AnimalAdd {
    // 重写抽象父类的 makeSound() 方法，否则会报错
    @Override
    public void makeSound() {
        System.out.println(name + "汪汪汪~");
    }
}

public class TestAdd {
    public static void main(String[] args) {
        // 创建 Dog 对象，子类可实例化，抽象父类不行，不能直接 new
        DogAdd dogAdd = new DogAdd();
        // 调用继承的 setName() 方法设置名字
        dogAdd.setName("旺财");
        // 调用重写的 makeSound() 方法
        dogAdd.makeSound();
    }
}

2. 接口

使用 interface 关键字定义接口。JDK 8 之后支持默认方法和静态方法。类用 implements 实现接口，需实现所有的抽象方法，一个类可实现多个接口，接口间可通过 extends 多继承。

interface IFlyable {
    // 抽象方法
    void fly();

    // 默认方法
    default void land() {
        System.out.println("降落");
    }
}

public class Bird implements IFlyable {
    @Override
    public void fly() {
        System.out.println("飞翔");
    }
}