Java 重写(Override)与重载(Overload)

在 Java 中，重写（Override）和重载（Overload）是两个重要的概念，它们都涉及到方法的定义和使用，但具有不同的含义和用途。

### 重载（Overload）

重载是指在同一个类中，可以定义多个方法，它们具有相同的方法名但参数列表不同（参数类型、参数个数或参数顺序），用来处理不同的输入，从而实现方法的多态性。重载的方法在编译时会根据传入的参数类型或个数决定具体调用哪个方法。

**特点和规则**：
- 方法名相同，参数列表不同。
- 返回类型可以相同也可以不同。
- 可以重载构造器。

**示例**：
```java
class Calculator {
    // 重载的方法
    public int add(int a, int b) {
        return a + b;
    }
    
    public double add(double a, double b) {
        return a + b;
    }
    
    public int add(int a, int b, int c) {
        return a + b + c;
    }
}

public class OverloadExample {
    public static void main(String[] args) {
        Calculator calc = new Calculator();
        
        System.out.println(calc.add(2, 3));        // 调用 add(int, int)
        System.out.println(calc.add(2.5, 3.5));    // 调用 add(double, double)
        System.out.println(calc.add(2, 3, 4));     // 调用 add(int, int, int)
    }
}
```

在上面的示例中，`Calculator` 类中定义了多个 `add` 方法，它们在参数列表上有所不同，但方法名相同。在 `main` 方法中，根据传入的参数类型和个数，编译器会自动匹配调用合适的重载方法。

### 重写（Override）

重写是指子类重新定义（覆盖）了父类中的方法，以便子类可以根据自己的特定需求实现该方法的行为。重写方法必须具有相同的方法签名（方法名、参数列表和返回类型都相同），并且访问权限不能比父类中的方法更严格（例如，如果父类方法是 `protected`，子类方法不能是 `private`）。

**特点和规则**：
- 方法名、参数列表（包括顺序）、返回类型必须与父类方法相同。
- 重写方法不能比父类方法抛出更多的异常（但可以抛出更少或不抛出异常）。
- 只有非`final`的方法可以被重写。

**示例**：
```java
class Animal {
    public void makeSound() {
        System.out.println("Animal makes a sound");
    }
}

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

public class OverrideExample {
    public static void main(String[] args) {
        Animal myAnimal = new Animal();
        myAnimal.makeSound();  // 输出: Animal makes a sound
        
        Animal myDog = new Dog();  // 向上转型
        myDog.makeSound();  // 输出: Dog barks
    }
}
```

在上面的示例中，`Animal` 类有一个 `makeSound` 方法，而 `Dog` 类继承自 `Animal` 并重写了 `makeSound` 方法。当用 `Animal` 类型的引用指向 `Dog` 对象时，调用 `makeSound` 方法时会执行 `Dog` 类中的重写方法，而不是 `Animal` 类中的原始方法。

### 总结

重载和重写是 Java 中利用方法名和参数列表实现多态性的两种方式。重载用于同一个类中多个方法的定义，提供了更灵活的方法调用方式；而重写用于子类重写父类方法，实现了基于继承的方法重定义。这两种技术在面向对象编程中非常常见，可以有效提高代码的复用性和灵活性。