七、构造方法

7.1 构造方法基础

public class ConstructorDemo {

    private String name;
    private int age;

    // 1. 无参构造器
    public ConstructorDemo() {
        this.name = "默认";
        this.age = 0;
    }

    // 2. 有参构造器
    public ConstructorDemo(String name) {
        this.name = name;
        this.age = 0;
    }

    // 3. 全参构造器
    public ConstructorDemo(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 4. 私有构造器（单例模式、工具类）
    private ConstructorDemo(int id) {
        // 私有构造器
    }

    // 5. 拷贝构造器
    public ConstructorDemo(ConstructorDemo other) {
        this.name = other.name;
        this.age = other.age;
    }
}

7.2 构造器链

public class ConstructorChainDemo {

    private String a;
    private String b;
    private String c;

    // 使用this()调用其他构造器
    public ConstructorChainDemo() {
        this("默认A");  // 必须放在第一行
    }

    public ConstructorChainDemo(String a) {
        this(a, "默认B");
    }

    public ConstructorChainDemo(String a, String b) {
        this(a, b, "默认C");
    }

    public ConstructorChainDemo(String a, String b, String c) {
        this.a = a;
        this.b = b;
        this.c = c;
    }
}

// 构建器模式（替代多参数构造器）
public class Person {
    private final String name;
    private final int age;
    private final String email;

    private Person(Builder builder) {
        this.name = builder.name;
        this.age = builder.age;
        this.email = builder.email;
    }

    public static class Builder {
        private String name;
        private int age;
        private String email;

        public Builder name(String name) {
            this.name = name;
            return this;
        }

        public Builder age(int age) {
            this.age = age;
            return this;
        }

        public Builder email(String email) {
            this.email = email;
            return this;
        }

        public Person build() {
            return new Person(this);
        }
    }

    // 使用示例
    public static void main(String[] args) {
        Person person = new Person.Builder()
            .name("张三")
            .age(25)
            .email("zhang@example.com")
            .build();
    }
}

八、方法重写

8.1 重写规则
方法重写（Overriding）：子类重新实现父类的方法。
重写规则：
方法名、参数列表必须相同
返回值类型必须是父类返回类型的子类型（协变返回）
访问修饰符不能比父类更严格
不能重写final方法
不能重写静态方法（隐藏而非重写）

class Animal {
    public String sound() {
        return "动物发出声音";
    }

    protected Animal getInstance() {
        return new Animal();
    }

    public final void cannotOverride() {
        System.out.println("不能被重写");
    }

    public static void staticMethod() {
        System.out.println("父类静态方法");
    }
}

class Dog extends Animal {

    // 重写父类方法
    @Override
    public String sound() {
        return "汪汪汪";
    }

    // 协变返回类型
    @Override
    public Dog getInstance() {
        return new Dog();
    }

    // 无法重写final方法

    // 方法隐藏（不是重写）
    public static void staticMethod() {
        System.out.println("子类静态方法");
    }
}

8.2 @Override注解

public class OverrideAnnotationDemo {

    // @Override的作用：
    // 1. 编译时检查是否正确重写
    // 2. 提高代码可读性

    class Parent {
        public void method1() {}
        public void method2() {}
    }

    class Child extends Parent {
        @Override
        public void method1() {}  // 正确重写

        // @Override
        // public void method3() {}  // 编译错误：没有重写任何方法

        @Override
        public void method2() {}  // 正确重写
    }
}

九、抽象方法与接口方法

9.1 抽象方法

// 抽象类
public abstract class Shape {

    // 抽象方法：没有方法体
    public abstract double area();

    public abstract double perimeter();

    // 抽象类可以有具体方法
    public void display() {
        System.out.println("面积: " + area());
        System.out.println("周长: " + perimeter());
    }
}

// 具体子类必须实现所有抽象方法
class Circle extends Shape {
    private double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    @Override
    public double area() {
        return Math.PI * radius * radius;
    }

    @Override
    public double perimeter() {
        return 2 * Math.PI * radius;
    }
}

class Rectangle extends Shape {
    private double width;
    private double height;

    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }

    @Override
    public double area() {
        return width * height;
    }

    @Override
    public double perimeter() {
        return 2 * (width + height);
    }
}

9.2 接口方法

// 接口中的方法（Java 8+）
public interface MyInterface {

    // 1. 抽象方法（默认public abstract）
    void abstractMethod();

    // 2. 默认方法（Java 8）
    default void defaultMethod() {
        System.out.println("默认方法");
        privateMethod();  // 可以调用私有方法
    }

    // 3. 静态方法（Java 8）
    static void staticMethod() {
        System.out.println("静态方法");
    }

    // 4. 私有方法（Java 9）
    private void privateMethod() {
        System.out.println("私有方法");
    }

    // 5. 私有静态方法（Java 9）
    private static void privateStaticMethod() {
        System.out.println("私有静态方法");
    }
}

// 函数式接口（只有一个抽象方法）
@FunctionalInterface
interface Calculator {
    int calculate(int a, int b);

    // 可以有多个默认方法
    default void log() {
        System.out.println("计算完成");
    }

    // 可以有多个静态方法
    static Calculator add() {
        return (a, b) -> a + b;
    }

    static Calculator multiply() {
        return (a, b) -> a * b;
    }
}

来源：
https://ljtgc.cn/article/332.html