异常教程

Java 继承（长文解析）

更新时间:

💡一则或许对你有用的小广告

欢迎加入小哈的星球 ，你将获得：专属的项目实战 / 1v1 提问 / Java 学习路线 / 学习打卡 / 每月赠书 / 社群讨论

  • 新项目:《从零手撸：仿小红书（微服务架构）》 正在持续爆肝中，基于 Spring Cloud Alibaba + Spring Boot 3.x + JDK 17...，点击查看项目介绍 ;
  • 《从零手撸：前后端分离博客项目（全栈开发）》 2 期已完结，演示链接： http://116.62.199.48/ ;

截止目前， 星球 内专栏累计输出 82w+ 字，讲解图 3441+ 张，还在持续爆肝中.. 后续还会上新更多项目，目标是将 Java 领域典型的项目都整一波，如秒杀系统, 在线商城, IM 即时通讯，权限管理，Spring Cloud Alibaba 微服务等等，已有 2900+ 小伙伴加入学习 ，欢迎点击围观

在 Java 编程中，继承（Inheritance）是面向对象编程（OOP）的核心概念之一。它允许开发者通过将已有类的属性和方法传递给新类，实现代码的复用与扩展。对于编程初学者而言，理解继承的原理和应用场景，能够显著提升开发效率并减少冗余代码。本文将以通俗易懂的语言，结合具体案例和代码示例，系统性地讲解 Java 继承的核心知识点，并探讨其在实际开发中的应用价值。

一、继承的基本概念

1.1 什么是继承？

继承是指一个类（子类）可以继承另一个类（父类）的属性和方法。通过继承，子类能够直接使用父类的功能，同时还能添加新的属性或方法，或对父类的方法进行扩展和修改。

形象比喻：
可以将继承想象成“家庭关系”。例如，人类（父类）有“行走”和“呼吸”的能力，而程序员（子类）继承了这些能力，同时还能拥有“编写代码”等独特技能。

1.2 父类与子类的关系

  • 父类（Superclass/Parent Class）：被继承的类，通常称为基类或超类。
  • 子类（Subclass/Child Class）：继承父类的类，也称为派生类。

代码示例：

// 父类 Animal
class Animal {
    String name;
    void eat() {
        System.out.println("动物需要进食");
    }
}

// 子类 Dog 继承 Animal
class Dog extends Animal {
    void bark() {
        System.out.println("狗会叫");
    }
}

1.3 继承的语法

Java 中使用 extends 关键字实现继承：

class SubClassName extends SuperClassName {
    // 子类代码
}

注意：Java 支持单继承，即一个子类只能直接继承一个父类，但可以通过多层继承间接扩展多个层级的父类。

二、继承的实现方法

2.1 构造函数的调用规则

当创建子类对象时，会先调用父类的构造函数（无参或有参），再执行子类的构造函数。

案例分析：

class Animal {
    Animal() {
        System.out.println("Animal 构造函数被调用");
    }
}

class Dog extends Animal {
    Dog() {
        System.out.println("Dog 构造函数被调用");
    }
}

// 输出顺序：
// Animal 构造函数被调用  
// Dog 构造函数被调用

关键点：

  • 如果父类没有无参构造函数，子类必须通过 super() 显式调用父类的有参构造函数。
  • super() 必须放在子类构造函数的第一行。

2.2 方法覆盖（Method Overriding）

当子类需要修改父类方法的实现时，可以使用 @Override 注解覆盖父类方法。

代码示例：

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

class Dog extends Animal {
    @Override
    void sound() {
        System.out.println("汪汪叫");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myDog = new Dog();
        myDog.sound(); // 输出：汪汪叫  
    }
}

2.3 访问父类成员

子类可以通过 super 关键字访问父类的成员变量或方法。例如：

class Parent {
    String name = "Parent";
    void show() {
        System.out.println("父类方法");
    }
}

class Child extends Parent {
    String name = "Child";
    void display() {
        System.out.println(super.name); // 输出 Parent  
        super.show(); // 调用父类方法  
    }
}

三、继承的应用场景

3.1 代码复用

继承的核心优势在于减少重复代码。例如，多个图形类（如圆形、矩形）可以继承一个共同的 Shape 类，复用其公共属性（如颜色、坐标）。

案例设计：

class Shape {
    String color;
    void draw() {
        System.out.println("绘制图形");
    }
}

class Circle extends Shape {
    double radius;
    void calculateArea() {
        System.out.println("面积 = πr²");
    }
}

class Rectangle extends Shape {
    double length, width;
    void calculatePerimeter() {
        System.out.println("周长 = 2*(长+宽)");
    }
}

3.2 灵活性与扩展性

通过继承，可以轻松扩展父类的功能。例如，电商平台中，Product 类可以作为父类，而 Electronics、Clothing 等子类可添加特定属性（如 warrantyPeriod 或 size）。

3.3 多态性（Polymorphism）

继承结合多态性，允许父类引用指向子类对象，从而动态调用不同子类的方法。

示例：

class Vehicle {
    void drive() {
        System.out.println("车辆在行驶");
    }
}

class Car extends Vehicle {
    @Override
    void drive() {
        System.out.println("汽车在公路上行驶");
    }
}

class Boat extends Vehicle {
    @Override
    void drive() {
        System.out.println("船只在水面上行驶");
    }
}

public class Main {
    public static void main(String[] args) {
        Vehicle vehicle1 = new Car();
        Vehicle vehicle2 = new Boat();
        vehicle1.drive(); // 输出汽车的行为  
        vehicle2.drive(); // 输出船只的行为  
    }
}

四、继承的注意事项

4.1 继承的局限性

  • 单继承限制：Java 不支持多继承（一个子类无法直接继承多个父类），但可通过接口（Interface）实现类似效果。
  • 继承层级过深的问题：过度使用继承可能导致代码耦合度高，难以维护。

4.2 私有成员的不可继承性

父类的私有方法和属性无法被子类直接访问。例如：

class Parent {
    private void secretMethod() {
        System.out.println("这是父类私有方法");
    }
}

class Child extends Parent {
    void test() {
        secretMethod(); // 编译错误，无法访问私有方法  
    }
}

4.3 继承 vs 组合（Composition）

并非所有场景都适合继承。当需要“具有”某种功能而非“是”某种类型时，应选择组合而非继承。例如，Car 类可以组合一个 Engine 对象，而非继承 Engine 类。

五、案例实践：设计图形系统

5.1 需求分析

构建一个图形系统，要求支持以下功能：

  1. 计算不同图形的面积和周长。
  2. 统一管理图形的绘制逻辑。

5.2 代码实现

// 父类 Shape
abstract class Shape {
    String color;
    abstract double calculateArea();
    abstract double calculatePerimeter();
    void draw() {
        System.out.println("正在绘制 " + this.getClass().getSimpleName());
    }
}

// 子类 Circle
class Circle extends Shape {
    double radius;
    Circle(double radius) {
        this.radius = radius;
    }
    @Override
    double calculateArea() {
        return Math.PI * radius * radius;
    }
    @Override
    double calculatePerimeter() {
        return 2 * Math.PI * radius;
    }
}

// 子类 Rectangle
class Rectangle extends Shape {
    double length, width;
    Rectangle(double length, double width) {
        this.length = length;
        this.width = width;
    }
    @Override
    double calculateArea() {
        return length * width;
    }
    @Override
    double calculatePerimeter() {
        return 2 * (length + width);
    }
}

// 测试类
public class Main {
    public static void main(String[] args) {
        Shape circle = new Circle(5);
        circle.draw();
        System.out.println("面积：" + circle.calculateArea());
        
        Shape rectangle = new Rectangle(4, 6);
        rectangle.draw();
        System.out.println("周长：" + rectangle.calculatePerimeter());
    }
}

5.3 代码分析

  • 抽象类：通过 abstract 关键字定义抽象方法，强制子类实现。
  • 多态性：父类引用 Shape 可指向 Circle 或 Rectangle 对象，动态调用不同方法。

结论

Java 继承是面向对象编程中不可或缺的工具，它通过代码复用、扩展性和多态性，显著提升了开发效率和代码的可维护性。然而，合理使用继承需要开发者深入理解其规则与限制，避免过度依赖继承导致的设计缺陷。

在实际开发中，建议遵循以下原则：

  1. 优先选择组合：当功能复用而非类型继承时，使用组合模式。
  2. 保持继承链简洁：避免过深的继承层级，确保代码结构清晰。
  3. 善用抽象类与接口：通过抽象类定义公共行为，接口实现多接口继承。

掌握 Java 继承的精髓，将帮助开发者构建更优雅、灵活且可扩展的软件系统。

最新发布

查看更多文章