Java 面向对象（四）继承

一、继承的概述（Inherited）

　　1、由来

　　　　多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。

　　　　其中，多个类可以称为 子类（派生类），单独的那一个类称为 父类、超类（super class）或 基类。

　　　继承描述的是事物之间的所属关系，这种关系是 ： is - a 的关系。（子类就是一个父类：子类 is a 父类）

　　　如上图：兔子属于食草动物，食草动物属于动物。可见，父类是通用，子类更具体。通过继承，可以使多种事物之间形成一种关系体系。

　　2、定义

　　　　继承：就是子类继承父类的属性和行为。使得子类对象具有与父类相同的属性、相同的行为。子类可以直接访问父类中的非私有的属性和行为。

　　3、好处

　　　　  a、提高代码的复用性。

　　　　b、扩展了新的功能。

　　　　c、类与类之间产生了关系，是多态的前提。

二、继承的格式

　　　　通过 extends 关键字，可以声明一个子类继承另外一个父类。

　　　定义格式：

// 定义父类
class 父类名称 {
...
}
// 定义子类
[修饰符] class 子类名称 extends 父类名称 {
...
}

三、继承后的特点——成员变量

　　　当类之间产生了关系后，其中各类中的成员变量会产生影响，分为下面两类来讨论：

　　1、成员变量不重名

　　　　如果子类父类中出现不重名的成员变量，这时候的访问是没有影响的。

　　　Demo：

 // 父类
 class Fu {
     // Fu中的成员变量。
     int num = 5;
 }
 // 子类
 class Zi extends Fu {
     // Zi中的成员变量
     int num2 = 6;
     // Zi中的成员方法
     public void show() {
         // 访问父类中的num，
         System.out.println("Fu num="+num); // 本类中没有，继承而来，所以直接访问。
         // 访问子类中的num2
         System.out.println("Zi num2="+num2);   // 本类中有，访问本类中num2
     }
 }
 // 测试类
 class Test{
 public static void main(String[] args) {
     // 创建子类对象
     Zi z = new Zi();
     // 调用子类中的show方法
      z.show();
     }
 }

 演示结果：
 Fu num = 5
 Zi num2 = 6

　　2、成员变量重名

　　　　如果子类父类中出现重名的成员变量，这时候的访问是有影响的。

　　　  Demo：

 class Fu {
     // Fu中的成员变量。
     int num = 5;
 }
 class Zi extends Fu {
     // Zi中的成员变量
     int num = 6;
     public void show() {
         // 访问父类中的num
         System.out.println("Fu num=" + num);
         // 访问子类中的num
         System.out.println("Zi num=" + num);
     }
 }
 class ExtendsDemo03 {
     public static void main(String[] args) {
         // 创建子类对象
         Zi z = new Zi();
         // 调用子类中的show方法
         z.show();
     }
 }
 演示结果：
 Fu num = 6
 Zi num = 6    

　　通过以上Demo可以看出，子父类中出现了同名的成员变量时，在子类中访问父类是访问不到的。

　　super 关键字

　　在子类中需要访问父类中非私有成员变量时，需要使用 super 关键字，修饰父类成员变量，类似于之前的 this。

　　使用格式：

super.父类成员变量名

　　 将上面的 Demo 中子类方法进行修改：

 class Zi extends Fu {
 　　// Zi中的成员变量
 　　int num = 6;
 　　public void show() {
 　　　　//访问父类中的num
 　　　　System.out.println("Fu num=" + super.num);
 　　　　//访问子类中的num
 　　　　System.out.println("Zi num=" + this.num);
 　　}
 }
 演示结果：
 Fu num = 5
 Zi num = 6

　　Tips：父类中的成员变量是非私有的，子类中可以直接访问。若父类中的成员变量私有了，子类是不能直接访问的。通常，遵循封装的原则，使用 private 修饰成员变量 ，那么访问父类的成员变量就需要使用公开的 setter 和 getter 方法。

四、继承后的特点——成员方法

　　当类之间产生了关系，其中各类中的成员方法又会产生影响，下面分两种情况来讨论：

　　1、成员方法不重名

　　　　如果子类父类中出现不重名的成员方法，这时调用是没有影响的。对象调用方法时，会先在子类中查找有没有对应的方法，若子类中存在就会执行子类中的方法，若子类中不存在就会执行父类中相应的方法。

　　　Demo：

 class Fu{
 　　public void show(){
 　　　　System.out.println("Fu类中的show方法执行");
 　　}
 }
 class Zi extends Fu{
 　　public void show2(){
 　　　　System.out.println("Zi类中的show2方法执行");
 　　}
 }
 public class ExtendsDemo04{
 　　public static void main(String[] args) {
 　　　　Zi z = new Zi();
 　　　　//子类中没有show方法，但是可以找到父类方法去执行
 　　　　z.show();
 　　　　z.show2();
 　　}
 }

　　2、成员方法重名 —— 重写（Override）

　　　　　如果子类父类中出现 重名 的成员方法，这时的访问是一种特殊情况，叫做方法重写（Override）。

　　　　方法重写：子类中出现与父类一模一样的方法时（返回值类型，方法名和参数列表都相同），会出现覆盖效果，也称为重写或者复写。声明不变，重新实现。

　　　　Demo：

 class Fu {
 　　public void show() {
 　　　　System.out.println("Fu show");
 　　}
 }
 class Zi extends Fu {
 　　//子类重写了父类的show方法
 　　public void show() {
 　　　　System.out.println("Zi show");
 　　}
 }
 public class ExtendsDemo05{
 　　public static void main(String[] args) {
 　　　　Zi z = new Zi();
 　　　　// 子类中有show方法，只执行重写后的show方法
 　　　　z.show(); // Zi show
 　　}
 }

　　　　　a、重写的应用

　　　　　　　　子类可以根据需要，定义特定与自己的行为。既沿袭了父类的功能名称，又根据子类的需要重新实现父类方法，从而进行扩展增强。

　　　　　　Demo：新手机增加来点显示头像的功能。

 class Phone {
     public void sendMessage(){
         System.out.println("发短信");
     }
     public void call(){
         System.out.println("打电话");
     }
     public void showNum(){
         System.out.println("来电显示号码");
     }
 }
 //智能手机类
 class NewPhone extends Phone {
     //重写父类的来电显示号码功能，并增加自己的显示姓名和图片功能
     public void showNum(){
         //调用父类已经存在的功能使用super
         super.showNum();
         //增加自己特有显示姓名和图片功能
         System.out.println("显示来电姓名");
         System.out.println("显示头像");
     }
 }

 public class ExtendsDemo06 {
     public static void main(String[] args) {
         // 创建子类对象
         NewPhone np = new NewPhone()；
         // 调用父类继承而来的方法
         np.call();
         // 调用子类重写的方法
         np.showNum();
     }
 }        

　　　　　　　　Tips：这里进行重写时，用到 super.父类成员方法，表示调用父类的成员方法。

　　　　    b、注意事项

　　　　　　（1）子类覆盖父类方法，方法名和形参列表必须和父类的一模一样。

　　　　　　（2）返回值类型：

　　　　　　　　  基本数据类型和void：要求与父类被重写的方法的返回值类型“相同”。

　　　　　　　　  引用数据类型：要求子类重写的方法的返回值类型 <= 父类被重写的方法的返回值类型

　　　　　　（3）修饰符：

　　　　　　　　  ① 权限修饰符：子类重写的方法的权限修饰符的可见性范围 >= 父类被重写方法的权限修饰符的可见性范围

　　　　　　　　　　(public > protected > (default) > private)

　　　　　　　　  ② 其他修饰符：不能是 final，private，static

　　　　　　（4）异常类型：子类重写的方法抛出的异常类型必须<=父类被重写的方法抛出的异常类型。

　　　　　　　　  父类方法没有抛出异常，子类重写父类该方法时也不可抛出异常。此时子类产生该异常，只能捕获处理，不能声明抛出。

五、继承后的特点——构造方法

　　当类之间产生了关系，现在来讨论各类中的构造方法的影响。

　   构造方法的定义格式和作用：

　　　　1、构造方法的名字和类名一致的，所以子类是无法继承父类构造方法的。

　　　　2、构造方法的作用是初始化成员变量的。所以子类的初始化过程中，必须先执行父类的初始化工作，父类成员变量初始化后，才可以给子类使用。

　　　　3、子类的构造方法中默认有一个 super() ，默认情况下，表示调用父类的无参构造方法；如果父类没有无参构造，那么在子类的构造方法的首行，必须手动调用父类的有参构造。

　　Demo：

 class Fu {
     private int n;
     Fu(){
         System.out.println("Fu()");
     }
 }
 class Zi extends Fu {
     Zi(){
         // super（），调用父类构造方法，默认就给提供一个。
         super();
         System.out.println("Zi（）");
     }
 }
 public class ExtendsDemo07{
     public static void main (String args[]){
         Zi zi = new Zi();
     }
 }
 输出结果：
 Fu（）
 Zi（）

　　　　小结：

• • 　子类构造方法当中有一个默认隐含的 “super()” 调用，所有一定是先调用的父类构造，后执行的子类构造；
    
  • 子类构造可以通过super关键字来调用父类重载构造；
  • super的父类构造调用，必须是子类构造方法的第一个语句。不能一个子类构造调用多次super构造，只能有一个。

六、super 关键字

　　1、super 含义

　　　　表示从父类中去查找，引用父类的属性或方法。

　　　　注意：super只能访问在子类中可见的属性、方法、构造器（非private修饰）

　　2、用法

　　　　（1）super.属性

　　　　　　当子类声明了和父类同名的属性时，可以使用super.属性来访问父类的属性　

　　　　（2）super.方法

　　　　　　当在子类中需要调用父类被重写的方法时，可以使用super.方法

　　　　（3）super() 或 super(实参列表)

　　　　　　super()：调用父类的无参构造

　　　　　　super(实参列表)：调用父类的有参构造

　　　　     注意：

　　　　　　① super() 或 super(实参列表) 必须在子类构造器的首行

　　　　　　② 如果子类的构造器中，没有写 super()，它也存在；但是如果子类构造器中写super(实参列表)，那么super()就不会存在的

六、super 和 this

　　1、父类空间优于子类对象产生

　　　　在每次创建子类对象时，先初始化父类空间，再创建其子类对象本身。

　　　目的在于子类对象中包含了其对应的父类空间，便可以包含其父类的成员，如果父类成员非private修饰，则子类可以随意使用父类成员。

　　    代码体现在子类的构造方法调用时，一定先调用父类的构造方法。

　　　图示：

　　2、super 和 this 的含义

• • 　super：代表父类的存储空间标识（可以理解为父亲的引用）。
  • this：代表当前对象的引用（谁调用就代表谁）。

　　3、super 和 this 的用法

　　　　a、访问成员

this.成员变量      ‐‐ 本类的
super.成员变量     ‐‐ 父类的

this.成员方法名()  ‐‐ 本类的
super.成员方法名() ‐‐ 父类的

　　　　　　Demo：

 class Animal {
     public void eat() {
         System.out.println("animal : eat");
     }
 }

 class Cat extends Animal {
     public void eat() {
         System.out.println("cat : eat");
     }
     public void eatTest() {
         this.eat(); // this 调用本类的方法
         super.eat(); // super 调用父类的方法
     }
 }
 public class ExtendsDemo08 {
     public static void main(String[] args) {
         Animal a = new Animal();
         a.eat();
         Cat c = new Cat();
         c.eatTest();
     }
 }
 输出结果为：
 animal : eat
 cat : eat
 animal : eat

　　　　b、访问构造方法

this(...)  ‐‐ 本类的构造方法
super(...) ‐‐ 父类的构造方法

　　　　注意：子类的每个构造方法中均有默认的 super(),调用父类的空参构造。手动调用父类构造会覆盖默认的super()。

　　　　　　super() 和 this() 都必须是在构造方法的第一行，所以不能同时出现。

七、继承的特点

　　1、子类继承了父类，子类不能直接访问父类中私有的属性、方法。可以通过 setter/getter 方法来调用。

　　2、子类继承父类时，构造器是不能被继承的。

　　3、子类继承父类时，在子类的构造器中一定要去调用父类的构造器。

　　　　 默认情况下，调用的是父类的无参构造；如果父类没有无参构造，那么在子类的构造器的首行，必须手动调用父类的有参构造。

　　4、Java 只支持单继承，即一个 Java 类只能有一个直接父类。

　　　　Demo：

 //一个类只能有一个父类，不可以有多个父类。
 class C extends A{}         //ok
 class C extends A，B...     //error

　　5、Java 支持多层继承（继承体系）。

　　　　Demo：

 class A{}
 class B extends A{}
 class C extends B{}

　　　扩展：顶层父类是 Object 类，所有的类默认继承 Object，作为父类。

　　6、子类和父类是一种相对的概念。

图示：