---

前言

为了深入了解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;//访问子类自己的Cc = 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();//访问父类中的methodAmethodB();//访问子类自己的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();//没有传参，访问父类中的methodAmethodA(3);//有传参，访问子类中的methodAmethodB();//子类中有，访问子类中的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！！!