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

🎁个人主页：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继承有所帮助，如有疑问或建议，欢迎在评论区交流！