【Java继承】——面向对象编程的基石

发布于：2025-05-12 ⋅ 阅读:(15) ⋅ 点赞:(0)

在这里插入图片描述

🎁个人主页：User_芊芊君子
🎉欢迎大家点赞👍评论📝收藏⭐文章
🔍系列专栏：【Java】内容概括

在这里插入图片描述
在这里插入图片描述
【前言】

在Java面向对象编程中，继承是一个非常重要的概念。它允许我们创建一个新类，这个新类可以继承现有类（称为父类或超类）的属性和方法，同时还可以添加自己特有的属性和方法。通过继承，我们可以实现代码的复用，减少重复代码，提高开发效率。本文将详细介绍Java继承的相关知识，并通过代码示例和图表进行深入讲解。

文章目录：

一、什么是继承？

举个例子吧，相信大家都看过西虹市首富吧，沈腾演的王多鱼通过他二爷的考验，最终继承了他二爷的财产。

1.继承的概念

继承是面向对象程序设计使代码重复利用的重要手段。
看下面两段代码，猫和狗都有名字，年龄和行为。但我们这样写就存在重复，这时候继承就体现出作用了。

public class Cat {
    String name;
    int age;
    public void eat(){
        System.out.println("吃饭");
    }
}


public class Dog {
    String name;
    int age;
    public void eat(){
        System.out.println("吃饭");
    }
}

我们可以继承原有类的属性，还可以进行扩展。原有类就是父类，而我们新定义的就是子类。
在这里插入图片描述

Dog和Cat都继承了Animal类，其中：Animal类称为⽗类/基类或超类，Dog和Cat可以称为Animal的⼦类/派⽣类，继承之后，⼦类可以复⽤⽗类中成员，⼦类在实现时只需关⼼⾃⼰新增加的成员即可。

2.继承的语法

在Java中如果要表⽰类之间的继承关系，需要借助extends关键字，具体如下：

修饰符 class ⼦类 extends ⽗类 {
// ...
}

还是用上面哪个例子：

public class Animal {
    String name;
    int age;
    public void eat(){
        System.out.println("吃饭");
    }
}

public class Cat extends Animal {
    void show(){
        System.out.println("喵喵喵");
    }
}

public class Dog extends Animal {
    void show(){
        System.out.println("汪汪汪");
    }
}

public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog();
        Cat cat = new Cat();
        System.out.println(dog.name);
        System.out.println(dog.age);
        dog.eat();
        dog.show();
    }
}

执行结果：
在这里插入图片描述

【注意】

  • ⼦类会将⽗类中的成员变量或者成员⽅法继承到⼦类中
  • ⼦类继承⽗类之后，必须要新添加⾃⼰特有的成员，体现出与基类的不同，否则就没有必要继承了

3.父类成员的访问

3.1 ⼦类中访问⽗类的成员变量

  • ⼦类和⽗类不存在同名成员变量
public class Base {
   public int a;
   public int b;
}

public class Derived extends Base{
    public int c;
    public void method(){
        this.a = 10;
        this.b = 20;
        this.c = 30;
    }
}
  • 成员方法没有同名的时，子类先访问自己的，其次再从父类中找，没有的话就会报错
  • 因为子类继承了父类，所以可以通过this关键字来访问
  • 成员⽅法名字相同
public class Test {
    public static void main(String[] args) {
        Derived derived = new Derived();
        derived.method();
    }
}

public class Derived extends Base{
    public int c;
    public int a=100;
    public void method(){

        System.out.println(this.a);
        System.out.println(this.b);
        System.out.println(this.c);
    }
}

public class Base {
   public int a=10;
   public int b;
}

同名时，访问子类自己的，父类和子类都有一个a，父类是10，子类是100，他打印出来就是100
在这里插入图片描述

3.2 ⼦类中访问⽗类的成员⽅法

这里与成员变量同理，就不多做解释了

4.super关键字

当父类与子类的成员名称相同时，我们又需要在子类中访问父类的成员，这时候就要用到super关键字

public class Base {
   public int a=10;
}

public class Derived extends Base{
    public int a=100;
    public void method(){
        System.out.println(this.a);
        System.out.println(super.a);
    
    }
}

执行结果：
在这里插入图片描述
【总结】

  • super+点号+父类成员变量
  • super+点号+父类成员方法
  • super还可以访问父类的构造方法
  • 静态的不能访问----static
  • 静态方法中不可以使用this和super，因为静态的是不依赖对象的

5.子类构造方法

我们要构造子类对象时，需要先调用父类的构造方法，然后执行子类的构造方法，所以，需要先对父类进行构造，如下代码：

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

构造完成后，他还会报错，这时我们需要初始化自己的

 public Dog(){
        super("旺财",10);
    }

如果父类构造方法没有参数，子类会自动生成不带参数的构造方法，就不会报错，但如果带参数，我们就需要自己构造，初始化
【注意事项】

  • 通过super(参数)的形式 可以调⽤⽗类指定的构造⽅法
  • super()的形式 只能出现在⼦类的构造⽅法当中且必须在第⼀⾏
  • super(…)只能在⼦类构造⽅法中出现⼀次，并且不能和this同时出现

6.super和this

【相同点】

  1. 都是Java中的关键字
  2. 只能在类的⾮静态⽅法中使⽤，⽤来访问⾮静态成员⽅法和字段
  3. 在构造⽅法中调⽤时，必须是构造⽅法中的第⼀条语句，并且不能同时存在

【不同点】

  1. this是当前对象的引⽤，当前对象即调⽤实例⽅法的对象，super相当于是⼦类对象中从⽗类继承下 来部分成员的引⽤
  2. 在⾮静态成员⽅法中，this⽤来访问本类的⽅法和属性，super⽤来访问⽗类继承下来的⽅法和属性
  3. 在构造⽅法中：this(…)⽤于调⽤本类构造⽅法，super(…)⽤于调⽤⽗类构造⽅法，两种调⽤不能 同时在构造⽅法中出现
  4. 构造⽅法中⼀定会存在super(…)的调⽤，⽤⼾没有写编译器也会增加，但是this(…)⽤⼾不写则没 有

7.继承关系上代码块的初始化顺序

这里还是举上面那个例子
父类Animal

public class Animal {
    public String name;
    public int age;
    static {
        System.out.println("Animal的静态代码块 static{}");
    }
    {
        System.out.println("Animal的实例代码块{}");
    }
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("执行Animal的2个参数的构造方法");
    }

子类Dog

public class Dog extends Animal{
    static {
        System.out.println("Dog的静态代码块 static{}");
    }
    {
        System.out.println("Dog的实例代码块{}");
    }
    public Dog(String name,int age){
        super("旺财",10);
        System.out.println("Dog类带两个参数的构造方法执行了");
    }

子类Cat

public class Cat extends Animal{
    static {
        System.out.println("Cat的静态代码块 static{}");
    }
    {
        System.out.println("Cat的实例代码块{}");
    }
    public Cat(){
        super("咪咪",10);
        System.out.println("Cat类带两个参数的构造方法执行了");
    }

public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog("旺财",10);
    }
}

执行结果：
在这里插入图片描述
【总结】

  • 先分别执行父类和子类的静态
  • 然后是父类的实例，父类的构造
  • 最后是子类的实例，子类的构造

8.访问修饰限定符-protected 关键字

在类和对象章节中，为了实现封装特性，Java中引⼊了访问限定符，主要限定：类或者类中成员能否在类外或者其他包中被访问。
在这里插入图片描述

9.继承方式

  • java中不支持多继承——比如一个子类继承两个父类，这是不行的
  • 继承关系也不要超过三层A—B—C；

10.final关键字

final关键字可以⽤来修饰变量、成员⽅法以及类。
• 修饰变量或字段，表⽰常量(即不能修改)

final int a = 10;
a = 20;//报错

• 修饰类：表⽰此类不能被继承

final public class Animal {
...
}
public class Bird extends Animal {
...
}

• 修饰⽅法：表⽰该⽅法不能被重写

二、继承与组合

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

  • 继承表⽰对象之间是is-a的关系，⽐如：狗是动物，猫是动物
  • 组合表⽰对象之间是has-a的关系，⽐如：汽⻋
// 轮胎类
class Tire{
// ...
}
// 发动机类
class Engine{
// ...
}
// ⻋载系统类
class VehicleSystem{
// ...
}
class Car{
private Tire tire;
// 可以复⽤轮胎中的属性和⽅法
private Engine engine;
// 可以复⽤发动机中的属性和⽅法
private VehicleSystem vs;
// 可以复⽤⻋载系统中的属性和⽅法
// ...
}

// 奔驰是汽⻋
class Benz extend Car{
// 将汽⻋中包含的：轮胎、发送机、⻋载系统全部继承下来
}

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

  • 继承是Java面向对象编程的核心概念之一，通过继承可以实现代码复用、提高可维护性，并为多态的实现奠定基础。在使用继承时，需要注意访问修饰符、构造方法和方法重写等细节。合理运用继承，可以让我们的代码更加简洁、灵活和易于维护。
  • 希望本文对大家理解Java继承有所帮助，如有疑问或建议，欢迎在评论区交流！

在这里插入图片描述

网站公告

今日签到

点亮在社区的每一天
去签到

热门文章

最新发布