Java 继承详解

Java 继承是面向对象编程（OOP）的三大核心特性之一（另外两个是封装和多态），它允许一个类（子类）继承另一个类（父类）的属性和方法，从而实现代码复用、简化开发，并为多态奠定基础。

一、继承的基本概念

定义：继承是指子类（Subclass）通过特定语法获取父类（Superclass）的非私有成员（属性和方法），同时子类可以新增自己的属性和方法，或重写父类的方法以实现特定功能。
作用：
1. 代码复用：避免重复定义相同的属性和方法。
2. 功能扩展：子类在父类基础上添加新特性。
3. 多态基础：不同子类对同一父类方法的重写，可通过父类引用调用不同实现。

二、继承的语法规则

在 Java 中，使用 extends 关键字声明继承关系，语法如下：

// 父类（基类）
class 父类名 {
    // 父类的属性和方法
}

// 子类（派生类），通过 extends 继承父类
class 子类名 extends 父类名 {
    // 子类新增的属性和方法
    // （可选）重写父类的方法
}

 

示例：
定义一个 Animal 父类，包含动物的基本属性（如名称）和行为（如移动），再定义 Dog 子类继承 Animal 并扩展特有功能（如吠叫）。

// 父类：动物
class Animal {
    protected String name; // 受保护的属性，子类可访问

    // 父类构造方法
    public Animal(String name) {
        this.name = name;
    }

    // 父类方法：移动
    public void move() {
        System.out.println(name + " 在移动");
    }
}

// 子类：狗（继承自动物）
class Dog extends Animal {
    // 子类构造方法，必须通过 super 调用父类构造
    public Dog(String name) {
        super(name); // 调用父类的构造方法，必须放在第一行
    }

    // 子类新增方法：吠叫
    public void bark() {
        System.out.println(name + " 汪汪叫");
    }

    // 重写父类的 move 方法
    @Override
    public void move() {
        System.out.println(name + " 四条腿跑");
    }
}

 

三、继承的核心特性

1. 单继承限制

Java 中一个类只能直接继承 一个父类（单继承），但支持 多层继承（子类 → 父类 → 祖父类...）。
例如：Dog 继承 Animal，Animal 可继承 Organism（生物）。

 
class Organism {} // 祖父类
class Animal extends Organism {} // 父类（继承 Organism）
class Dog extends Animal {} // 子类（继承 Animal，间接继承 Organism）

2. `super` 关键字

super 用于访问父类的成员（属性、方法、构造方法），主要场景：

调用父类构造方法：子类构造方法中，super(参数) 必须放在第一行，若未显式调用，默认调用父类无参构造（若父类无无参构造，编译报错）。
访问父类属性 / 方法：当子类与父类有同名成员时，用 super 区分父类成员。

class Parent {
    int num = 10;
    void print() {
        System.out.println("Parent: " + num);
    }
}

class Child extends Parent {
    int num = 20;
    void print() {
        super.print(); // 调用父类的 print 方法
        System.out.println("Child: " + num);
        System.out.println("Parent num: " + super.num); // 访问父类的 num
    }
}

// 测试
public class Test {
    public static void main(String[] args) {
        Child c = new Child();
        c.print(); 
        // 输出：
        // Parent: 10
        // Child: 20
        // Parent num: 10
    }
}

 

3. 方法重写（Override）

子类可重写父类的方法，以实现子类特有的逻辑。需满足以下规则：

方法名、参数列表（类型、顺序、数量）必须与父类完全一致。
返回值类型：若父类返回类型为 T，子类返回类型可为 T 或 T 的子类（Java 5+ 支持）。
访问权限：子类重写方法的权限 不能低于 父类（如父类是 protected，子类可为 protected 或 public）。
异常：子类抛出的异常 不能多于 / 严于 父类。
被 final、static 修饰的方法 不能被重写。

注解：推荐使用 @Override 注解显式标识重写方法，编译器会校验是否符合重写规则。

4. 成员访问权限

父类成员的访问权限决定了子类能否直接访问：

public：子类可直接访问。
protected：子类可直接访问（即使不在同一包）。
默认（无修饰符）：仅同包子类可访问。
private：子类 不能直接访问（需通过父类的 public/protected 方法间接访问）。

5. `final` 与继承

被 final 修饰的类 不能被继承（如 String 类）。
被 final 修饰的方法 不能被重写。
被 final 修饰的属性 不能被重写 / 修改（常量）。

四、继承与多态的关联

继承是多态的基础。通过父类引用指向子类对象，可实现 “同一方法，不同实现”：

public class Test {
    public static void main(String[] args) {
        Animal animal1 = new Dog("旺财"); // 父类引用指向 Dog 对象
        Animal animal2 = new Cat("咪咪"); // 父类引用指向 Cat 对象
        
        animal1.move(); // 输出：旺财 四条腿跑（调用 Dog 的 move）
        animal2.move(); // 输出：咪咪 四条腿走（调用 Cat 的 move）
    }
}

class Cat extends Animal {
    public Cat(String name) {
        super(name);
    }
    
    @Override
    public void move() {
        System.out.println(name + " 四条腿走");
    }
}

 

五、继承的注意事项

避免过度继承：多层继承可能导致代码耦合度高、可读性差，推荐 “组合优于继承” 的设计原则。
父类的构造方法不能被继承，但子类必须通过 super 调用父类构造。
子类不能继承父类的 private 成员，需通过父类提供的公共方法访问。
所有类最终都间接继承 Object 类（Java 根类），Object 的方法（如 equals()、toString()）可被所有类重写。

总结：Java 继承通过 extends 实现代码复用和功能扩展，结合方法重写为多态提供支持，是面向对象编程中组织类关系的核心手段。合理使用继承可显著提升代码的可维护性和扩展性。

posted on 2025-09-12 08:59 coding博客阅读(80) 评论(0) 收藏举报

刷新页面返回顶部

coding博客