继承

继承是面向对象编程的核心特性之一。

继承概念

什么是继承

继承是子类获得父类属性和方法的机制，实现代码复用。

// 父类（基类）
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 {
    // 继承了Animal的name、age、eat()、sleep()
    
    // 子类特有方法
    public void bark() {
        System.out.println(name + "汪汪叫");
    }
}

继承语法

// 语法：class 子类 extends 父类
public class Child extends Parent {
    // 子类内容
}

继承特点

子类获得父类内容

Dog dog = new Dog();
dog.name = "旺财";     // 使用父类属性
dog.age = 3;
dog.eat();             // 调用父类方法
dog.sleep();           // 调用父类方法
dog.bark();            // 调用子类特有方法

继承关系图

        Animal（父类）
           ↑
           | extends
           |
    Dog（子类）

子类继承父类 → 子类拥有父类的属性和方法

继承优势

• 代码复用：避免重复编写相同代码
• 扩展功能：子类可添加新功能
• 统一结构：相关类形成层级体系
• 多态基础：为多态提供前提

继承规则

Java单继承

Java只支持单继承，一个子类只能有一个父类。

// 正确：单继承
public class Dog extends Animal { }

// 错误：多继承（Java不支持）
public class Dog extends Animal, Object { }  // 编译错误

Java单继承简化类关系，避免多继承复杂性。

多层继承

支持多层继承，形成继承链。

// 继承链：Animal → Dog → Husky
public class Animal { }
public class Dog extends Animal { }
public class Husky extends Dog { }

// Husky继承Dog，间接继承Animal

所有类继承Object

Java中所有类默认继承java.lang.Object。

public class Person { }
// 等价于
public class Person extends Object { }

// Object类的方法所有类都有：
// toString(), equals(), hashCode(), getClass()等

方法重写

什么是方法重写

子类重新定义父类的方法，提供不同的实现。

public class Animal {
    public void speak() {
        System.out.println("动物发出声音");
    }
}

public class Dog extends Animal {
    @Override  // 重写注解
    public void speak() {
        System.out.println("汪汪汪");  // 狗特有的叫声
    }
}

// 使用
Dog dog = new Dog();
dog.speak();  // 输出：汪汪汪（子类方法）

重写规则

• 方法名、参数必须相同
• 返回类型相同或为子类型
• 访问修饰符不能更严格
• 加@Override注解（推荐）

// 父类
public class Parent {
    public void method() { }
}

// 子类重写
public class Child extends Parent {
    @Override
    public void method() { }  // 正确
    
    // 错误：访问修饰符更严格
    @Override
    private void method() { }  // 编译错误
}

重写与重载对比

super关键字

调用父类方法

public class Animal {
    public void eat() {
        System.out.println("动物吃东西");
    }
}

public class Dog extends Animal {
    @Override
    public void eat() {
        super.eat();  // 调用父类方法
        System.out.println("狗吃骨头");
    }
}

Dog dog = new Dog();
dog.eat();
// 输出：动物吃东西 → 狗吃骨头

调用父类构造方法

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

public class Dog extends Animal {
    public Dog(String name) {
        super(name);  // 调用父类构造方法（必须在第一行）
    }
}

子类构造方法默认调用super()，无参父类构造。

继承中的访问控制

访问修饰符影响继承

// 父类
public class Parent {
    private int privateField;    // 子类不可访问
    protected int protectedField; // 子类可访问
    public int publicField;       // 子类可访问
    
    private void privateMethod() { }
    protected void protectedMethod() { }
    public void publicMethod() { }
}

// 子类
public class Child extends Parent {
    public void test() {
        // privateField = 1;       // 错误：不可访问
        protectedField = 2;        // 正确
        publicField = 3;           // 正确
        
        // privateMethod();        // 错误
        protectedMethod();         // 正确
        publicMethod();            // 正确
    }
}

final与继承

final类不能继承

public final class FinalClass {
    // final类不可被继承
}

// 错误：无法继承final类
public class Child extends FinalClass { }  // 编译错误

final方法不能重写

public class Parent {
    public final void finalMethod() {
        // final方法不可重写
    }
}

public class Child extends Parent {
    // 错误：无法重写final方法
    @Override
    public void finalMethod() { }  // 编译错误
}

继承设计原则

合理使用继承

• 子类确实是父类的特殊类型
• 子类需要扩展父类功能
• 遵循"is-a"关系（子类 is a 父类）

// 合理继承（Dog is an Animal）
public class Dog extends Animal { }

// 不合理继承（Dog is not a Cat）
public class Dog extends Cat { }  // 设计错误

继承层次不要太深

// 不推荐：继承层次太深
A → B → C → D → E → F

// 推荐：层次控制在2-3层
Animal → Dog → Husky

要点总结

• 继承是子类获得父类属性和方法的机制
• 使用extends关键字实现继承
• Java只支持单继承（一个父类）
• 支持多层继承形成继承链
• 所有类默认继承Object类
• 子类可重写父类方法（Override）
• 重写方法名、参数必须相同
• @Override注解标注重写方法
• super调用父类方法和构造方法
• final类不能继承，final方法不能重写
• 遵循"is-a"关系设计继承