【java】重载（overloading）和重写（overriding）

重载（Overloading） 是 Java 中的一个重要概念，它允许在同一个类中定义多个方法名相同但参数列表不同的方法。重载的目的是让方法的使用更加灵活，可以根据不同的参数类型或数量执行不同的操作。

重载的核心特点

1. 方法名相同：

   • 重载的方法必须具有相同的名字。

2. 参数列表不同：

   • 参数列表可以有以下不同：

     • 参数的类型不同。

     • 参数的数量不同。

     • 参数的顺序不同（如果类型不同）。

3. 返回值类型无关：

   • 重载与方法的返回值类型无关。即使返回值类型不同，如果参数列表相同，也不能算作重载。

4. 发生在同一个类中：

   • 重载通常发生在同一个类中，但也可以在父类和子类之间发生。

重载的示例

1. 参数数量不同

java

class Calculator {
    // 方法 1：两个整数相加
    public int add(int a, int b) {
        return a + b;
    }

    // 方法 2：三个整数相加
    public int add(int a, int b, int c) {
        return a + b + c;
    }
}

public class Main {
    public static void main(String[] args) {
        Calculator calc = new Calculator();
        System.out.println(calc.add(1, 2));       // 调用方法 1，输出 3
        System.out.println(calc.add(1, 2, 3));    // 调用方法 2，输出 6
    }
}

输出：

3
6

2. 参数类型不同

java

class Printer {
    // 方法 1：打印整数
    public void print(int number) {
        System.out.println("整数: " + number);
    }

    // 方法 2：打印字符串
    public void print(String text) {
        System.out.println("字符串: " + text);
    }
}

public class Main {
    public static void main(String[] args) {
        Printer printer = new Printer();
        printer.print(10);        // 调用方法 1，输出 "整数: 10"
        printer.print("Hello");   // 调用方法 2，输出 "字符串: Hello"
    }
}

输出：

整数: 10
字符串: Hello

3. 参数顺序不同

java

class Display {
    // 方法 1：先整数后字符串
    public void show(int number, String text) {
        System.out.println("整数: " + number + ", 字符串: " + text);
    }

    // 方法 2：先字符串后整数
    public void show(String text, int number) {
        System.out.println("字符串: " + text + ", 整数: " + number);
    }
}

public class Main {
    public static void main(String[] args) {
        Display display = new Display();
        display.show(10, "Hello"); // 调用方法 1
        display.show("Hello", 10); // 调用方法 2
    }
}

输出：

复制整数: 10, 字符串: Hello 字符串: Hello, 整数: 10

重载的好处

1. 提高代码可读性：

   • 相同功能的方法使用相同的名字，代码更直观。

2. 简化方法调用：

   • 根据参数的不同，自动调用合适的方法，无需记住多个方法名。

3. 增强灵活性：

   • 可以根据不同的需求定义多个版本的方法。

重载 vs 重写

总结

• 重载是指在同一个类中定义多个方法名相同但参数列表不同的方法。

• 重载的目的是让方法的使用更加灵活，可以根据不同的参数类型或数量执行不同的操作。

• 重载与返回值类型无关，只与参数列表有关。

重写（Overriding） 是 Java 中的一个重要概念，它允许子类重新定义父类中已有的方法，以改变或扩展方法的行为。重写的核心是方法名、参数列表和返回值类型必须与父类方法完全相同。

下面通过一个具体的实例来帮助你理解重写。

重写的规则

1. 方法名相同：

   • 子类方法的名字必须与父类方法的名字完全相同。

2. 参数列表相同：

   • 子类方法的参数列表必须与父类方法的参数列表完全相同。

3. 返回值类型相同：

   • 子类方法的返回值类型必须与父类方法的返回值类型相同（或者是其子类）。

4. 访问权限不能更严格：

   • 子类方法的访问权限不能比父类方法更严格。例如，如果父类方法是 public，子类方法不能是 private。

5. 不能重写静态方法：

   • 静态方法属于类，不属于对象，因此不能重写。

重写的实例

父类和子类的定义

java

// 父类
class Animal {
    // 父类方法
    public void makeSound() {
        System.out.println("动物发出声音");
    }
}

// 子类
class Dog extends Animal {
    // 重写父类方法
    @Override
    public void makeSound() {
        System.out.println("汪汪汪！");
    }
}

// 子类
class Cat extends Animal {
    // 重写父类方法
    @Override
    public void makeSound() {
        System.out.println("喵喵喵！");
    }
}

测试代码

java

public class Main {
    public static void main(String[] args) {
        Animal animal1 = new Animal(); // 父类对象
        Animal animal2 = new Dog();    // 子类对象（多态）
        Animal animal3 = new Cat();    // 子类对象（多态）

        animal1.makeSound(); // 调用父类方法
        animal2.makeSound(); // 调用子类 Dog 的重写方法
        animal3.makeSound(); // 调用子类 Cat 的重写方法
    }
}

输出

动物发出声音
汪汪汪！
喵喵喵！

代码解析

1. 父类 Animal：

   • 定义了一个 makeSound 方法，输出 "动物发出声音"。

2. 子类 Dog：

   • 重写了 makeSound 方法，输出 "汪汪汪！"。

3. 子类 Cat：

   • 重写了 makeSound 方法，输出 "喵喵喵！"。

4. 多态：

   • 在 Main 类中，animal2 和 animal3 是父类 Animal 类型的变量，但实际指向的是子类 Dog 和 Cat 的对象。

   • 当调用 makeSound 方法时，实际执行的是子类重写的方法，这就是多态的体现。

重写的注意事项

1. @Override 注解：

   • 在子类方法前加上 @Override 注解，可以明确表示这是一个重写的方法。如果方法签名与父类方法不匹配，编译器会报错。

2. 不能重写静态方法：

   • 静态方法属于类，不属于对象，因此不能重写。如果子类定义了与父类相同的静态方法，这称为隐藏（Hiding），而不是重写。

3. 不能重写 final 方法：

   • 如果父类方法被声明为 final，子类不能重写该方法。

4. 不能重写私有方法：

   • 私有方法在子类中不可见，因此不能重写。