1 继承
1.1 概述
多个类中存在相同属性和⾏为时，将这些内容抽取到单独⼀个类中，那么多个类⽆需再定义这些属性和⾏为，只要继承那⼀个类即可。例：兔子和羊属于食草动物类，狮子和老虎属于食肉动物类，而食草动物和食肉动物又是属于动物类。因此我们可以归纳出多个类可以称为子类，单独那一个类称为父类、超类或者基类。
上面所描述的是事物之间的所属关系可以称之为继承，可见父类更通用，子类更具体，我们可以通过继承来使多种事物之间形成一种关系体系。
定义
- 继承：就是⼦类继承⽗类的属性和⾏为，使得⼦类对象具有与⽗类相同的属性、相同的⾏为。⼦类可以直接访问⽗类中的⾮私有的属性和⾏为。
好处
- 提⾼代码的复⽤性。
- 类与类之间产⽣了关系，是多态的前提。
1.2 继承的格式
通过 extends 关键字，可以声明⼀个⼦类继承另外⼀个⽗类，定义格式如下：
class ⽗类 {
...
}
class ⼦类 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 num2 = 6;
// Zi中的成员⽅法
public void show() {
// 访问⽗类中的num
System.out.println("Fu num = " + num); // 继承⽽来，所以直接访问
// 访问⼦类中的num2
System.out.println("Zi num2 = " + num2);
}
}
class ExtendDemo02 {
public static void main(String[] args) {
// 创建⼦类对象
Zi z = new Zi();
// 调⽤⼦类中的show⽅法
z.show();
}
}
运行结果:
Fu num = 5
Zi num2 = 6
成员变量重名
如果⼦类⽗类中出现重名的成员变量，这时的访问是有影响的。代码如下：
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 。使⽤格式：
super.⽗类成员变量名
⼦类⽅法需要修改，代码如下：
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
⼩贴⼠：Fu 类中的成员变量是⾮私有的，⼦类中可以直接访问。若Fu 类中的成员变量私有了，⼦类是不能直接访问的。通常编码时，我们遵循封装的原则，使⽤private修饰成员变量，那么如何访问⽗类的私有成员变量？答案是我们可以在⽗类中提供公共的getXxx⽅法和setXxx⽅法。
1.4 继承后的特点 – 成员⽅法
当类之间产⽣了关系，其中各类中的成员⽅法，⼜产⽣了哪些影响呢？
成员⽅法不重名
如果⼦类⽗类中出现不重名的成员⽅法，这时的调⽤是没有影响的。对象调⽤⽅法时，会先在⼦类中查找有没有对应的⽅法，若⼦类中存在就会执⾏⼦类中的⽅法，若⼦类中不存在就会执⾏⽗类中相应的⽅法。代码如下：
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();
}
}
成员⽅法重名 – 重写（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
}
}
重写的应⽤
⼦类可以根据需要，定义特定于⾃⼰的⾏为。既沿袭了⽗类的功能名称，⼜根据⼦类的需要重新实现⽗类⽅法，从⽽进⾏扩展增强。⽐如新的⼿机增加来电显示头像的功能，代码如下：
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();
}
}
小贴士：这里重写时，用到super.父类成员方法，表示调用父类的成员方法。
注意事项
1.子类方法覆盖父类方法，必须要保证权限大于等于父类权限
2.子类方法覆盖父类方法，返回值类型、方法名和参数列表都要一模一样
1.5 继承后的特点 – 构造方法
当类之间产⽣了关系，其中各类中的构造⽅法，⼜产⽣了哪些影响呢？
⾸先我们要回忆两个事情，构造⽅法的定义格式和作⽤：
- 构造⽅法的名字是与类名⼀致的。所以⼦类是⽆法继承⽗类构造⽅法的。
- 构造⽅法的作⽤是初始化成员变量的。所以⼦类的初始化过程中，必须先执⾏⽗类的初始化动作。⼦类的构造⽅法中默认有⼀个 super() ，表示调⽤⽗类的构造⽅法，⽗类成员变量初始化后，才可以给⼦类使⽤。代码如下：
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()
1.6 super 和 this
⽗类空间优先于⼦类对象产⽣
在每次创建⼦类对象时，先初始化⽗类空间，再创建其⼦类对象本身。⽬的在于⼦类对象中包含了其对应的⽗类空间，便可以包含其⽗类的成员，如果⽗类成员⾮private修饰，则⼦类可以随意使⽤⽗类成员。代码体现在⼦类的构造⽅法调⽤时，⼀定先调⽤⽗类的构造⽅法。
super和this的含义
super ：代表⽗类的存储空间标识（可以理解为⽗亲的引⽤）
this ：代表当前对象的引⽤（谁调⽤就代表谁）
super和this的⽤法
- 访问成员
this.成员变量 -- 本类的
super.成员变量 -- ⽗类的
this.成员⽅法名() -- 本类的
super.成员⽅法名() -- ⽗类的
⽤法演示，代码如下：
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
- 访问构造⽅法
this(...) -- 本类的构造⽅法
super(...) -- ⽗类的构造⽅法
⼦类的每个构造⽅法中均有默认的super()，调⽤⽗类的空参构造。⼿动调⽤⽗类构造会覆盖默认的super()。
super() 和 this() 都必须是在构造⽅法的第⼀⾏，所以不能同时出现。
1.7 继承的特点
- Java只⽀持单继承，不⽀持多继承。
// ⼀个类只能有⼀个⽗类，不可以有多个⽗类。
class C extends A{} // ok
class C extends A，B... // error
- Java⽀持多层继承（继承体系）。
class A {}
class B extends A {}
class C extends B {}
- ⼦类和⽗类是⼀种相对的概念。
2 抽象类
2.1 概述
由来
⽗类中的⽅法，被它的⼦类们重写，⼦类各⾃的实现都不尽相同。那么⽗类的⽅法声明和⽅法主体，只有声明还有意义，⽽⽅法主体则没有存在的意义了。我们把没有⽅法主体的⽅法称为抽象⽅法。Java语法规定，包含抽象⽅法的类就是抽象类。
定义
抽象⽅法：没有⽅法体的⽅法。
抽象类：包含抽象⽅法的类。
2.2 abstract使⽤格式
抽象⽅法
使⽤ abstract 关键字修饰⽅法，该⽅法就成了抽象⽅法，抽象⽅法只包含⼀个⽅法名，⽽没有⽅法体。
定义格式：
修饰符 abstract 返回值类型 ⽅法名 (参数列表);
代码举例：
public abstract void run();
抽象类
如果⼀个类包含抽象⽅法，那么该类必须是抽象类。
定义格式：
abstract class 类名字 {
}
代码举例：
public abstract class Animal {
public abstract void run();
}
抽象的使⽤
继承抽象类的⼦类必须重写⽗类所有的抽象⽅法。否则，该⼦类也必须声明为抽象类。最终，必须有⼦类实现该⽗类的抽象⽅法，否则，从最初的⽗类到最终的⼦类都不能创建对象，失去意义。
代码举例：
abstract class Animal {
public abstract void run();
}
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 注意事项
关于抽象类的使⽤，以下为语法上要注意的细节，虽然条⽬较多，但若理解了抽象的本质，⽆需死记硬背。
-
抽象类不能创建对象，如果创建，编译⽆法通过⽽报错。只能创建其⾮抽象⼦类的对象。
理解：假设创建了抽象类的对象，调⽤抽象的⽅法，⽽抽象⽅法没有具体的⽅法体，没有意义。
-
抽象类中，可以有构造⽅法，是供⼦类创建对象时，初始化⽗类成员使⽤的。
理解：⼦类的构造⽅法中，有默认的super()，需要访问⽗类构造⽅法。
-
抽象类中，不⼀定包含抽象⽅法，但是有抽象⽅法的类必定是抽象类。
理解：未包含抽象⽅法的抽象类，⽬的就是不想让调⽤者创建该类对象，通常⽤于某些特殊的类结构设计。
-
抽象类的⼦类，必须重写抽象⽗类中所有的抽象⽅法，否则，编译⽆法通过⽽报错。除⾮该⼦类也是抽象类。
理解：假设不重写所有抽象⽅法，则类中可能包含抽象⽅法。那么创建对象后，调⽤抽象的⽅法，没有意义。
3 接⼝
3.1 概述
接⼝，是Java语⾔中⼀种引⽤类型，是⽅法的集合，如果说类的内部封装了成员变量、构造⽅法和成员⽅法，那么接⼝的内部主要就是封装了⽅法，包含抽象⽅法（JDK 7及以前），默认⽅法和静态⽅法（JDK 8），私有⽅法 (JDK 9)。
接⼝的定义，它与定义类⽅式相似，但是使⽤ interface 关键字。它也会被编译成 .class ⽂件，但⼀定要明确它并不是类，⽽是另外⼀种引⽤数据类型。
引⽤数据类型：数组，类，接⼝。
接⼝的使⽤，它不能创建对象，但是可以被实现（ implements ，类似于被继承）。⼀个实现接⼝的类（可以看做是接⼝的⼦类），需要实现接⼝中所有的抽象⽅法，创建该类对象，就可以调⽤⽅法了，否则它必须是⼀个抽象类。
3.2 定义格式
public interface 接⼝名称 {
// 抽象⽅法
// 默认⽅法
// 静态⽅法
// 私有⽅法
}
含有抽象⽅法
抽象⽅法：使⽤ abstract 关键字修饰，可以省略，没有⽅法体。该⽅法供⼦类实现使⽤。
代码如下：
public interface InterFaceName {
public abstract void method();
}
含有默认⽅法和静态⽅法
默认⽅法：使⽤ default 修饰，不可省略，供⼦类调⽤或者⼦类重写。
静态⽅法：使⽤ static 修饰，供接⼝直接调⽤。
代码如下：
public interface InterFaceName {
public default void method() {
// 执⾏语句
}
public static void method2() {
// 执⾏语句
}
}
含有私有⽅法和私有静态⽅法
私有⽅法：使⽤ private 修饰，供接⼝中的默认⽅法或者静态⽅法调⽤。
代码如下：
public interface InterFaceName {
private void method() {
// 执⾏语句
}
}
3.3 基本的实现
实现的概述
类与接⼝的关系为实现关系，即类实现接⼝，该类可以称为接⼝的实现类，也可以称为接⼝的⼦类。实现的动作类似继承，格式相仿，只是关键字不同，实现使⽤ implements 关键字。
⾮抽象⼦类实现接⼝：
- 必须重写接⼝中所有抽象⽅法。
- 继承了接⼝的默认⽅法，即可以直接调⽤，也可以重写。
实现格式：
class 类名 implements 接⼝名 {
// 重写接⼝中抽象⽅法【必须】
// 重写接⼝中默认⽅法【可选】
}
抽象⽅法的使⽤
必须全部实现，代码如下：
定义接⼝：
public interface LiveAble {
// 定义抽象⽅法
public abstract void eat();
public abstract void sleep();
}
定义实现类：
public class Animal implements LiveAble {
@Override
public void eat() {
System.out.println("吃东⻄");
}
@Override
public void sleep() {
System.out.println("晚上睡");
}
}
实现测试类：
public class InterfaceDemo {
public static void main(String[] args) {
// 创建⼦类对象
Animal a = new Animal();
// 调⽤实现后的⽅法
a.eat();
a.sleep();
}
}
输出结果:
吃东⻄
晚上睡
默认⽅法的使⽤
可以继承，可以重写，⼆选⼀，但是只能通过实现类的对象来调⽤。
1.继承默认⽅法，代码如下：
定义接⼝：
public interface LiveAble {
public default void fly() {
System.out.println("天上⻜");
}
}
定义实现类：
public class Animal implements LiveAble {
// 继承，什么都不⽤写，直接调⽤
}
定义测试类：
public class InterfaceDemo {
public static void main(String[] args) {
// 创建⼦类对象
Animal a = new Animal();
// 调⽤默认⽅法
a.fly();
}
}
输出结果:
天上⻜
2.重写默认⽅法，代码如下：
定义接⼝：
public interface LiveAble {
public default void fly() {
System.out.println("天上⻜");
}
}
定义实现类：
public class Animal implements LiveAble {
@Override
public void fly() {
System.out.println("⾃由⾃在的⻜");
}
}
定义测试类：
public class InterfaceDemo {
public static void main(String[] args) {
// 创建⼦类对象
Animal a = new Animal();
// 调⽤重写⽅法
a.fly();
}
}
输出结果:
⾃由⾃在的⻜
静态⽅法的使⽤
静态与 .class ⽂件相关，只能使⽤接⼝名调⽤，不可以通过实现类的类名或者实现类的对象调⽤，代码如下：
定义接⼝：
public interface LiveAble {
public static void run() {
System.out.println("跑起来~~~");
}
}
定义实现类：
public class Animal implements LiveAble {
// ⽆法重写静态⽅法
}
定义测试类：
public class InterfaceDemo {
public static void main(String[] args) {
// Animal.run(); // 【错误】⽆法继承⽅法,也⽆法调⽤
LiveAble.run();
}
}
输出结果:
跑起来~~~
私有⽅法的使⽤
- 私有⽅法：只有默认⽅法可以调⽤。
- 私有静态⽅法：默认⽅法和静态⽅法可以调⽤。
如果⼀个接⼝中有多个默认⽅法，并且⽅法中有重复的内容，那么可以抽取出来，封装到私有⽅法中，供默认⽅法去调⽤。从设计的⻆度讲，私有的⽅法是对默认⽅法和静态⽅法的辅助。
定义接⼝：
public interface LiveAble {
default void func() {
func1();
func2();
}
private void func1() {
System.out.println("跑起来~~~");
}
private void func2() {
System.out.println("跑起来~~~");
}
}
3.4 接⼝的多实现
在继承体系中，⼀个类只能继承⼀个⽗类。⽽对于接⼝⽽⾔，⼀个类是可以实现多个接⼝的，这叫做接⼝的多实现。并且，⼀个类能继承⼀个⽗类，同时实现多个接⼝。
实现格式：
class 类名 [extends ⽗类名] implements 接⼝名1,接⼝名2,接⼝名3... {
// 重写接⼝中抽象⽅法【必须】
// 重写接⼝中默认⽅法【不重名时可选】
}
[ ]：表示可选操作。
抽象⽅法
接⼝中，有多个抽象⽅法时，实现类必须重写所有抽象⽅法。如果抽象⽅法有重名的，只需要重写⼀次。代码如下：
定义多个接⼝：
interface A {
public abstract void showA();
public abstract void show();
}
interface B {
public abstract void showB();
public abstract void show();
}
定义实现类：
public class C implements A, B {
@Override
public void showA() {
System.out.println("showA");
}
@Override
public void showB() {
System.out.println("showB");
}
@Override
public void show() {
System.out.println("show");
}
}
默认⽅法
接⼝中，有多个默认⽅法时，实现类都可继承使⽤。如果默认⽅法有重名的，必须重写⼀次。代码如下：
定义多个接⼝：
interface A {
public default void methodA() {}
public default void method() {}
}
interface B {
public default void methodB() {}
public default void method() {}
}
定义实现类：
public class C implements A, B {
@Override
public void method() {
System.out.println("method");
}
}
静态⽅法
接⼝中，存在同名的静态⽅法并不会冲突，原因是只能通过各⾃接⼝名访问静态⽅法。
优先级的问题
当⼀个类，既继承⼀个⽗类，⼜实现若⼲个接⼝时，⽗类中的成员⽅法与接⼝中的默认⽅法重名，⼦类就近选择执⾏⽗类的成员⽅法。代码如下：
定义接⼝：
interface A {
public default void methodA() {
System.out.println("AAAAAAAAAAAA");
}
}
定义⽗类：
class D {
public void methodA() {
System.out.println("DDDDDDDDDDDD");
}
}
定义⼦类：
class C extends D implements A {
// 未重写methodA⽅法
}
定义测试类：
public class Test {
public static void main(String[] args) {
C c = new C();
c.methodA();
}
}
输出结果：
DDDDDDDDDDDD
3.5 接⼝的多继承
⼀个接⼝能继承另⼀个或者多个接⼝，这和类之间的继承⽐较相似。接⼝的继承使⽤ extends 关键字，⼦接⼝继承⽗接⼝的⽅法。如果⽗接⼝中的默认⽅法有重名的，那么⼦接⼝需要重写⼀次。代码如下：
定义⽗接⼝：
interface A {
public default void method() {
System.out.println("AAAAAAAAAAAAAAAAAAA");
}
}
interface B {
public default void method() {
System.out.println("BBBBBBBBBBBBBBBBBBB");
}
}
定义⼦接⼝：
interface D extends A, B {
@Override
public default void method() {
System.out.println("DDDDDDDDDDDDDD");
}
}
⼩贴⼠：
⼦接⼝重写默认⽅法时，default关键字可以保留。
⼦类重写默认⽅法时，default关键字不可以保留。
3.6 其他成员特点
- 接⼝中，⽆法定义成员变量，但是可以定义常量，其值不可以改变，默认使⽤ public static final 修饰。
- 接⼝中，没有构造⽅法，不能创建对象。
- 接⼝中，没有静态代码块。
335
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
