继承、super、this、抽象类、接口

1 继承

1.1 概述

由来多个类中存在相同属性和⾏为时，将这些内容抽取到单独⼀个类中，那么多个类⽆需再定义这些属性和⾏为，只要继承那⼀个类即可。如图所示：

定义
继承：就是⼦类继承⽗类的属性和⾏为，使得⼦类对象具有与⽗类相同的属性、相同的⾏为。⼦类可以直接访问⽗类中的⾮私有的属性和⾏为。
好处

1. 提⾼代码的复⽤性。
2. 类与类之间产⽣了关系，是多态的前提。

1.2 继承的格式

通过 extends 关键字，可以声明⼀个⼦类继承另外⼀个⽗类，定义格式如下：

继承演示，代码如下：

/*
* 定义员⼯类Employee，做为⽗类
*/
class Employee {
 String name; // 定义name属性
 // 定义员⼯的⼯作⽅法
 public void work() {
 System.out.println("尽⼼尽⼒地⼯作");
 }
}
/*
* 定义讲师类Teacher 继承 员⼯类Employee
*/
class Teacher extends Employee {
 // 定义⼀个打印name的⽅法
 public void printName() {
 System.out.println("name=" + name);
 }
}
/*
* 定义测试类
*/
public class ExtendDemo01 {
 public static void main(String[] args) {
 // 创建⼀个讲师类对象
 Teacher t = new Teacher();
 
 // 为该员⼯类的name属性进⾏赋值
 t.name = "⼩明";
 
 // 调⽤该员⼯的printName()⽅法
 t.printName(); // name = ⼩明
 // 调⽤Teacher类继承来的work()⽅法
 t.work(); // 尽⼼尽⼒地⼯作
 }
}

1.3 继承后的特点 – 成员变量

当类之间产⽣了关系后，其中各类中的成员变量，⼜产⽣了哪些影响呢？
成员变量不重名
如果⼦类⽗类中出现不重名的成员变量，这时的访问是没有影响的。
成员变量重名
如果⼦类⽗类中出现重名的成员变量，这时的访问是有影响的。代码如下：

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

⼦⽗类中出现了同名的成员变量时，在⼦类中需要访问⽗类中⾮私有成员变量时，需要使⽤ super 关键字，修饰⽗类成员变量，类似于之前学过的 this 。
使⽤格式：

⼩贴⼠：Fu 类中的成员变量是⾮私有的，⼦类中可以直接访问。若Fu
类中的成员变量私有了，⼦类是不能直接访问的。通常编码时，我们遵循封装的原则，使⽤private修饰成员变量，那么如何访问⽗类的私有成员变量呢？对！可以在⽗类中提供公共的getXxx⽅法和setXxx⽅法。

1.4 继承后的特点 – 成员⽅法

当类之间产⽣了关系，其中各类中的成员⽅法，⼜产⽣了哪些影响呢？
成员⽅法不重名

如果⼦类⽗类中出现不重名的成员⽅法，这时的调⽤是没有影响的。对象调⽤⽅法时，会先在⼦类中查找有没有对应的⽅法，若⼦类中存在就会执⾏⼦类中的⽅法，若⼦类中不存在就会执⾏⽗类中相应的⽅法。代码如下：

成员⽅法重名 – 重写（Override）
如果⼦类⽗类中出现重名的成员⽅法，这时的访问是⼀种特殊情况，叫做⽅法重写 (Override)。

⽅法重写：⼦类中出现与⽗类⼀模⼀样的⽅法时（返回值类型，⽅法名和参数列表都相同），会出现覆盖效果，也称为重写或者复写。声明不变，重新实现。
代码如下：

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
 }}

重写的应⽤

⼦类可以根据需要，定义特定于⾃⼰的⾏为。既沿袭了⽗类的功能名称，⼜根据⼦类的需要重新实现⽗类⽅法，从⽽进⾏扩展增强。
⽐如新的⼿机增加来电显示头像的功能，代码如下：

⼩贴⼠：这⾥重写时，⽤到super.⽗类成员⽅法，表示调⽤⽗类的成员⽅法。

注意事项

1. ⼦类⽅法覆盖⽗类⽅法，必须要保证权限⼤于等于⽗类权限。
2. ⼦类⽅法覆盖⽗类⽅法，返回值类型、函数名和参数列表都要⼀模⼀样。

1.5 继承后的特点 – 构造⽅法

当类之间产⽣了关系，其中各类中的构造⽅法，⼜产⽣了哪些影响呢？

⾸先我们要回忆两个事情，构造⽅法的定义格式和作⽤：

1. 构造⽅法的名字是与类名⼀致的。所以⼦类是⽆法继承⽗类构造⽅法的。
2. 构造⽅法的作⽤是初始化成员变量的。所以⼦类的初始化过程中，必须先执⾏⽗类的初始化动作。⼦类的构造⽅法中默认有⼀个 super() ，表示调⽤⽗类的构造⽅法，⽗类成员变量初始化后，才可以给⼦类使⽤。代码如下：

1.6 super 和 this

⽗类空间优先于⼦类对象产⽣

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

⽬的在于⼦类对象中包含了其对应的⽗类空间，便可以包含其⽗类的成员，如果⽗类成员⾮private修饰，则⼦类可以随意使⽤⽗类成员。代码体现在⼦类的构造⽅法调⽤时，⼀定先调⽤⽗类的构造⽅法。理解图解如下：

super和this的含义

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

super和this的⽤法

⽤法演示，代码如下：

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

⼦类的每个构造⽅法中均有默认的super()，调⽤⽗类的空参构造。
⼿动调⽤⽗类构造会覆盖默认的super()。 super() 和 this() 都必须是在构造⽅法的第⼀⾏，所以不能同时出现。

1.7 继承的特点

1. Java只⽀持单继承，不⽀持多继承

2 抽象类

2.1 概述

由来

⽗类中的⽅法，被它的⼦类们重写，⼦类各⾃的实现都不尽相同。那么⽗类的⽅法声明和⽅法主体，只有声明还有意义，⽽⽅法主体则没有存在的意义了。我们把没有⽅法主体的⽅法称为抽象⽅法。Java语法规定，包含抽象⽅法的类就是抽象类。

定义

抽象⽅法：没有⽅法体的⽅法。
抽象类：包含抽象⽅法的类。

2.2 abstract使⽤格式

抽象⽅法

抽象类

如果⼀个类包含抽象⽅法，那么该类必须是抽象类。

抽象的使⽤

继承抽象类的⼦类**必须重写⽗类所有的抽象⽅法。**否则，该⼦类也必须声明为抽象类。最终，必须有⼦类实现该⽗类的抽象⽅法，否则，从最初的⽗类到最终的⼦类都不能创建对象，失去意义。

public abstract class Animal {
 public abstract void run();
}
public class Cat extends Animal {
 public void run () {
 System.out.println("⼩猫在墙头⾛~~~");
 }
}
public class CatTest {
 public static void main(String[] args) {
 // 创建⼦类对象
 Cat c = new Cat();
 // 调⽤run⽅法
  c.run();
 }
}
输出结果:
⼩猫在墙头⾛~

此时的⽅法重写，是⼦类对⽗类抽象⽅法的完成实现，我们将这种⽅法重写的操作，也叫做实现⽅法

2.3 注意事项

关于抽象类的使⽤，以下为语法上要注意的细节，虽然条⽬较多，但若理解了抽象的本质，⽆需死记硬背。

3 继承的综合案例

3.1 综合案例：群主发普通红包

群主发普通红包。某群有多名成员，群主给成员发普通红包。普通红包的规则：

1. 群主的⼀笔⾦额，从群主余额中扣除，平均分成n等份，让成员领取。
2. 成员领取红包后，保存到成员余额中。

请根据描述，完成案例中所有类的定义以及指定类之间的继承关系，并完成发红包的操作。

3.2 案例分析

根据描述分析，得出如下继承体系：

4 接⼝

4.1 概述

接⼝，是Java语⾔中⼀种引⽤类型，是⽅法的集合，如果说类的内部封装了成员变量、构造⽅法和成员⽅法，那么接⼝的内部主要就是封装了⽅法，包含抽象⽅法（JDK 7及以前），默认⽅法和静态⽅法（JDK 8），私有⽅法 (JDK 9)。

接⼝的定义，它与定义类⽅式相似，但是使⽤ interface 关键字。它也会被编译成 .class ⽂件，但⼀定要明确它并不是类，⽽是另外⼀种引⽤数据类型。

引⽤数据类型：数组，类，接⼝。

接⼝的使⽤，它不能创建对象，但是可以被实现（ implements ，类似于被继承）。⼀个实现接⼝的类（可以看做是接⼝的⼦类），需要实现接⼝中所有的抽象⽅法，创建该类对象，就可以调⽤⽅法了，否则它必须是⼀个抽象类。

4.2 定义格式

含有抽象⽅法

抽象⽅法：使⽤ abstract 关键字修饰，可以省略，没有⽅法体。该⽅法供⼦类实现使⽤。
代码如下：

含有默认⽅法和静态⽅法

默认⽅法：使⽤ default 修饰，不可省略，供⼦类调⽤或者⼦类重写。
静态⽅法：使⽤ static 修饰，供接⼝直接调⽤。
代码如下：

含有私有⽅法和私有静态⽅法

私有⽅法：使⽤ private 修饰，供接⼝中的默认⽅法或者静态⽅法调⽤。
代码如下：

4.3 基本的实现

实现的概述

类与接⼝的关系为实现关系，即类实现接⼝，该类可以称为接⼝的实现类，也可以称为接⼝的⼦类。实现的动作类似继承，格式相仿，只是关键字不同，实现使⽤ implements 关键字。

⾮抽象⼦类实现接⼝：

1. 必须重写接⼝中所有抽象⽅法。
2. 继承了接⼝的默认⽅法，即可以直接调⽤，也可以重写。
   实现格式：
   

抽象⽅法的使⽤

必须全部实现，代码如下：
定义接⼝：

默认⽅法的使⽤

可以继承，可以重写，⼆选⼀，但是只能通过实现类的对象来调⽤。

1. 继承默认⽅法，代码如下：
   定义接⼝：
   
   
   

静态⽅法的使⽤

静态与 .class ⽂件相关，只能使⽤接⼝名调⽤，不可以通过实现类的类名或者实现类的对象调⽤，代码如下：

私有⽅法的使⽤

私有⽅法：只有默认⽅法可以调⽤。
私有静态⽅法：默认⽅法和静态⽅法可以调⽤。

如果⼀个接⼝中有多个默认⽅法，并且⽅法中有重复的内容，那么可以抽取出来，封装到私有⽅法中，供默认⽅法去调⽤。从设计的⻆度讲，私有的⽅法是对默认⽅法和静态⽅法的辅助。同学们在已学技术的基础上，可以⾃⾏测试。

4.4 接⼝的多实现

之前学过，在继承体系中，⼀个类只能继承⼀个⽗类。⽽对于接⼝⽽⾔，⼀个类是可以实现多个接⼝的，这叫做接⼝的多实现。并且，⼀个类能继承⼀个⽗类，同时实现多个接⼝。

抽象⽅法

接⼝中，有多个抽象⽅法时，实现类必须重写所有抽象⽅法。如果抽象⽅法有重名的，只需要重写⼀次。代码如下：

默认⽅法

接⼝中，有多个默认⽅法时，实现类都可继承使⽤。如果默认⽅法有重名的，必须重写⼀次。代码如下：

静态⽅法

接⼝中，存在同名的静态⽅法并不会冲突，原因是只能通过各⾃接⼝名访问静态⽅法。

优先级的问题

当⼀个类，既继承⼀个⽗类，⼜实现若⼲个接⼝时，⽗类中的成员⽅法与接⼝中的默认⽅法重名，⼦类就近选择执⾏⽗类的成员⽅法。代码如下：

4.5 接⼝的多继承【了解】

⼀个接⼝能继承另⼀个或者多个接⼝，这和类之间的继承⽐较相似。接⼝的继承使⽤ extends 关键字，⼦接⼝继承⽗接⼝的⽅法。如果⽗接⼝中的默认⽅法有重名的，那么⼦接⼝需要重写⼀次。代码如下：

⼩贴⼠：
⼦接⼝重写默认⽅法时，default关键字可以保留。
⼦类重写默认⽅法时，default关键字不可以保留。

4.6 其他成员特点

接⼝中，⽆法定义成员变量，但是可以定义常量，其值不可以改变，默认使⽤ 	publicstatic final 修饰。
接⼝中，没有构造⽅法，不能创建对象。
接⼝中，没有静态代码块。