继承与多态：Java 面向对象编程的核心魔法！

大家好！今天我们来聊聊 Java 面向对象编程中的两大核心概念：继承（Inheritance）和多态（Polymorphism）。这两个概念是 Java 的灵魂，掌握了它们，你就能写出更加灵活、可扩展的代码！本文基于《Head First Java》第 7 章的内容，通过生动的故事和 Java 代码示例，带你轻松掌握继承与多态的精髓。

1. 继承：代码复用的利器

什么是继承？

继承是面向对象编程中的一个重要特性，它允许一个类（子类）基于另一个类（父类）来构建。子类可以继承父类的属性和方法，从而避免重复代码，提高代码的可维护性。

核心思想

父类（超类）：被继承的类，包含通用的属性和方法。
子类（派生类）：继承父类的类，可以扩展或修改父类的行为。

代码示例

假设我们有一个动物王国，其中有多种动物，比如猫和狗。我们可以通过继承来实现代码复用。

// 父类：动物
class Animal {
    String name;

    public Animal(String name) {
        this.name = name;
    }

    public void eat() {
        System.out.println(name + " is eating.");
    }

    public void sleep() {
        System.out.println(name + " is sleeping.");
    }
}

// 子类：猫
class Cat extends Animal {
    public Cat(String name) {
        super(name); // 调用父类的构造函数
    }

    public void meow() {
        System.out.println(name + " says: Meow!");
    }
}

// 子类：狗
class Dog extends Animal {
    public Dog(String name) {
        super(name); // 调用父类的构造函数
    }

    public void bark() {
        System.out.println(name + " says: Woof!");
    }
}

// 客户端代码
public class AnimalKingdom {
    public static void main(String[] args) {
        Cat cat = new Cat("Whiskers");
        Dog dog = new Dog("Buddy");

        cat.eat();   // 输出: Whiskers is eating.
        cat.meow();  // 输出: Whiskers says: Meow!

        dog.sleep(); // 输出: Buddy is sleeping.
        dog.bark();  // 输出: Buddy says: Woof!
    }
}

优点

代码复用：子类可以直接使用父类的属性和方法。
扩展性：子类可以添加新的属性和方法，或者重写父类的方法。

注意事项

Java 是单继承的，一个类只能继承一个父类。
使用 super 关键字可以调用父类的构造函数或方法。

2. 多态：灵活的行为表现

什么是多态？

多态是指同一个方法在不同对象中有不同的行为表现。多态的核心思想是一个接口，多种实现。通过多态，我们可以编写更加通用和灵活的代码。

核心思想

方法重写（Override）：子类可以重写父类的方法，提供不同的实现。
向上转型（Upcasting）：将子类对象赋值给父类引用，从而实现多态。

代码示例

继续以动物王国为例，我们可以通过多态来实现不同动物的叫声。

// 父类：动物
class Animal {
    String name;

    public Animal(String name) {
        this.name = name;
    }

    // 父类的 makeSound 方法
    public void makeSound() {
        System.out.println(name + " makes a sound.");
    }
}

// 子类：猫
class Cat extends Animal {
    public Cat(String name) {
        super(name);
    }

    // 重写父类的 makeSound 方法
    @Override
    public void makeSound() {
        System.out.println(name + " says: Meow!");
    }
}

// 子类：狗
class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }

    // 重写父类的 makeSound 方法
    @Override
    public void makeSound() {
        System.out.println(name + " says: Woof!");
    }
}

// 客户端代码
public class AnimalSounds {
    public static void main(String[] args) {
        Animal myCat = new Cat("Whiskers"); // 向上转型
        Animal myDog = new Dog("Buddy");   // 向上转型

        myCat.makeSound(); // 输出: Whiskers says: Meow!
        myDog.makeSound(); // 输出: Buddy says: Woof!
    }
}

优点

灵活性：同一个方法可以根据对象的不同表现出不同的行为。
可扩展性：新增子类时，无需修改现有代码。

注意事项

多态的实现依赖于方法重写。
向上转型后，只能调用父类中定义的方法。如果需要调用子类特有的方法，需要向下转型（需谨慎使用）。

3. 方法重写 vs 方法重载

方法重写（Override）

发生在父子类之间。
子类重写父类的方法，提供不同的实现。
方法名、参数列表和返回类型必须相同。

方法重载（Overload）

发生在同一个类中。
方法名相同，但参数列表不同。
返回类型可以不同。

代码示例

class Calculator {
    // 方法重载：加法
    public int add(int a, int b) {
        return a + b;
    }

    public double add(double a, double b) {
        return a + b;
    }
}

class AdvancedCalculator extends Calculator {
    // 方法重写：加法
    @Override
    public int add(int a, int b) {
        return a + b + 10; // 重写父类的加法方法
    }
}

4. 总结

继承和多态是 Java 面向对象编程的核心概念，它们让代码更加灵活、可扩展和易于维护：

继承：通过子类复用父类的代码，避免重复。
多态：通过方法重写和向上转型，实现同一个接口的多种行为表现。

掌握继承与多态，你就能写出更加优雅和高效的 Java 代码！希望本文能帮助你更好地理解这两个重要的概念。

互动话题
你在项目中使用过继承和多态吗？遇到过哪些有趣的问题？欢迎在评论区分享你的经验！