方法重载和方法重写的区别

方法重载和方法重写的区别

1.什么是方法重载？

方法重载（Method Overloading）是指在同一个类中，可以定义多个方法具有相同的名称，但是参数列表不同。重载的方法可以有不同的参数类型、不同的参数个数，或者参数类型的顺序不同。方法重载的目的是提高代码的灵活性和可读性。

方法重载的规则：

1. 方法名称相同： 重载的方法必须具有相同的名称。

2. 参数列表不同： 重载的方法必须具有不同的参数列表。这可以通过参数类型、参数个数，或者参数类型的顺序来实现。

3. 返回类型可以相同也可以不同： 方法重载可以具有相同的返回类型，也可以具有不同的返回类型。返回类型不是重载的决定性因素。

4. 访问修饰符和异常类型不影响重载： 方法重载可以具有相同或不同的访问修饰符（如 public、private、protected）和可以抛出相同或不同的异常。

例子：

public class OverloadExample {

    // 方法重载：不同参数类型
    static int add(int a, int b) {
        return a + b;
    }

    // 方法重载：不同参数个数
    static double add(double a, double b, double c) {
        return a + b + c;
    }

    // 方法重载：不同参数类型和参数个数
    static String concatenate(String str1, String str2) {
        return str1 + str2;
    }

    static String concatenate(String str1, String str2, String str3) {
        return str1 + str2 + str3;
    }

    public static void main(String[] args) {
        System.out.println(add(2, 3));                // 输出 5
        System.out.println(add(1.5, 2.5, 3.5));       // 输出 7.5
        System.out.println(concatenate("Hello, ", "World!"));          // 输出 Hello, World!
        System.out.println(concatenate("Java", " is", " awesome!"));  // 输出 Java is awesome!
    }
}

在上面的例子中，add 方法和 concatenate 方法都展示了方法重载的不同形式。通过这样的方式，我们可以根据不同的参数情况使用相同的方法名称，提高代码的可读性和灵活性。

---

2. 什么是方法重写

方法重写（Method Overriding）是指子类中定义了一个与父类中已有的方法签名（包括方法名称、返回类型和参数列表）相同的方法，并且具有相同的访问修饰符。通过方法重写，子类可以提供自己的实现，覆盖父类中的相应方法。

方法重写是实现多态性（Polymorphism）的一种方式，允许在运行时动态选择调用哪个方法，具体调用哪个方法取决于对象的实际类型。

方法重写的规则：

1. 方法名称、返回类型和参数列表必须相同： 在子类中重写的方法必须与父类中的方法具有相同的名称、返回类型和参数列表。

2. 访问修饰符不能更严格： 子类中重写的方法的访问修饰符不能比父类中的方法更严格。例如，如果父类方法是 protected，子类方法可以是 protected 或者 public，但不能是 private 或默认（不加修饰符）。

3. 抛出的异常不能更多，不能更限制： 子类中重写的方法可以不抛出异常，或者抛出与父类相同的异常，不能抛出更多或更限制的异常。

例子：

class Animal {
    void makeSound() {
        System.out.println("Some generic sound");
    }
}

class Dog extends Animal {
    // 方法重写
    @Override
    void makeSound() {
        System.out.println("Bark! Bark!");
    }
}

class Cat extends Animal {
    // 方法重写
    @Override
    void makeSound() {
        System.out.println("Meow");
    }
}

public class OverrideExample {
    public static void main(String[] args) {
        Animal animal1 = new Dog();
        Animal animal2 = new Cat();

        animal1.makeSound();  // 输出 Bark! Bark!
        animal2.makeSound();  // 输出 Meow
    }
}

在上面的例子中，Dog 和 Cat 类继承自 Animal 类，它们分别重写了 makeSound 方法。在 main 方法中，通过多态性，使用父类的引用指向子类的对象，实现了动态调用相应子类的重写方法。这就是方法重写的一个典型应用场景。

3.两者区别

1. 前者是使用在同一类下，方法用意相同但是传参不同
2. 后者是主要用于继承，改写父类方法达到子类目的