Java重写与重载：一文彻底搞懂核心区别

public class Calculator {
    
    // 重载1：两个int参数
    public int add(int a, int b) {
        return a + b;
    }
    
    // 重载2：参数类型不同（double）
    public double add(double a, double b) {
        return a + b;
    }
    
    // 重载3：参数数量不同
    public int add(int a, int b, int c) {
        return a + b + c;
    }
    
    // 重载4：参数顺序不同（谨慎使用！可读性差）
    public void print(String name, int age) {
        System.out.println(name + " is " + age);
    }
    public void print(int age, String name) {
        System.out.println(age + " years old: " + name);
    }
    
    // ❌ 编译错误！仅返回类型不同不能构成重载
    // public String add(int a, int b) { return ""; } 
}

Calculator calc = new Calculator();
calc.add(2, 3);        // 调用 int add(int, int)
calc.add(2.5, 3.1);    // 调用 double add(double, double)
calc.add(1, 2, 3);     // 调用 int add(int, int, int)

// 父类
class Animal {
    public void makeSound() {
        System.out.println("Animal makes a sound");
    }
    
    public Animal createOffspring() {
        return new Animal();
    }
    
    // private/final/static 方法不能被重写！
    private void secret() {}
    final void fixed() {}
    static void staticMethod() {}
}

// 子类
class Dog extends Animal {
    
    @Override // 安全卫士！写错方法名/参数会直接编译报错
    public void makeSound() { // 访问修饰符可更宽松（如父类protected→子类public）
        System.out.println("Dog barks: Woof!");
    }
    
    // 协变返回：返回类型是父类返回类型的子类
    @Override
    public Dog createOffspring() { 
        return new Dog();
    }
    
    // ❌ 编译错误！缩小访问权限
    // private void makeSound() {}
    
    // ❌ 编译错误！抛出更广的检查异常
    // @Override
    // public void makeSound() throws Exception {}
}

Animal myPet = new Dog(); // 向上转型
myPet.makeSound(); 
// 输出: Dog barks: Woof! （运行时根据实际对象类型调用）