当前位置：首页 > news >正文

八. 深入理解 Java 继承：概念、应用与最佳实践

news 来源：原创 2025/6/30 2:11:09

hello！这里是敲代码的小董，很荣幸您阅读此文，本文只是自己在学习JAVA过程中的笔记，如有不足，期待您的评论指点和关注，欢迎欢迎~~

✨✨个人主页：敲代码的小董

💗💗系列专栏：JAVA

1. 为什么需要继承

2. 继承概念

3. 继承的语法

4. 父类成员访问

4.1 子类中访问父类的成员变量

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

5. super 关键字

6. 子类构造方法

7. super 和 this

8. 再谈初始化

9. protected 关键字

10. 继承方式

11. final 关键字

11.1 final 类

11.2 final 方法

11.3 final 变量

12. 继承与组合

13. 继承的最佳实践

14. 常见问题与陷阱

上一节：七. JAVA类和对象（四）-CSDN博客

1. 为什么需要继承

在软件开发的世界里，代码的复用性和可维护性至关重要。想象一个场景，你正在开发一个学校管理系统，其中涉及学生、教师和管理人员。这些角色都有一些共同的属性，比如姓名、年龄，也有一些共同的行为，像登录系统。如果为每个角色都编写重复的代码来实现这些属性和行为，不仅会让代码变得冗长，还会增加维护的难度。一旦需要修改这些共同的属性或行为，就需要在多个地方进行修改，容易出错。

比如：狗和猫，它们都是一个动物。

使用Java语言来进行描述，就会设计出：

通过观察上述代码会发现，猫和狗的类中存在大量重复，如下所示：

继承的出现就是为了解决这个问题。它允许我们创建一个通用的父类，将这些共同的属性和行为放在父类中，然后让各个子类继承这个父类。这样，子类就可以自动拥有父类的属性和行为，从而实现代码的复用。同时，如果需要修改共同的属性或行为，只需要在父类中进行修改，所有子类都会受到影响，大大提高了代码的可维护性。

2. 继承概念

继承是面向对象编程（OOP）的基本特性之一，它描述了类与类之间的一种关系。在继承关系中，有父类（也称为基类、超类）和子类（也称为派生类）。子类可以继承父类的属性和方法，并且可以在此基础上添加自己的属性和方法，或者重写父类的方法以实现不同的行为。这种关系体现了一种 “is - a” 的逻辑，即子类是父类的一种特殊类型。例如：狗和猫都是动物，那么我们就可以将共性的内容进行抽取，然后采用继承的思想来达到共用。

上述图示中，Dog和Cat都继承了Animal类，其中：Animal类称为父类/基类或超类，Dog和Cat可以称为Animal的子类/派生类，继承之后，子类可以复用父类中成员，子类在实现时只需关心自己新增加的成员即可。
从继承概念中可以看出继承最大的作用就是：实现代码复用，还有就是来实现多态。

3. 继承的语法

在 Java 中，使用 extends 关键字来实现继承。其基本语法如下：

class 父类名 {
    // 父类的成员变量和方法
}

class 子类名 extends 父类名 {
    // 子类的成员变量和方法
}

对 1.为什么需要继承中场景使用继承方式重新设计：

Animal.java

public class Animal{
    String name;
    int age;
    public void eat(){
        System.out.println(name + "正在吃饭");
    }
    public void sleep(){
        System.out.println(name + "正在睡觉");
    }
}

Dog.java

public class Dog extends Animal{
    void bark(){
        System.out.println(name + "汪汪汪~~~");
    }
}

Cat.Java

public class Cat extends Animal{
    void mew(){
        System.out.println(name + "喵喵喵~~~");
    }
}

在这个示例中，Animal是父类，Dog、Cat是子类。Dog、Cat类继承了Animal类的name、age成员变量和 eat( )、sleep( ) 方法，并且添加了自己的 brak( )、mew( ) 方法。

注意：

子类会将父类中的成员变量或者成员方法继承到子类中了.
子类继承父类之后，必须要新添加自己特有的成员，体现出与基类的不同，否则就没有必要继承了.

4. 父类成员访问

在继承体系中，子类将父类中的方法和字段继承下来了，那在子类中能否直接访问父类中继承下来的成员呢？

4.1 子类中访问父类的成员变量

子类和父类不存在同名成员变量：

当子类和父类不存在同名成员变量时，子类可以直接访问父类的成员变量。示例代码如下：

class Parent {
    int parentVar = 10;
}

class Child extends Parent {
    public void printParentVar() {
        System.out.println(parentVar);
    }
}

在这个例子中，Child 类的 printParentVar() 方法可以直接访问类 Parent 的 parentVar 成员变量。

子类和父类成员变量同名：

class Parent {
    int a;
    int b;
    int c;
}
class Child extends Parent{
    int a;     // 与父类中成员a同名，且类型相同
    char b;    // 与父类中成员b同名，但类型不同
    public void method(){
        a = 100; // 访问父类继承的a，还是子类自己新增的a？
        b = 101; // 访问父类继承的b，还是子类自己新增的b?
        c = 102; // 子类没有c，访问的肯定是从父类继承下来的c
     // d = 103; // 编译失败，因为父类和子类都没有定义成员变量b
    }
}

在子类方法中或者通过子类对象访问成员时：

如果访问的成员变量子类中有，优先访问自己的成员变量。
如果访问的成员变量子类中无，则访问父类继承下来的，如果父类也没有定义，则编译报错。
如果访问的成员变量与父类中成员变量同名，则优先访问自己的。
成员变量访问遵循就近原则，自己有优先自己的，如果没有则向父类中找。

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

成员方法名字不同：

当子类和父类的成员方法名字不同时，子类可以直接调用父类的方法。示例代码如下：

class Parent {
    public void parentMethod() {
        System.out.println("父类的方法");
    }
}

class Child extends Parent {
    public void childMethod() {
        parentMethod();
        System.out.println("子类的方法");
    }
}

在这个例子中，Child 类的 childMethod() 方法可以直接调用父类 Parent 的 parentMethod() 方法。

总结：成员方法没有同名时，在子类方法中或者通过子类对象访问方法时，则优先访问自己的，自己没有时再到父类中找，如果父类中也没有则报错。

成员方法名字相同：

class Parent {
    public void methodA(){
        System.out.println("Base中的methodA()");
    }
    public void methodB(){
        System.out.println("Base中的methodB()");
    }
}
class Chiled extends Parent{
    public void methodA(int a) {
        System.out.println("Derived中的method(int)方法");
    }
    public void methodB(){
        System.out.println("Derived中的methodB()方法");
    }
    public void methodC(){
        methodA();     // 没有传参，访问父类中的methodA()
        methodA(20);   // 传递int参数，访问子类中的methodA(int)
        methodB();     // 直接访问，则永远访问到的都是子类中的methodB()，基类的无法访问到
    }
}

说明：

通过子类对象访问父类与子类中不同名方法时，优先在子类中找，找到则访问，否则在父类中找，找到则访问，否则编译报错。
通过派生类对象访问父类与子类同名方法时，如果父类和子类同名方法的参数列表不同(重载)，根据调用方法适传递的参数选择合适的方法访问，如果没有则报错；

问题：如果子类中存在与父类中相同的成员时，那如何在子类中访问父类相同名称的成员呢？

5. super 关键字

由于设计不好，或者因场景需要，子类和父类中可能会存在相同名称的成员，如果要在子类方法中访问父类同名成员时，该如何操作？直接访问是无法做到的，Java提供了super关键字，该关键字主要作用：在子类方法中访问父类的成员。它有以下几种常见的用法：

访问父类的成员变量：super.成员变量名
调用父类的成员方法：super.成员方法名()
调用父类的构造方法：super() 或 super(参数列表)

class Parent {
    int var = 10;

    public Parent() {
        System.out.println("父类的无参构造方法");
    }

    public Parent(int var) {
        this.var = var;
        System.out.println("父类的有参构造方法");
    }

    public void method() {
        System.out.println("父类的方法");
    }
}

class Child extends Parent {
    int var = 20;

    public Child() {
        super(); // 调用父类的无参构造方法
    }

    public Child(int var) {
        super(var); // 调用父类的有参构造方法
    }

    public void printVars() {
        System.out.println("子类的 var: " + var);
        System.out.println("父类的 var: " + super.var);
    }

    public void callParentMethod() {
        super.method();
    }
}

注意：只能在非静态方法中使用

6. 子类构造方法

在 Java 中，子类的构造方法在执行时，会默认先调用父类的无参构造方法。如果父类没有无参构造方法，子类必须在构造方法的第一行使用 super(参数列表) 显式调用父类的有参构造方法。示例代码如下：

class Parent {
    int var;

    public Parent(int var) {
        this.var = var;
        System.out.println("父类的有参构造方法");
    }
}

class Child extends Parent {
    public Child(int var) {
        super(var); // 显式调用父类的有参构造方法
        System.out.println("子类的构造方法");
    }
}

在这个例子中，由于父类 Parent 没有无参构造方法，所以子类 Child 的构造方法必须显式调用父类的有参构造方法。

在子类构造方法中，并没有写任何关于基类构造的代码，但是在构造子类对象时，先执行基类的构造方法，然后执行子类的构造方法，因为：子类对象中成员是有两部分组成的，父类继承下来的以及子类新增加的部分。父子父子肯定是先有父再有子，所以在构造子类对象时候，先要调用基类的构造方法，将从基类继承下来的成员构造完整，然后再调用子类自己的构造方法，将子类自己新增加的成员初始化完整。

注意：

若父类显式定义无参或者默认的构造方法，在子类构造方法第一行默认有隐含的super()调用，即调用基类构造方法。
如果父类构造方法是带有参数的，此时需要用户为子类显式定义构造方法，并在子类构造方法中选择合适的父类构造方法调用，否则编译失败。
在子类构造方法中，super(...)调用父类构造时，必须是子类构造函数中第一条语句。
super(...)只能在子类构造方法中出现一次，并且不能和this同时出现。

7. super 和 this

super 和 this 都是 Java 中的关键字，他们之间有什么区别呢？

相同点：

都是Java中的关键字。
只能在类的非静态方法中使用，用来访问非静态成员方法和字段。
在构造方法中调用时，必须是构造方法中的第一条语句，并且不能同时存在。

不同点：

this是当前对象的引用，当前对象即调用实例方法的对象，super相当于是子类对象中从父类继承下来部分成员的引用。
在非静态成员方法中，this用来访问本类的方法和属性，super用来访问父类继承下来的方法和属性。
在构造方法中：this(...)用于调用本类构造方法，super(...)用于调用父类构造方法，两种调用不能同时在构造方法中出现。
构造方法中一定会存在super(...)的调用，用户没有写编译器也会增加，但是this(...)用户不写则没有。

8. 再谈初始化

我们还记得之前讲过的代码块吗？我们简单回顾一下几个重要的代码块：实例代码块和静态代码块。

在没有继承关系时的执行顺序：

继承关系上的执行顺序：

class Person {
    public String name;
    public int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("Person：构造方法执行");
    }
    {
        System.out.println("Person：实例代码块执行");
    }
    static {
        System.out.println("Person：静态代码块执行");
    }
}
class Student extends Person{
    public Student(String name,int age) {
        super(name,age);
        System.out.println("Student：构造方法执行");
    }
    {
        System.out.println("Student：实例代码块执行");
    }
    static {
        System.out.println("Student：静态代码块执行");
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Student student1 = new Student("stu1", 19);
        System.out.println("===========================");
        Student student2 = new Student("syu2", 20);
    }
}

执行结果：

通过分析执行结果，得出以下结论：

父类静态代码块优先于子类静态代码块执行，且是最早执行。
父类实例代码块和父类构造方法紧接着执行。
子类的实例代码块和子类构造方法紧接着再执行。
第二次实例化子类对象时，父类和子类的静态代码块都将不会再执行。

9. protected 关键字

protected 是 Java 中的一种访问修饰符，它的访问权限介于 private 和 public 之间。被 protected 修饰的成员可以在同一个包内的任何类中访问，也可以在不同包的子类中访问。示例代码如下：

// 父类
package com.example.parent;

public class Parent {
    protected int protectedVar = 10;

    protected void protectedMethod() {
        System.out.println("这是一个受保护的方法");
    }
}

// 子类
package com.example.child;

import com.example.parent.Parent;

public class Child extends Parent {
    public void accessParentProtected() {
        System.out.println("访问父类的受保护成员变量: " + protectedVar);
        protectedMethod();
    }
}

10. 继承方式

在现实生活中，事物之间的关系是非常复杂，灵活多样，比如：

但在Java中只支持以下几种继承方式：

注意：

Java中不支持多继承（接口继承实现多继承）。
Java继承一般我们不希望出现超过三层的继承关系。
想要限制继承可以使用 final 关键字。

11. final 关键字

final关键可以用来修饰变量、成员方法以及类。

11.1 final 类

final class Immutable {
    // 表示此类不能被继承
}

11.2 final 方法

class Base {
    final void fixedMethod() { /* ... */ }
}

class Derived extends Base {
    // 无法重写
}

11.3 final 变量

final int MAX_SIZE = 100;
// MAX_SIZE = 200; // 编译错误 修饰变量或字段，表示常量(即不能修改)

12. 继承与组合

和继承类似, 组合也是一种表达类之间关系的方式, 也是能够达到代码重用的效果。组合并没有涉及到特殊的语法(诸如 extends 这样的关键字), 仅仅是将一个类的实例作为另外一个类的字段。

继承表示对象之间是is-a的关系，比如：狗是动物，猫是动物
组合表示对象之间是has-a的关系，比如：汽车

class Engine {
    void start() { /* ... */ }
}

class Car {
    private Engine engine = new Engine();

    void startCar() {
        engine.start(); // 组合调用
    }
}

组合和继承都可以实现代码复用，应该使用继承还是组合，需要根据应用场景来选择，一般建议：能用组合尽量用组合。

13. 继承的最佳实践

里氏替换原则：子类应能替换父类出现的任何地方。
优先使用组合：除非明确需要继承语义。
合理使用 protected：避免过度暴露父类实现细节。
finalize 设计：用 final 修饰不希望被重写的类 / 方法。
构造方法规范：父类应提供无参构造或明确构造调用链。

14. 常见问题与陷阱

隐藏字段问题：子类声明与父类同名的字段会导致隐藏，应避免
构造方法调用顺序：必须保证父类构造在子类之前执行
多态方法调用：子类重写方法时，注意参数列表和返回类型
接口继承 vs 类继承：接口用于行为抽象，类继承用于实现复用

Error：java: 程序包lombok不存在

基于springboot+vue的停车场管理系统

数据库第一章 MYSQL基础(5)

在线Notepad智能笔记——你的全能AI创作助手

C++ 常量

【gdutthesis模板】章节标题有英文解决方案

数据结构第一轮复习--第六章图包含代码

蓝桥杯冲刺

Mybatis模糊查询

【C语言】字符串处理指南

容器的CPU

T n、const T n、T const n

1. hadoop 集群的常用命令

工商业储能要关注的核心能力与未来发展方向

CMDB平台（进阶篇）：3D机房大屏全景解析

CentOS7 安装 LLaMA-Factory

Spring Boot 定时任务的多种实现方式

SQLark：一款国产免费数据库开发和管理工具

SpringCloud快速认识

进行性核上性麻痹护理指南，助患者安稳生活

1. 为什么需要继承

2. 继承概念

3. 继承的语法

4. 父类成员访问

4.1 子类中访问父类的成员变量

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

5. super 关键字

6. 子类构造方法

7. super 和 this

8. 再谈初始化

9. protected 关键字

10. 继承方式

11. final 关键字

11.1 final 类

11.2 final 方法

11.3 final 变量

12. 继承与组合

13. 继承的最佳实践

14. 常见问题与陷阱

相关文章：