Java继承：代码复用的基石

概述

继承是面向对象编程的三大特性之一，它允许子类继承父类的属性和方法，实现代码复用。通过继承，子类可以在不修改父类的情况下扩展父类的功能。

1. 继承的基本概念

// 父类：动物
public class Animal {
    protected String name;
    protected int age;

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

    public void eat() {
        System.out.println(name + "正在吃东西");
    }

    public void sleep() {
        System.out.println(name + "正在睡觉");
    }

    public void displayInfo() {
        System.out.println("名字: " + name + ", 年龄: " + age);
    }
}

// 子类：狗
public class Dog extends Animal {
    private String breed;

    public Dog(String name, int age, String breed) {
        super(name, age);
        this.breed = breed;
    }

    public void bark() {
        System.out.println(name + "汪汪叫");
    }

    public void fetch() {
        System.out.println(name + "正在捡球");
    }

    @Override
    public void displayInfo() {
        super.displayInfo();
        System.out.println("品种: " + breed);
    }
}

2. super关键字

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

public class Cat extends Animal {
    private boolean isIndoor;

    public Cat(String name, int age, boolean isIndoor) {
        super(name, age);
        this.isIndoor = isIndoor;
    }

    public void meow() {
        System.out.println(name + "喵喵叫");
    }

    @Override
    public void eat() {
        super.eat();
        System.out.println(name + "正在吃猫粮");
    }
}

3. 方法重写

子类可以重写父类的方法，提供特定的实现：

public class Bird extends Animal {
    private boolean canFly;

    public Bird(String name, int age, boolean canFly) {
        super(name, age);
        this.canFly = canFly;
    }

    @Override
    public void eat() {
        System.out.println(name + "正在啄食");
    }

    public void fly() {
        if (canFly) {
            System.out.println(name + "正在飞翔");
        } else {
            System.out.println(name + "不会飞");
        }
    }
}

4. 继承链与构造方法调用顺序

public class GrandParent {
    public GrandParent() {
        System.out.println("GrandParent构造方法");
    }
}

public class Parent extends GrandParent {
    public Parent() {
        System.out.println("Parent构造方法");
    }
}

public class Child extends Parent {
    public Child() {
        System.out.println("Child构造方法");
    }

    public static void main(String[] args) {
        new Child();
        // 输出：GrandParent -> Parent -> Child
    }
}

5. 继承与组合的选择

// 继承：is-a关系
public class Employee extends Person {
    private String department;
}

// 组合：has-a关系
public class Department {
    private List<Employee> employees;

    public void addEmployee(Employee emp) {
        employees.add(emp);
    }
}

最佳实践

1. 遵循is-a原则：只有真正满足"是一个"关系时才使用继承
2. 优先使用组合：组合比继承更灵活，耦合度更低
3. 合理使用protected：protected成员应是子类确实需要访问的
4. 重写时使用@Override：确保正确重写父类方法
5. 避免深层继承：继承层次一般不超过3层

总结

继承是Java面向对象编程的核心机制，它实现了代码复用和层次化设计。正确使用继承可以提高代码的可维护性和可扩展性，但也要注意继承的局限性，合理选择继承和组合。