Java 继承详解

原创 已于 2025-07-31 23:06:57 修改 · 1.2k 阅读 · 30 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #开发语言

于 2025-07-31 21:28:16 首次发布

1. 引言

  • 什么是继承？：

    继承是指面向对象编程中实现代码复用的核心机制。它允许开发者基于现有类创建新类​（称为派生类），在保留原有类特性的同时进行功能扩展。这种机制不仅体现了面向对象程序设计的层次化结构，也符合从简单到复杂的认知规律。​继承的核心价值在于提取共性特征，从而高效实现代码复用。

  • 为什么使用继承？：

    在项目开发中，多个类经常需要定义相同属性，​直接重复定义会导致代码冗余。通过继承机制，不仅能消除重复代码，其层次化结构还能提升代码可读性和可维护性。

    在图书馆管理系统中，​书籍分类管理是一个典型场景。假设系统需要管理三种类型的书籍：​普通书籍、电子书和稀有古籍。如果不使用继承，每类书籍都需要独立定义属性​（如书名、作者、ISBN）和方法​（如借阅、归还），导致大量重复代码。例如，​电子书和稀有古籍都需要重复定义与普通书籍相同的借阅逻辑，仅因存储方式或保护措施不同而略有差异。这种实现方式不仅增加维护成本，在新增书籍类型​（如有声书）时还需从头编写所有功能。

    简单来说，各类图书虽然形式各异，但都具备一些共性特征。例如，所有图书都包含书名和作者信息，都可以进行借阅和归还。在此基础上，​电子书额外具有文件格式和下载链接等属性；古籍则需要特别记录保存温度和修复状态等信息。未来如果要新增有声书类型，只需说明它与其他图书一样具有基本属性，再补充音频时长这一特殊项即可。这种设计既避免了重复定义共性特征，又能清晰体现电子书、古籍等作为"​图书​"这一基础类型的衍生特性，为系统升级和维护提供了便利。

2. Java继承基础

  • 2.1 语法基础：

    • 使用关键字extends来实现继承，具体格式如下：
      • 修饰符 class （子类）类名 extends （父类）类名{ }
      • Modifier class subclassName extends parentClassName{
    //
}

  • 2.2 示例

  • 2.2.1 基本示例：
    class Vehicle {
    void start() {
        System.out.println("Vehicle started");
    }
}

class Car extends Vehicle {
    // 子类继承父类方法
}

    上述例子中，Car为子类，继承父类Vehicle.
    *此时 Car也叫做 派生类

  • 2.2.2 实例：

    • 假设现在有一个手机类别，包含Xiaomi手机，Huawei手机，Apple手机，并定义它们的产品特性与功能。我们可以对比使用继承和不使用继承两种实现方式的区别

      • 不使用继承

    • class ApplePhone{
    String model;
    String cpu;

    String system;

    public ApplePhone(String model, String cpu,String system) {
        this.model = model;
        this.cpu = cpu;
        this.system = system;
    }

    public void powerOn() {
        System.out.println(this.model + "正在开机");
    }
    public void powerOff() {
        System.out.println(this.model + "正在关机");
    }

    public void useSystem() {
        System.out.println(this.model + " 使用的是 " + this.system);
    }
}
class HuaweiPhone{
    String model;
    String cpu;

    String system;

    public HuaweiPhone(String model, String cpu,String system) {
        this.model = model;
        this.cpu = cpu;
        this.system = system;
    }

    public void powerOn() {
        System.out.println(this.model + "正在开机");
    }
    public void powerOff() {
        System.out.println(this.model + "正在关机");
    }

    public void useSystem() {
        System.out.println(this.model + " 使用的是 " + this.system);
    }
}

class XiaomiPhone{
    String model;
    String cpu;

    String system;

    public XiaomiPhone(String model, String cpu,String system) {
        this.model = model;
        this.cpu = cpu;
        this.system = system;
    }

    public void powerOn() {
        System.out.println(this.model + "正在开机");
    }
    public void powerOff() {
        System.out.println(this.model + "正在关机");
    }

    public void useSystem() {
        System.out.println(this.model + " 使用的是 " + this.system);
    }
}
public class PhoneNonInheritance {
    public static void main(String[] args) {
        ApplePhone iphone15ProMax = new ApplePhone("15","A17 Pro","ios");
        HuaweiPhone huaweiMate40Pro = new HuaweiPhone("Mate40 Pro","麒麟9000","HarmonyOS");
        XiaomiPhone xiaomi15Ultra = new XiaomiPhone("15 Ultra","SM8850","HyperOS");

        iphone15ProMax.powerOn();
        iphone15ProMax.powerOff();
        iphone15ProMax.useSystem();
        System.out.println("==================");
        huaweiMate40Pro.powerOn();
        huaweiMate40Pro.powerOff();
        huaweiMate40Pro.useSystem();
        System.out.println("==================");
        xiaomi15Ultra.powerOn();
        xiaomi15Ultra.powerOff();
        xiaomi15Ultra.useSystem();
    }
}
      • 使用继承：
    • class Phone{
    String model;
    String cpu;

    String system;

    public Phone(String model, String cpu,String system) {
        this.model = model;
        this.cpu = cpu;
        this.system = system;
    }

    public void powerOn() {
        System.out.println(this.model + " 正在开机");
    }
    public void powerOff() {
        System.out.println(this.model + " 正在关机");
    }

    public void useSystem() {
        System.out.println(this.model + " 使用的系统是 " + this.system);
    }
}
class ApplePhone extends Phone{
    public ApplePhone(String model, String cpu, String system) {
        super(model, cpu, system);
    }
}
class HuaweiPhone extends Phone{
    public HuaweiPhone(String model, String cpu, String system) {
        super(model, cpu, system);
    }
}

class XiaomiPhone extends Phone{
    public XiaomiPhone(String model, String cpu, String system) {
        super(model, cpu, system);
    }
}
public class PhoneInheritance {
    public static void main(String[] args) {
        ApplePhone iphone15ProMax = new ApplePhone("Apple 15","A17 Pro","ios");
        HuaweiPhone huaweiMate40Pro = new HuaweiPhone("Huawei Mate40 Pro","麒麟9000","HarmonyOS");
        XiaomiPhone xiaomi15Ultra = new XiaomiPhone("Xiaomi 15 Ultra","SM8850","HyperOS");
        Phone[] phones = {iphone15ProMax,huaweiMate40Pro,xiaomi15Ultra};
        for (Phone phone : phones) {
            phone.powerOn();
            phone.powerOff();
            phone.useSystem();
            System.out.println("==================");
        }
    }
}

从代码中可以明显看出，采用继承机制的实现方式大幅减少了代码量。当需要扩展手机属性时，使用继承机制只需在父类Phone中添加一次属性即可，而无需继承的方案则必须在每个子类中重复添加。这充分体现了继承机制对开发效率的提升作用。此外，若HuaweiPhone需要添加特殊属性，仅需在该子类中单独实现，完全不会影响其他两个类的功能

2.3 子类中访问父类的成员方法

        当通过 extends 关键字 继承了父类的方法和字段，就可以直接访问父类的成员/方法
                通过 子类对象 . 父类成员 /方法的形式访问父类成员/方法

  1.   成员方法名称不同
    class Base {
    public void testBase() {
        System.out.println("调用一个无参的基类的方法");
    }
}
class Derived extends Base {
    public void testDerived() {
        System.out.println("调用一个无参的派生类的方法");
    }
}
public class Test {
    public static void main(String[] args) {
        Derived derived = new Derived();
        derived.testBase();
        derived.testDerived();
    }
}

    运行结果：

            调用一个无参的基类的方法

            调用一个无参的派生类的方法

  2.   成员方法名称相同
    class Base {
    public void test() {
        System.out.println("调用一个无参的基类的方法");
    }
}
class Derived extends Base {
    public void test() {
        System.out.println("调用一个无参的派生类的方法");
    }
}
public class Test {
    public static void main(String[] args) {
        Derived derived = new Derived();
        derived.test();
    }
}

    运行结果：调用一个无参的派生类的方法

    【结论】

  • 当成员方法没有同名时，通过子类对象访问成员会优先查找子类自身的成员。若子类中不存在该成员，则会继续向上在父类中查找。若父类中也不存在该成员，则会导致编译报错。

2.4 构造方法 

        2.4.1 子类构造方法 隐式 调用父类构造方法
  • 父类 无 显示构造方法
    • 子类 无 显示构造方法

      • 此时，编译器会自动生成一个无参构造方法。具体实现如下代码所示（注释部分展示了编译器默认生成的构造方法）：

      • class Base {
    /*public Base() {
        // 空实现
    }*/
}

class Derived extends Base {
    /*public Derived() {
        super();//编译器自动添加
    }*/
}
    • 子类 有 显示构造方法

      • 当构造方法的第一行没有显式调用 super 时，编译器会自动生成一个 super() 调用，隐式执行父类的无参构造方法。

      • class Base {
    /*public Base() {
        
    }*/
}
class Derived extends Base {
    public Derived(int x) {
        super();//编译器自动添加
        System.out.println("Derived()");
    }
}
  • 父类 包含 显示构造方法
    • 子类 无 显示 构造方法

      • 父类 为 无参 构造方法

        • 此时 子类会默认生成 注释掉的内容，进行隐式调用父类无参构造方法

        • class Base {
    public Base() {
        //xxxxx
    }
}
class Derived extends Base {
    /* public Derived(int x) {
        super();//编译器自动添加
    }*/
}

​

      • 父类 为 含参 构造方法

        • 此时 编译报错，需要进行显示调用

        • //error！！！

class Base {
    public Base(int x) {
        //xxxxx
    }
}
class Derived extends Base {
    /* public Derived(int x) {
        super(x);//手动显示调用
    }*/
}

      2.4.2 子类构造方法 显式 调用父类构造方法

  • 当 ​父类​ 与 ​子类​ 均显示定义了构造方法，且 ​父类为含参构造方法​ 时

    • class Base {
    public Base(int x) {
        System.out.println(x);
    }
}
class Derived extends Base {
    public Derived(int x) {
        super(x);
    }
}

重要提示：在创建子类对象时，必须先调用父类的构造方法，然后再执行子类自身的构造方法。

3. 核心机制详解

  • 方法重写（Override）：子类重写父类方法，实现多态行为。
    • 触发方式：
      • 当子类与父类的方法名，参数列表一致时，便会发生方法的重写

注：

  • 当子类与父类的方法名，参数列表一致时：

    • 如果父类方法返回类型为 ​void，则子类也必须为 ​void，否则编译错误

    • 如果父类方法返回类型为基本数据类型​（如 int），子类必须返回相同的基本类型，不能修改为其他类型（如 long）

    • 如果父类方法返回类型为引用类型​（如 Animal），子类可以返回相同类型或其子类​（如 Dog，假设 Dog 是 Animal 的子类），这称为协变返回类型​（Java 5+ 支持）

  • 访问修饰符规则： 

    • 子类方法的访问权限必须不低于父类方法（即访问范围不能缩小）。具体规则如下：

      • 当父类方法为 protected 时，子类方法可以是 protected 或 public
      • 当父类方法为 public 时，子类方法必须保持 public（不能降低访问级别）

    • 特殊说明：
      对于 private 方法：由于对子类不可见，子类无法重写该方法，只能定义同名新方法（这不属于方法重写）

  • final ：

    • 使用 final 修饰的类无法被继承，因此无法用于需要继承的场景。

访问修饰限定符
NO.范围privatedefaultprotectedpublic
1同一包中的同一类√√√√
2同一包中的不同类√√√
3不同包中的子类√√
4不同包中的非子类√
0权限大小private＜defualt＜protected＜public
  • 示例代码： 
    • class Base {
    public void test() {
        System.out.println("Base-test()::调用一个无参的基类的方法");
    }
}
class Derived extends Base {
    public void test() {
        System.out.println("Derived-test()::调用一个无参的派生类的方法");
    }
}
public class Test {
    public static void main(String[] args) {
        Base base = new Base();
        base.test();
    }
}

      运行结果：Base-test()::调用一个无参的基类的方法

  • super关键字：在子类中访问父类成员。
    • 用途：
      • 调用父类成员方法/属性(super.xxx)
      • 调用父类构造方法（super（ ））
        • 在调用父类构造方法时，super();只能在子类构造方法总的第一行

注意事项：

  1. 只能直接访问父类
            super 的调用不能跨级跳转。例如，当 C 类继承 B 类，B 类又继承 A 类时，C 类通过 super 只能访问直接父类 B 的方法，无法直接访问祖父类 A 的方法。
  2. 禁止跨级语法（super.super）
           ​super.super​ 是无效语法
  3. 间接访问祖父类的方法
           在父类B中显示调用A（super.xxx），在由C间接调用
  • 示例： 
    • class Base {
    public void test() {
        System.out.println("Base-test()::调用一个无参的基类的方法");
    }
    public Base() {
        System.out.println("Base()::调用一个无参的构造方法");
    }
}
class Derived extends Base {

    public Derived() {
        super();//调用父类的构造方法
        System.out.println("Derived()::调用一个无参的构造方法");
    }
    public void test() {
        System.out.println("Derived-test()::调用一个无参的派生类的方法");
        super.test();//调用父类的 test方法
    }
}
public class Test {
    public static void main(String[] args) {
        Derived derived = new Derived();
        derived.test();
    }
}

      运行结果：

                      Base()::调用一个无参的构造方法
                      Derived()::调用一个无参的构造方法
                      Derived-test()::调用一个无参的派生类的方法
                      Base-test()::调用一个无参的基类的方法

  • final关键字：限制继承（final class不可继承）或方法重写（final method不可重写）。

3.继承方式

现实世界中，事物之间的联系往往错综复杂且灵活多变。例如：

那么在Java中 支持的继承方式有如下几种：

在Java中 并不支持 多继承

其次 在多层继承的前提下，不建议出现超过三层的继承关系

4.继承与组合

组合和继承都能实现代码复用，但两者实现方式不同。组合不需要特定的语法（如继承中的extends关键字），而是通过将其他类作为字段来实现功能复用。

以手机制造为例：一部手机由电池、主板、CMOS、尾插、扬声器、震动马达、屏幕、SOC、UFS、RAM和通信模块等部件组成。这些部件可以由不同厂商（如Xiaomi、Apple或Huawei）进行组装，最终贴上各自的品牌标识。

在Java中理解组合：

  1. 每个手机部件都可以封装成独立类：

    • 电池类包含型号、容量等属性
    • CMOS类包含型号、尺寸、进光量等参数

  2. 手机厂商只需：

    • 了解需要哪些组件类
    • 将这些类实例组合起来
    • 完成手机的整体组装

这种模块化的设计方式就是组合的典型应用。

组合示例代码

class Cmos{
    String brand;//品牌
    String type;//型号

    public Cmos(String brand, String type) {
        this.brand = brand;
        this.type = type;
    }
}
class Battery{
    int batteryCapacity;//电池容量
    String brand;//品牌
    String type;//型号

    public Battery(int batteryCapacity, String brand, String type) {
        this.batteryCapacity = batteryCapacity;
        this.brand = brand;
        this.type = type;
    }
}
class Soc{
    String type;//型号
    String brand;//品牌

    public Soc(String type, String brand) {
        this.type = type;
        this.brand = brand;
    }
}
class Phone{
    private Soc soc;
    private Cmos cmos;
    private Battery battery;
    //上述就为组合

    public String brand;//手机品牌
    public String type;//手机型号
    public double weight;//手机重量
    public String color;//手机颜色

    public Phone(Soc soc, Cmos cmos, Battery battery, String brand, String type, double weight, String color) {
        this.soc = soc;
        this.cmos = cmos;
        this.battery = battery;
        this.brand = brand;
        this.type = type;
        this.weight = weight;
        this.color = color;
    }
}
public class Test {
    public static void main(String[] args) {
        // 创建手机组件
        Soc snapdragon8Elit = new Soc("Snapdragon 8 Elit", "Qualcomm");
        Cmos sonyIMX989 = new Cmos("Sony", "IMX989");
        Battery xiaomiBattery = new Battery(5000, "Xiaomi", "BM58");

        // 创建小米15 Ultra手机
        Phone Xiaomi15Ultra = new Phone(
                snapdragon8Gen3,
                sonyIMX989,
                xiaomiBattery,
                "Xiaomi",
                "15 Ultra",
                225.0,  // 重量（克）
                "Ceramic Black" // 颜色
        );
    }
}

end *

[JAVA] 图书管理系统
weixin_55250388的博客
05-16 2838
管理员主要分为: 查找图书, 新增图书, 删除图书, 显示图书, 退出图书普通用户主要分为: 查找图书, 借阅图书, 归还图书, 退出系统。
图书系统（多继承）
SChenlyx
03-24 625
编写一个程序，其中有一个书类book，该类的数据成员包括：书号、书名、出版社和定价；有一个作者类author，该类的数据成员包括：姓名、年龄和写作时间，每个类都有相应的数据输入、输出。以此两个类为基类，派生出图书查询卡card，并增加一个数据成员表示书籍系统名称，及一个可以显示系统名称、书名、作者、作者年龄、出版社和定价等数据的函数。 注： 输入数据内容有 系统名称 图书编号 图书名 出版社 ...
Java继承详解
a15766649633的博客
03-03 1120
如果类存在多级继承关系，则在创建一个子类对象时，构造方法的调用规则会多次向更高一级父类传递，一直到执行顶级父类Object类的无参构造方法为止;子类的构造方法默认调用父类无参构造方法，在这种情况下，无论是否使用super()语句,执行结果都相同;
java继承详解
cjhcjq122108的博客
08-26 1348
多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。多个类可以称为子类，单独这个类称为父类超类或者基类。使用extends关键词class 父类 {class 子类 extends 父类 {继承之后，子类自动拥有父类的属性与方法（一般，有部分特殊情况）
Java继承（超详解）
热门推荐
m0_52896041的博客
07-18 3万+
继承是面向对象的三大特征之一，可以使得子类具有父类的属性和方法，还可以在子类中重新定义，追加属性和方法。继承是指在原有类的基础上，进行功能扩展，创建新的类型。继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。JAVA中类只有单继承，没有多继承!继承是类和类之间的一种关系。除此之外,类和类之间的关系还有依赖、组合、聚合等。继承关系的两个类，一个为子类(派生类),一个为父类(基类)。子类继承父类,使用关键字extends来表示。子类和父类之间,从意义上讲应该具有"is a"的关系。
Java继承全解析（超详解版
2301_76937176的博客
07-11 2050
这是因为：在了解继承的概念并通过例子发现，在子类对象中的成员实际上是由两部分组成，继承父类的成员和自己新增加的成员，所以在构造子类对象的时候，先要调用父类的构造方法，讲父类继承下来的成员构造完整，然后再调用子类自己的构造方法，将子类自己新增加的成员初始化完整。假设有两种动物，分别是猫和狗，可以将其定义为两个类，一个类是猫，一个类是狗，猫可以有自己的名字、年龄、体重等，和一些行为正在吃饭、正在喵喵叫~~~等，狗也可以有自己的名字、年龄、体重，和一些行为正在吃、正在汪汪叫~~~等。可以在不同的包中的子类使用。
java--继承（详解）
2302_81090306的博客
10-17 3644
本文详细讲解了什么是继承，继承的概念，继承的方式等等。。快来一起学习吧！！！
java继承详解加练习题
weixin_54107527的博客
11-21 2155
继承 继承是面向对象三大特征之一，可以使得子类具有父类的属性和方法，还可以在子类中重新定义，以及追加属性和方法 继承的好处 提高了代码的复用性（多个类相同的成员可以收到同一个类中） 提高了代码的维护性（如果方法的代码需要修改，修改一处即可） 继承弊端 继承让类与类之间产生了关系，类的耦合性增强了，当父类发生变化时子类实现也不得不跟着变化，削弱了子类的独立性 继承中变量的访问特点 在子类方法中访问一个变量，采用的是就近原则。 子类局部范围找 子类成员范围找 父类成员范围找 如果都没有就报错(不考虑父亲的父亲
Java 继承详解（extends）
qq_43751200的博客
03-13 2万+
继承概述 问题1：什么是继承、继承的好处？ 继承就是java允许我们用extends关键字，让一个类和另一个类建立起一种父子关系。 提高代码复用性，减少代码冗余，增强类的功能扩展性。 问题2：继承的格式？ 子类 extends父类 问题3：继承后子类的特点？ 子类 继承父类，子类可以得到父类的属性和行为，子类可以使用。 Java中子类更强大 代码示例： 继承的设计规范、内存运行原理 继承的特点 继承的特点 1、子类可以继承父类的属性和行为，但是子类不能继承父类的构造器。 2、Java是单继承模式：
java教程之java继承示例详解
09-04
"java继承示例详解" java继承是指新定义的类从已有的类中获取属性和方法的现象。这个已有的类叫做父类，而从这个父类获取属性和方法的类叫做子类。继承的主要优点是提高了代码的重用性，让类和类之间产生了关系，为...
TensorRT笔记（5）：研究timingCache
ouliten的博客
12-02 1005
在里出现了大量的timingCache，但是当时没有取研究这是干啥的，本文就来解析一下。样例都基于上面的文章。
MVP改成MVVM模式
u014035162的专栏
12-05 550
面将登录示例改造成（基于 Android Jetpack 的 ViewModel + LiveData + DataBinding），核心是抛弃 Presenter 中间层，通过 ViewModel 管理数据和业务逻辑，LiveData 实现数据驱动 UI，DataBinding 简化视图与数据的绑定。
零基础学JAVA--Day41(IO文件流+IO流原理+InputStream+OutputStream)
最新发布
Dxxyyyy的博客
12-05 553
文件在程序中是以流的形式来操作的流：数据在数据源（文件）和程序（内存）之间经历的路径输入流：数据从数据源（文件）到程序（内存）的路径输出流：数据从程序（内存）到数据源（文件）的路径。
基于Springboot2+Vue2的旅游景点购票系统
自学网站s.jf3q.com,菜鸟的成长之路
12-02 656
本系统是一个集旅游景点信息展示、在线购票、用户游记分享与互动交流于一体的综合性平台。核心价值在于提供便捷的景点门票预订服务，同时构建活跃的旅游社区，促进用户间的经验分享。
Java 缓冲区优化
qq_43427354的博客
12-02 687
在 Java 中，缓冲区（Buffer） 是一块用于临时存储数据的内存区域，核心作用是协调数据生产者和消费者的速度差异，减少频繁 I/O 操作或数据拷贝的开销，提升程序性能。它本质是 “数据中转站”，避免了直接对原始数据源（如文件、网络流、数组）的频繁读写，通过 “批量处理” 优化效率。
【Android逆向工程】第8章：Frida 高级应用：函数追踪与 RPC 调用
w987333120的博客
12-01 392
本文介绍了Frida框架的核心功能与应用技巧，包括函数调用栈追踪、RPC机制、批量Hook、内存操作和脚本模块化等关键技术。重点讲解了Thread.backtrace()和DebugSymbol.fromAddress()的用法，提供Java和Native函数的调用栈追踪示例，并展示了调用栈过滤与分析方法。最后通过实战案例演示登录流程追踪和RPC调用，同时给出常见问题解决方案。这些技术可有效提升逆向分析效率，适用于移动应用安全测试场景。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值