【Java】面向对象之继承超级详解！！

---

前言

为了深入了解JAVA的面向对象的特性，今天我们来学习剖析多态。多态在Java中的应用非常广泛，可以大大优化代码，让代码清晰整洁，它需要在继承的前提下让子类将父类中的方法进行重写，最后通过父类对象访问到子类重写的方法实现多态！
提到了很多新内容，本篇文章将会详细介绍Java语言中的继承，访问限定符，关键字等相关内容，让我们速速开始吧！！

---

一、继承

前言我们提到多态需要在继承的前提下使用，那么就需要先知道继承是什么。在生活中有许多事物，一类人，一类物品等，这些都有着或多或少的联系，事物之间会产生一些关联，那在设计程序时就需要考虑。
举个栗子🌰：动物一类中的猫和狗。

//定义一个猫类
class Cat{
    String name;
    int age;
    String color;

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

    public void mew(){
        System.out.println(this.name + "正在喵喵喵~");
    }
}

//定义一个狗类
class Dog{
    String name;
    int age;
    String color;

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

    public void barks(){
        System.out.println(this.name + "正在汪汪汪~");
    }
}

//输出运用
public class test {
    public static void main(String[] args) {
        Dog dog = new Dog("大黄",3,"金黄");
        dog.barks();
        Cat cat = new Cat("小黑",1,"黑色");
        cat.mew();
    }
}

//最后输出结果分别是：
//“大黄正在汪汪叫~”和“小黑正在喵喵叫~”

通过观察代码可以发现，猫类和狗类都有重复的部分：

圈画的部分都是一模一样的，那能否将这些共性提取出来呢？

“面向对象思想便提出了继承的概念，专门用来进行共性抽取，实现代码的复用。”

---

1.1 继承的概念

继承(inheritance)机制：是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加新功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构， 体现了由简单到复杂的认知过程。
继承主要解决的问题是：共性的抽取，实现代码复用。

被继承的称为：父类，基类或者超类
继承的称为：子类或者派生类

上图中Dog类和Cat类就是Animal的子类，继承了Animal中的元素，实现复用，子类在实现时只需要管各自的成员即可。

1.1.1继承的语法

在java中如果想表示继承的关系，需要借助extends关键字，具体如下：

修饰符 class 子类 extends 父类{
	...;
}

对刚刚的猫狗场景使用继承方式重新设计，代码如下：

//定义动物类（父类）
class Animal{
    String name;
    int age;
    String color;
}

//定义狗类（子类）
class Dog extends Animal{
    public void barks(){
        System.out.println(this.name + "正在汪汪汪~");
    }
}

//定义猫类
class Cat extends Animal{
    public void mew(){
        System.out.println(this.name + "正在喵喵喵~");
    }
}
public class test {
    public static void main(String[] args) {
        Dog dog = new Dog();
        // dog类中并没有定义任何成员变量，name和age属性肯定是从父类Animal中继承下来的
        System.out.println(dog.name);
        System.out.println(dog.age);
        dog.barks();
    }
}

注意：
1.子类会将父类中的成员变量或成员方法继承到子类中
2.子类继承父类后，必须添加自己特有的新成员体现不同，否则就没必要来继承。

1.2 父类成员访问

在继承体系中，子类将父类的内容继承下来了，那在子类中能否直接访问父类中继承下来的成员呢？

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

分两种情况：

1.子类和父类中没有同名的成员变量

class Base{
    int a;
    int b;
}

class Drived extends Base{
    int c;
    public void methods(){
        //访问父类中的成员变量
        a = 10;
        b = 20;
        //访问子类自己的C
        c = 30;
    }
}

public class test1 {
    public static void main(String[] args) {
        Drived drived = new Drived();
        drived.methods();
        System.out.println(drived.a);
        System.out.println(drived.b);
        System.out.println(drived.c);
    }
    //运行结果为
    //10
    //20
    //30
}

2.子类和父类中有同名的成员变量

class Base{
    int a;
    int b;

}

/*class Drived extends Base{
    int c;
    public void methods(){
        //访问父类中的成员变量
        a = 10;
        b = 20;
        c = 30;
    }
}*/

class Drived extends Base {
    int a;
    int b;

    public void methods() {
        //访问父类中的成员变量
        a = 10;
        b = 20;
    }
}

public class test1 {
    public static void main(String[] args) {
        Drived drived = new Drived();
        Base base = new Base();
        drived.methods();//进行赋值
        System.out.println(drived.a);//看看子类的变化
        System.out.println(drived.b);
        System.out.println(base.a);//再看看父类的变化
        System.out.println(base.b);
    }
    //运行结果为
    //10
    //20
    //0
    //0
}

由此可见，在子类方法中或者通过子类对象访问成员时：

• 如果访问的成员变量子类中有，优先访问自己的成员变量。
• 如果访问的成员变量子类中没有，则访问继承的父类的，如果父类中也没有定义，则编译报错。
• 如果访问的成员变量与父类中成员变量同名，则优先访问自己的。

遵循就近原则，自己有优先，没有就向父类中找。

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

也是分两种：

成员方法名不同

class Base{
    public void methodA(){
        System.out.println("Base中的method");
    }
}

class Drived extends Base{
    public void methodB(){
        System.out.println("Drived中的method");
    }
    public void methodC(){
        methodA();//访问父类中的methodA
        methodB();//访问子类自己的methodB
        // methodD(); // 编译失败，在整个继承体系中没有发现方法methodD()
    }
}
public class test2 {
    public static void main(String[] args) {
        Drived drived = new Drived();
        drived.methodC();
    }
}

成员方法名字相同

class Base{
    public void methodA(){
        System.out.println("Base中的method");
    }
    public void methodB(){
        System.out.println("Base中的method");
    }
}

class Derived extends Base{
    public void methodA(int a){
        System.out.println("Derived中的method(int)");
    }
    public void methodB(){
        System.out.println("Derived中的method");
    }
    public void methodC(){
        methodA();//没有传参，访问父类中的methodA
        methodA(3);//有传参，访问子类中的methodA
        methodB();//子类中有，访问子类中的methodB
    }
}

总结：

• 通过子类对象访问父类与子类中不同名方法时，优先在子类中找，找到则访问，否则在父类中找，找到则访问，否则报错。
• 通过子类对象访问父类与子类同名方法时，如果父类和子类同名方法的参数列表不同（即重载），根据调用方法适应的参数选择合适的方法访问，没有对应方法则报错。

疑问：如果子类中存在与父类中相同的成员时，该如何在子类中访问同名的父类的成员？

1.3 super关键字

因为可能会出现上面问题的情况，java提供了super关键字，该关键字主要作用：在子类方法中访问父类成员。

可以尝试更改一下上面的示例（主要看最后三行）：

class Base{
    int a;
    int b;
	public void methodA(){
        System.out.println("Base中的method");
    }
}

class Derived extends Base {
    int a;
    int b;
    public void methods() {
        //访问父类中的成员变量
        super.a = 10;
        super.b = 20;
        super.methodA(); // 访问父类的methodA()
    }
}

借助super关键字这样就可以访问父类中的成员了。
【注意事项】

• 只能在非静态方法（无static）中使用。
• 在子类方法中，访问父类的成员变量和方法。

1.4 子类构造方法

子类的构造方法也很关键，稍不注意就会报错无法运行。
在java环境中，子类对象构造时，需要先调用父类的构造方法，然后在执行子类的构造方法。

import com.sun.javafx.css.parser.DeriveSizeConverter;

class Base{
    public Base(){
        System.out.println("Base()");
    }
}

class Derived extends Base{
    public Derived(){
        //super() 注意子类构造方法中会默认调用父类的无参构造方法super()
        //用户没有写时，编译器会自动添加，而且在子类构造方法中的第一条语句
        //并且只能出现一次
        System.out.println("Derived()");
    }
}

public class test3 {
    public static void main(String[] args) {
        Derived derived = new Derived();
    }
}

结果打印：

在子类的构造方法中，没有写任何关于基类构造的代码，但是在构造子类对象时，先执行基类的构造方法，然后执行子类的构造方法，这是因为：
子类对象是由两部分构成的，基类继承下来的部分和子类新增的部分。有父才有子，构造子类对象时，会先调用基类的构造方法，将从基类继承下来的成员构造完整，然后再调用自己的构造方法，将子类自己新增的成员初始化完整。

【注意】

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

1.5 继承时的初始化

之前我们有探究过代码块，静态代码块和实例代码块。

1.静态代码块先执行，在类加载阶段执行，且只执行一次
2.当有对象创建时，才会执行实例化代码块，实例化代码块执行完成后，最后构造方法执行。

总结下初始化顺序就是：静态代码块（只会初始化一次）->实例化代码块->构造方法

但这是一般情况，现在讲到的继承关系上的执行顺序会是什么样子呢？

【继承关系上的执行顺序】

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 newnew {
    public static void main(String[] args) {
        Student student1 = new Student("张三", 10);
        System.out.println("===========================");
        Student student2 = new Student("csdn", 20);
    }
}

运行结果：

由此分析可知：

1. 父类静态代码块先于子类静态代码块，最早执行
2. 第二次实例化子类对象时，父类和子类的静态代码块都不会再执行

也就是变成：父类静态-》子类静态-》父类实例化-》父类构造方法-》子类实例化-》子类构造方法

1.6 继承的方式

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

1. 单继承

2. 多层继承

3. 不同类继承一个类

注意：Java中不支持一个类同时继承多个父类

注意我们在实际应用时，类之间的关系会更加复杂，但我们并不希望类之间的继承层次太复杂，一般不希望出现超过三层的继承关系。
如果想从语法上进行继承的限制，就可以使用final关键字

1.7 final关键字

final关键字可以用来修饰变量，成员方法以及类：

1.由final修饰的变量相当于常量

final public class Animal {
...
}
public class Bird extends Animal {
...
}
// 编译出错
Error:(3, 27) java: 无法从最终com.bit.Animal进行

2.类（class）前加【final】代表当前类不可继承，被称为密封类

final int a = 10;
a = 20; // 编译出错

3.final修饰成员方法说明该方法不能被重写。

---

结语

好了以上就是本篇“【Java】面向对象之继承超级详解”博客的全部内容啦，感谢各位的阅读=v=，如有不足之处欢迎在评论区指出哦！！
觉得可以的话别忘了点赞三连支持一下欧！拜托啦这对我真的很重要o(>ω< )o！！!