Java 中的继承与多态：面向对象编程的核心特性

继承和多态是面向对象编程中最重要的两个概念，它们使代码结构更加清晰、灵活，并极大地提高了代码复用性。本文将深入探讨 Java 中的继承与多态，帮助你更好地理解这些核心概念。

1. 继承

1.1 为什么需要继承

在实际编程中，我们经常会遇到不同的类具有相似的属性和行为。例如，猫和狗都是动物，它们都有名字、年龄等属性，也都有吃饭、睡觉等行为。如果为每一个类都独立编写这些共同的属性和方法，会导致代码重复，维护困难。

继承机制允许我们定义一个通用的基类（父类），然后创建从这个基类派生的子类。子类继承父类的属性和方法，同时可以添加自己特有的属性和方法。

1.2 继承的语法

Java 中使用 extends 关键字表示继承关系：

java 复制代码

// 父类
public class Animal {
    String name;
    int age;
    
    public void eat() {
        System.out.println(name + "正在吃饭");
    }
    
    public void sleep() {
        System.out.println(name + "正在睡觉");
    }
}

// 子类
public class Dog extends Animal {
    public void bark() {
        System.out.println(name + "汪汪汪~~~");
    }
}

// 子类
public class Cat extends Animal {
    public void mew() {
        System.out.println(name + "喵喵喵~~~");
    }
}

1.3 成员访问规则

在继承关系中，子类访问父类成员的规则如下：

成员变量：

如果子类和父类中的成员变量不同名，子类可以直接访问父类的成员变量

如果同名，子类优先访问自己的成员变量

如果需要访问被覆盖的父类成员变量，可以使用 super 关键字

成员方法：

如果方法名不同，子类可以直接调用父类的方法

如果方法名相同但参数不同（构成重载），根据调用时的参数确定调用哪个方法

如果方法签名完全相同（构成重写），子类方法会覆盖父类方法，如果需要调用父类的被覆盖方法，需使用 super 关键字

1.4 super 关键字

super 关键字用于在子类中访问父类的成员：

java 复制代码

public class Derived extends Base {
    int a; // 与父类同名
    
    public void method() {
        a = 100;         // 访问子类自己的 a
        super.a = 200;   // 访问父类的 a
        
        methodB();       // 调用子类自己的方法
        super.methodB(); // 调用父类的方法
    }
}

1.5 构造方法继承

在创建子类对象时，必须先调用父类的构造方法，再执行子类的构造方法。如果没有显式调用父类构造方法，Java 会自动插入对父类无参构造方法的调用：

java 复制代码

public class Derived extends Base {
    public Derived() {
        // 编译器自动插入 super();
        System.out.println("Derived()");
    }
}

特别注意：

子类构造方法中调用父类构造方法必须是第一条语句
子类可以通过 super(参数) 显式调用父类的特定构造方法

2. 组合

组合是另一种代码复用的方式，它表示"has-a"关系，通过将一个类的对象作为另一个类的成员变量来实现：

java 复制代码

class Tire { }
class Engine { }

class Car {
    private Tire tire;       // 汽车有轮胎
    private Engine engine;   // 汽车有发动机
}

与继承相比，组合的耦合性较低，更灵活。一般建议：能用组合尽量用组合。

3. 多态

3.1 多态的概念

多态是指同一个行为，作用于不同的对象，会产生不同的结果。在面向对象编程中，多态使程序更加灵活和可扩展。

3.2 多态的实现条件

Java 中实现多态需要满足三个条件：

必须在继承体系下
子类必须重写父类的方法
通过父类引用调用重写的方法

3.3 方法重写

方法重写是子类对父类方法的重新实现。重写时需要遵循以下规则：

方法名、参数列表必须相同
返回类型可以相同，或是父类返回类型的子类型
访问权限不能比父类更严格
不能抛出比父类方法更多的异常

3.4 向上转型和向下转型

向上转型是将子类对象赋值给父类引用：

java 复制代码

Animal animal = new Dog(); // 向上转型

向下转型是将父类引用转换为子类引用：

java 复制代码

Dog dog = (Dog)animal; // 向下转型，需要类型转换

向下转型可能不安全，应该使用 instanceof 操作符进行类型检查：

java 复制代码

if (animal instanceof Dog) {
    Dog dog = (Dog)animal;
    dog.bark();
}

3.5 多态的优缺点

优点：

降低代码的"圈复杂度"，避免大量的 if-else 语句

提高代码的可扩展性，增加新的子类时无需修改调用代码

缺点：

多态会有一定的性能开销

不能访问子类特有的方法（除非向下转型）

属性没有多态性，只能访问父类属性

3.6 避免在构造方法中调用重写的方法

在构造方法中调用可能被子类重写的方法很危险，因为当创建子类对象时，父类构造方法会在子类字段初始化之前执行，可能导致未预期的结果。

结论

继承和多态是 Java 面向对象编程的核心概念，掌握它们对于编写出高质量的代码至关重要。继承提供了代码复用的机制，而多态则提供了灵活性和可扩展性。然而，我们也应当注意继承的一些局限性，**例如 Java 不支持多继承，以及继承可能导致较高的耦合度。**在实际开发中，应当根据具体情况选择使用继承还是组合。

记住这句面向对象设计的经典建议："组合优于继承"。在大多数情况下，组合会提供更好的灵活性和更低的耦合度。