19. 【Java】继承：代码复用的艺术

最新推荐文章于 2026-07-30 09:02:14 发布
原创 最新推荐文章于 2026-07-30 09:02:14 发布 · 277 阅读 · 3 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
收录于
Java: 从入门到精通

当前文章被收录于：

Java: 从入门到精通
26 篇文章 0 人学习

该系列规划了一条从“纯小白“到“项目实战“的学习路径，一共约 60 多篇文章，分为六个阶段：入门篇 ：与Java的第一次握手、基础篇：夯实语法地基、核心篇：面向对象编程、进阶篇：常用API与工具、精通篇：JDK 21新特性与并发、实战篇：项目驱动与生态拓展。欢迎关注。

订阅专栏 查看详情

摘要： 本文深入讲解Java面向对象编程中的继承机制，从重复代码问题引入，详细解析extends关键字、super用法、方法重写规则、构造方法调用链等核心概念。通过学校人员管理系统等实际案例，展示如何通过继承实现代码复用和层次化设计，帮助初学者掌握继承的适用场景与设计考量，为理解多态打下坚实基础。

关键词： Java继承, extends关键字, super关键字, 方法重写, 面向对象编程

在上一篇文章里，我们给代码装上了一道“防护门”——封装。通过把属性设为 private，只暴露受控的方法，我们的类变得安全了、有自我意识了。

今天，我们要给面向对象的大厦添上第二根顶梁柱——继承（Inheritance）。

如果说封装是“横向”地把数据和操作放在一起，那继承就是“纵向”地组织类与类之间的关系，让代码能够一层一层地复用。

1. 一个熟悉的场景：重复的代码

假设你是学校信息系统的开发者。你需要定义几种角色：Student（学生）、Teacher（老师）、Staff（行政人员）。

你会发现，这三者有大量共同的信息：姓名、年龄、联系方式、ID。如果你独立定义三个类，这些字段和方法每个类都要写一遍：

public class Student {
    private String name;
    private int age;
    private String phone;
    private String studentId;
    // getter/setter 大量重复...
}

public class Teacher {
    private String name;
    private int age;
    private String phone;
    private String employeeId;
    // getter/setter 还是大量重复...
}

public class Staff {
    private String name;
    private int age;
    private String phone;
    private String department;
    // 又是大量重复...
}

你发现了问题：代码在重复。修改一个字段的名字，要改三个类；增加一个公共属性，也要改三个类。这不优雅，也不高效。

这时你就会想：能不能把“人”的共同特征提取出来，让 Student、Teacher、Staff 直接“继承”这些共同的东西，然后再加上自己特有的内容？

这就是继承要解决的问题。

2. 什么是继承？—— “父子”关系的建立

继承（Inheritance） 是一种机制，它允许一个类（子类）基于另一个类（父类）来定义，从而获得父类的属性和方法，并可以在此基础上扩展或修改。

  • 父类（Superclass / Parent Class）：被继承的类，也叫基类。它包含了通用的属性和行为。
  • 子类（Subclass / Child Class）：继承父类的类，也叫派生类。它拥有父类的全部属性和方法（除了 private 的），并可以增加自己特有的内容。

打个比方：你觉得“动物”是一个比较宽泛的概念。动物有名字、会吃东西、会移动。在这个基础上，你定义“狗”是动物的一个特例——狗继承了动物的全部特征（名字、吃、移动），但额外增加了“吠叫”的能力。“猫”也继承了动物，但增加了“捉老鼠”的能力。这就是继承：从“一般”到“特殊”的延伸。

用专业术语说：子类是一种（is-a）父类。狗是一种动物，学生是一个人。继承关系表达的是一种 “is-a” 关系。

3. 继承的语法 —— extends

在 Java 中，继承使用 extends 关键字。

// 父类（基类）
public class Person {
    private String name;
    private int age;
    private String phone;

    // 构造方法
    public Person(String name, int age, String phone) {
        this.name = name;
        this.age = age;
        this.phone = phone;
    }

    // getter/setter
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    // ...
}

然后定义子类，用 extends 继承 Person：

// 子类：Student 继承 Person
public class Student extends Person {
    // 新增属性：学号
    private String studentId;

    // 构造方法
    public Student(String name, int age, String phone, String studentId) {
        super(name, age, phone);  // 调用父类的构造方法
        this.studentId = studentId;
    }

    // 新增方法：学习
    public void study() {
        System.out.println(getName() + " 正在学习...");
    }
}

// 子类：Teacher 继承 Person
public class Teacher extends Person {
    private String employeeId;

    public Teacher(String name, int age, String phone, String employeeId) {
        super(name, age, phone);
        this.employeeId = employeeId;
    }

    public void teach() {
        System.out.println(getName() + " 正在讲课...");
    }
}

现在，Student 和 Teacher 都自动拥有了 Person 的 name、age、phone 属性以及它们的 getter/setter，不需要再重复定义了。它们只需要关注自己特有的部分。

4. super 关键字 —— 指向“父辈”的引用

在上面的代码中，你可能已经注意到了 super(name, age, phone); 这个看起来有些神秘的调用。我们来拆解一下。

① super() —— 调用父类的构造方法

子类构造方法的第一条语句，必须调用父类的构造方法（使用 super(...)），以确保父类的属性先被正确初始化。

如果父类有无参构造方法，并且子类没有显式调用 super(...)，Java 会自动帮你调用父类的无参构造。但如果父类只有有参构造（没有无参构造），子类必须显式地用 super(...) 调用。

public class Person {
    private String name;

    // 没有无参构造，只有有参构造
    public Person(String name) {
        this.name = name;
    }
}

public class Student extends Person {
    private int score;

    public Student(String name, int score) {
        super(name);   // 必须显式调用父类的有参构造
        this.score = score;
    }
}

⚠️ 如果父类既有无参构造又有有参构造，子类可以不用显式调用 super()，但如果你需要传入参数，必须显式调用。

② super.xxx —— 访问父类的成员

当子类中定义了和父类同名的属性或方法时，super.xxx 用来明确访问父类的版本。

public class Person {
    protected String name = "Person";
    public void sayHello() {
        System.out.println("Hello from Person");
    }
}

public class Student extends Person {
    private String name = "Student";

    public void test() {
        System.out.println(super.name);    // 输出 "Person"
        System.out.println(this.name);     // 输出 "Student"
        super.sayHello();                 // 调用父类的方法
    }
}

注意：super 和 this 一样，不能用于静态上下文中（因为它们是针对实例的）。

5. 方法重写（Override） —— 子类的“个性化定制”

子类继承了父类的方法，但如果父类的方法在子类的语境下“不适用”，子类可以重新定义该方法——这就是方法重写（Override）。

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

public class Dog extends Animal {
    @Override   // 注解，告诉编译器这是重写，帮你检查
    public void sound() {
        System.out.println("汪汪汪！");
    }
}

public class Cat extends Animal {
    @Override
    public void sound() {
        System.out.println("喵喵喵～");
    }
}

使用：

Animal a1 = new Dog();
a1.sound();   // 输出：汪汪汪！

Animal a2 = new Cat();
a2.sound();   // 输出：喵喵喵～
重写的规则
  • 方法名、参数列表必须完全一致（返回类型可以是父类返回类型的子类型，称为“协变返回类型”，初学暂不深入）。
  • 访问修饰符不能比父类更严格（比如父类是 public，子类不能是 private）。
  • final 方法不能重写，static 方法不能被重写（静态方法属于类，没有“重写”的概念，只能说“隐藏”）。
@Override 注解

@Override 是一个注解，它不改变代码的运行，但给编译器传达了信息：“我要重写父类的方法，请帮我检查一下方法签名是否正确。”如果你写错了（比如拼写错误或参数类型不对），编译器会报错。这是一个很好的习惯，一定要加。

6. 继承中的构造方法调用链 —— 从顶到底

当创建一个子类对象时，JVM 会调用父类的构造方法，然后调用子类的构造方法。从继承链的顶端（Object）到最底端（当前类），一层一层地初始化。

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 构造方法");
    }
}

// 输出：
// Grandparent 构造方法
// Parent 构造方法
// Child 构造方法

记住：父类的构造方法总是先执行。这保证了父类的属性在子类使用之前已经被正确初始化。

7. 单继承 —— Java 的“一个孩子只有一个亲生父亲”

在 Java 中，一个类只能直接继承一个父类（单继承）。这与其他一些语言（如 C++ 支持多继承）不同。

// 这是合法的
public class Student extends Person { ... }

// 这是非法的（编译错误）
public class Student extends Person, Employee { ... }   // ❌

为什么 Java 要这样做？

  1. 避免“菱形继承”问题：如果 A 有方法 m()，B 和 C 都继承自 A 并各自重写了 m()，D 同时继承 B 和 C，那么 D 应该继承谁的 m()？这种歧义在多继承中很容易出现，Java 通过单继承彻底避免了它。
  2. 简化设计：单继承让类的关系更清晰，也更容易理解和维护。

但 Java 提供了接口（Interface） 来实现“多重能力”，我们会在第 22 篇文章中详细讲解。接口允许多实现，可以弥补单继承的不足。

8. 什么时候用继承？—— 设计上的考量

继承是一种强耦合的关系，子类对父类有很强的依赖。所以，使用继承时需要谨慎思考：

✅ 适合用继承的场景：

  • 子类和父类之间存在明显的“is-a”关系（狗是一种动物、学生是一个人）。
  • 子类需要父类的全部或大部分功能，且基本不需要修改父类的行为。
  • 你在构建一个框架或公共库，希望用户通过继承来扩展功能。

❌ 不适合用继承的场景：

  • 只是为了复用代码（比如恰好都有 name 和 age 字段），但逻辑上不属于“is-a”关系。
  • 父类的行为在子类中需要大幅修改（那说明它们可能不应该有继承关系）。
  • 深层继承（超过 3 层）：继承链过长会让代码难以理解和调试。

著名的设计原则：“优先使用组合而非继承”（Favor composition over inheritance）。但那是进阶话题，初学阶段，我们先掌握好继承这个工具。

9. 综合示例 —— 学校人员管理系统

让我们把今天的内容串起来，写一个完整的例子：

// ========== 父类：Person ==========
public class Person {
    private String name;
    private int age;
    private String phone;

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

    // Getter/Setter（省略部分，避免代码过长）
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }

    public int getAge() { return age; }
    public void setAge(int age) { this.age = age; }

    public String getPhone() { return phone; }
    public void setPhone(String phone) { this.phone = phone; }

    // 公共方法
    public void introduce() {
        System.out.println("我是 " + name + "，今年 " + age + " 岁。");
    }
}

// ========== 子类：Student ==========
public class Student extends Person {
    private String studentId;
    private String major;

    public Student(String name, int age, String phone, String studentId, String major) {
        super(name, age, phone);
        this.studentId = studentId;
        this.major = major;
    }

    public String getStudentId() { return studentId; }
    public void setStudentId(String studentId) { this.studentId = studentId; }

    public String getMajor() { return major; }
    public void setMajor(String major) { this.major = major; }

    // 重写 introduce 方法，增加学生特有的信息
    @Override
    public void introduce() {
        super.introduce();   // 调用父类的方法
        System.out.println("我是学生，学号 " + studentId + "，专业 " + major);
    }

    public void study() {
        System.out.println(getName() + " 正在学习 " + major);
    }
}

// ========== 子类：Teacher ==========
public class Teacher extends Person {
    private String employeeId;
    private String title;   // 职称

    public Teacher(String name, int age, String phone, String employeeId, String title) {
        super(name, age, phone);
        this.employeeId = employeeId;
        this.title = title;
    }

    // Getter/Setter 省略...

    @Override
    public void introduce() {
        super.introduce();
        System.out.println("我是老师，工号 " + employeeId + "，职称 " + title);
    }

    public void teach() {
        System.out.println(getName() + " 正在授课");
    }
}

// ========== 主程序 ==========
public class Main {
    public static void main(String[] args) {
        Student s = new Student("张三", 20, "13800001111", "S001", "计算机科学");
        Teacher t = new Teacher("李老师", 35, "13800002222", "T001", "教授");

        System.out.println("=== 学生信息 ===");
        s.introduce();
        s.study();

        System.out.println("\n=== 教师信息 ===");
        t.introduce();
        t.teach();

        // 多态的体现：把子类对象当作父类来使用
        System.out.println("\n=== 多态演示 ===");
        Person p1 = new Student("王五", 22, "13800003333", "S002", "数学");
        p1.introduce();   // 动态绑定：调用的是 Student 的 introduce()
        // p1.study();     // 编译错误！Person 类型没有 study() 方法
    }
}

输出：

=== 学生信息 ===
我是 张三，今年 20 岁。
我是学生，学号 S001，专业 计算机科学
张三 正在学习 计算机科学

=== 教师信息 ===
我是 李老师，今年 35 岁。
我是老师，工号 T001，职称 教授
李老师 正在授课

=== 多态演示 ===
我是 王五，今年 22 岁。
我是学生，学号 S002，专业 数学

10. 今天的总结

今天我们学习了面向对象的第二大特性 —— 继承：

  • 继承：子类通过 extends 获得父类的属性和方法，实现代码复用。
  • super：访问父类的构造方法（super(...)）或父类的成员（super.xxx）。
  • 方法重写（Override）：子类重新定义父类的方法，实现个性化行为。记得加 @Override。
  • 构造调用链：从父类到子类依次构造，层层递进。
  • 单继承：一个子类只能有一个直接父类，避免菱形继承问题。

继承让代码能够复用，让类与类之间形成层次结构，是面向对象中组织和扩展代码的关键工具。

动手试试

  1. 定义一个 Vehicle（交通工具）类，包含 brand、speed 属性和 move() 方法。再定义两个子类 Car 和 Bicycle，Car 增加 engineType 属性和 honk() 方法，Bicycle 增加 hasBell 属性和 ringBell() 方法。各自重写 move() 方法，输出不同的移动方式。

  2. 在上题的基础上，写一个方法 testDrive(Vehicle v)，接收 Vehicle 参数，调用 move() 方法。传入 Car 和 Bicycle 对象，观察多态的效果。

  3. 定义一个 Shape（图形）父类，包含 getArea() 方法（返回 0）。定义 Circle、Rectangle、Triangle 子类，各自实现 getArea() 的计算方法。在 main 中创建一个 Shape 数组，放入不同图形，循环调用 getArea()，打印面积。

  4. （思考）如果你在 Person 类中把 name 设为 private，在 Student 中还能直接访问 name 吗？如果不能，Student 如何获取或修改自己的名字？结合 super 和 getter/setter 来回答。

继承的知识很多，但核心就一条：“子类是一种父类”。牢牢抓住这个“is-a”关系，遇到任何继承场景，先问自己：“这两个类之间是 is-a 关系吗？”如果不是，就不要用继承。

我们下一篇会讲多态——在继承的基础上，让同一个方法表现出不同的行为。它是面向对象的第三大特性，也是让代码真正“活”起来的关键。

我们下一篇见。😃

📌 获取本系列示例代码请访问 GitCode。

标签
#java #开发语言
Python编程基础19：封装、继承与多态
热门推荐
howard2005的专栏
01-26 1万+
文章目录零、本讲学习目标一、类的封装（一）为什么需要封装1、案例演示2、案例分析3、解决方案（二）如何实现封装1、封装的定义（2）封装的实现（3）案例演示 零、本讲学习目标 解如何利用封装保护属性 掌握单继承和多继承，会重写和调用父类方法 理解多态的使用 一、类的封装 （一）为什么需要封装 Python是面向对象的编程语言，因为面向对象中所有的实体都是以对象为基本单位的，以宏观世界的实体来映射到计算机世界中，每个对象有它自己的属性和自己的行为，我们用类来将这些属性和行为封装到一起，当它实例化出来一个
【Python-Day 33】OOP核心之继承（Inheritance）：代码复用与扩展的艺术
吴师兄大模型的博客
07-18 1375
本文是 Python 面向对象编程（OOP）核心概念系列文章的第三篇，将深入探讨“继承”（Inheritance）。继承是面向对象三大特性之一，它允许我们创建一个新类（子类），该类可以获取一个已存在类（父类）的属性和方法，从而实现代码的高度复用和逻辑扩展。本文将从继承的基本概念、语法结构、方法重写（Method Overriding）等多个维度，结合生活中的类比和丰富的代码示例，带您全面掌握 Python 中的继承机制，为构建清晰、可维护的类层次结构打下坚实的基础。
【Java基础知识 19】继承
weixin_60274730的博客
08-30 2392
本文围绕 Java 继承展开，系统讲解其核心内容。首先介绍继承概念，它是 OOP 三大特性之一，子类借extends继承父类非私有成员，实现代码复用与扩展，还给出 “人 - 教师 - 咨询师” 的示例。接着阐述权限修饰符，含private“仅当前类访问” 等 4 种，说明其访问范围及开发中 “成员变量私有、对外接口公开” 的规范。 然后分析继承特点，包括单继承（类仅直接继承一个父类，支持多层继承）、所有类默认继承Object类、子类访问成员遵循就近原则（可借super访问父类成员）。
JAVA类复用的方式：组合和继承 --《JAVA编程思想》19
BaymaxCS的博客
05-22 466
在编程过程中，常常会需要复用一部分代码或者在当前方法的功能上进行拓展，这就需要用到2种代码重用机制：组合和继承。 一、组合 二、继承
19.Java之继承
weixin_37714766的博客
02-09 157
一、继承的概念 继承是OOP(面向对象)的特征之一，它是从已有的类(父类或称超类)中派生出新的类(子类)，子类会自动拥有父类的属性和方法，并且之类可以扩展新的属性和方法。 二、为什么使用继承 这是两张UML图，对于这两个不同的类存在大量代码的重复，继承就是为了减少代码量，将重复代码抽取到父类中。 使用继承优化设计后： 将公共的一些属性和方法提取到父类中，每一个子类只需要编写子类中与父类不同的...
Java_单继承和多继承
12-14 659
1 /* 2 继承： 3 好处：提高了代码的复用性，让类与类之间产生了关系。 4 将对象中的共性内容不断的向上抽取，就形成了关系，就有了继承，有了子父类， 5 提高了代码的复用 6 7 继承特点： 8 1，在Java中只能单继承，多继承的机制被Java语言改良了（Java基于c语言，c支持多继承） 9 单继...
Java基础：复用类
dijian3603的博客
03-16 139
1、复用方式：组合、继承、代理 组合是功能上的复用，继承是形式上的复用，代理位于二者之间。 2、创建一个子类对象时，该对象包含了一个基类的子对象。这个子对象与用基类直接创建的对象是一样的。二者的区别在于：后者来自于外部，而子对象被包装在子类对象内部。 3、基类的无参构造器可以隐式地自动被调用，有参构造器必须被显式地调用（通过super关键字）。 子类构造器中调用基类构造器的语句须...
19 面向对象三大特征——继承
小安的博客
07-27 505
意味着，动物的特性，哺乳动物都有；在我们编程中，如果新定义一个Student类，发现已经有Person类包含了我们需要的属性和方法，那么Student类只需要继承Person类即可拥有Person类的属性和方法。继承是面向对象编程的三大特征之一。从英文字面意思理解，extends的意思是“扩展”。开个玩笑：你可以继承父亲的密码箱，但不见得你能直接打开。你能继承你父亲的情书，但你没法直接使用。是二元运算符，左边是对象，右边是类；本文重点针对面向对象编程的三大特征：继承、封装、多态进行详细的讲解。
Java学习笔记 继承与抽象类：类的继承
qq_39286015的博客
11-19 581
1.继承的概念 （1）什么是继承？ 两个类之间的一种关系 父类（Super ClassParent Class），子类（Children Class） Student类具有所有Person类共性的特点同时还具有自己特有的特点 例：学生是在上学的人 （2）继承的特点 基于现有类构建新类 在父类基础上建立子类 继承可以实现代码再利用 （3）Java中的继承 一个类可以有多个子类，任何一个类都只有一个单一的父类 Java语言只支持单重继承 单重继承的优势：安全，可靠性 2.继承的实现 继承的语法 子类利用父
java类继承语法_java类的继承（基础）
weixin_36308872的博客
02-13 1015
---恢复内容开始---这篇随笔和大家讲讲java中类的继承是什么？希望对你们有所帮助。目录一、java继承是什么？二、为什么使用java继承三、java继承的实现1.1 java继承的基本语法1.2 super的用法一、Java继承是什么？简单来讲，Java中的继承是一个对象获取父对象的所有属性和行为的机制。它是面向对象编程系统(OOP)的重要组成部分。Java中继承的思想是，创建基于现有类...
java小白日记19（继承！！！）
2301_78068233的博客
12-13 221
继承是面向对象编程中的一个基本概念，它允许一个类（称为子类或派生类）继承另一个类（称为父类或基类）的属性和方法。继承机制可以促进代码的复用，使得子类能够继承父类的特性，同时还可以添加新的属性和方法或者覆盖（重写）父类中的方法。
JAVA继承和多态详细讲解
weixin_45536242的博客
07-08 3581
面向对象编程的重要知识：继承和多态。通过类的继承机制，可以使用已有的类为基础派生出新类，无需编写重复的程序代码，很好地实现程序代码复用。多态是面向对象编程中继封装和继承之后的另一大特征，它具体是指同一个行为具有多个不同表现形式或形态的能力。使用多态机制，可以提高程序的抽象程度和简洁性，最大程度地降低类和程序模块间的耦合性，并提高程序的可扩展性和可维护性。从Java语言的底层逻辑上看，封装和继承是为实现多态做准备的。6.1 类的继承继承描述了类的所属关系，多个类通过继承可形成一个关系体系，进而在原有类的基础上
19、深入理解Java中的继承机制
m2n3b4v5c6的博客
06-10 319
本文深入探讨了Java中的继承机制，包括继承的基本概念、成员继承规则、构造函数的使用、方法隐藏与字段隐藏、方法覆盖、上转型和下转型等内容。同时介绍了抽象类和方法、最终类和方法，以及多态性的应用。通过多个示例代码展示了如何在实际开发中有效利用继承特性，并分析了继承的优点和缺点，帮助开发者更好地理解和应用面向对象编程的核心理念。
java中的类继承只有什么样的继承_java中类继承，到底继承了什么？
weixin_35934603的博客
02-28 179
继承的最大好处就是为了实现代码的复用。那么，子类到底从父类得到的什么呢？实例成员父类的private成员不会被子类继承，子类不能访问。但是子类对象的确包含父类的私有成员。父类的 包访问成员 继承为子类的包访问成员。就好像他们直接定义在子类中一样。父类的 protected 成员继承为子类的protected 成员。就好像他们直接定义在子类中一样。父类的 public 成员继承为子类的public ...
Java中继承的目的
MySenvens的专栏
08-19 2499
LZ第一次写博文，语言组织不好，请大牛勿喷。          关于JAVA的继承相信很多人都知道，这是面相对象三大基本基本特征（封装，继承，多态）之一，当时LZ学到继承的时候就发现一个问题我们什么时候该用继承， （有人开始解释：继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。通过继承创建的新类称为“子类”或“派生类”被继承的类称为“基
Java 继承与多态
weixin_57463832的博客
06-15 2186
.1包 在生活中，保存文档时会经常使用文件夹，把不同类型的文档归类，然后分放到不同的文件夹中，便于管理和查找。在计算机中保存电子文档也不例外，如我们看到的Windos系统中的树形目录结构。在复杂的文件系统中，文件分门别类地存储在不同的文件夹中，解决了文件同名冲突的问题。事实上，在编写复杂程序的过程中，也会遇到同样的问题。Java以类组织程序，开发一一个大型的工程需要成百上千个类。如果要求开发人员确保自己所用的类名不与其他开发人员选择的类名相冲突，这是非常困难的。例如，开发人员定义-一个Sort类，使用...
java对象的继承_JAVA面向对象 - 继承
weixin_39955233的博客
02-20 179
继承可以解决代码的复用，让我们的编程更加靠近人类思维，当多个类存在相同的属性和方法时，可以从这些类中抽象出父类，在父类中定义这些相同的属性和方法，所有的子类不需要重新定义这些属性和方法，只需要通过extends语句来声明继承。注意事项Ⅰ.java 中支持单继承，不直接支持多继承，但对c++中的多继承机制进行改良。Ⅱ.ava支持多层(多重)继承Ⅲ.Java所有类都是Object类的子类Ⅳ.JDK中有...
【Java高级特性实战】：为什么Java 19禁止记录类继承密封类？
StepNexus的博客
11-17 605
掌握Java 19密封类设计关键限制，本文解析记录类无法继承密封类的原因与最佳实践。涵盖Java 19密封类的记录实现限制，适用于模式匹配与不可变数据建模场景，提升类型安全性。值得收藏
Java继承
asm2826的博客
09-02 185
继承的特性 子类拥有父类非private的属性，方法。 子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。 子类可以用自己的方式实现父类的方法。 Java的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如A类继承B类，B类继承C类，所以按照关系就是C类是B类的父类，B类是A类的父类，这是java继承区别于...
JsonUtils.toBean vs ObjectMapper.readValue 完整对比
最新发布
devilnumber的博客
07-30 292
摘要： Jackson的ObjectMapper.readValue()与Hutool的JsonUtils.toBean()均用于JSON反序列化，但存在关键差异： 底层管理：前者需手动配置ObjectMapper实例，灵活性高；后者封装全局单例ObjectMapper，简化代码但配置不可局部修改。 核心差异： 未知字段：Hutool默认忽略未知字段，Jackson需手动关闭FAIL_ON_UNKNOWN_PROPERTIES。 Spring整合：Hutool独立配置易与Spring MVC序列化规则冲突，
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值