【day10】接口、多态

01_接口概述与生活举例

接口就是一种公共的规范标准

02_接口的定义基本格式

/*
接口就是多个类的公共规范。
接口是一种引用数据类型，最重要的内容就是其中的：抽象方法。

如何定义一个接口的格式：
public interface 接口名称{
	//接口内容
}

备注：换成了关键字interface之后，编译生成的字节码文件仍然是：.java ---->  .class

*/

03_接口的抽象方法定义

/*
如何定义一个接口的格式：
public interface 接口名称{
	//接口内容
}


在任何版本的Java中，接口都能定义抽象方法。
格式：
public abstract 返回值类型 方法名称（参数列表）；

注意事项：
1、接口当中的抽象方法，修饰符必须是两个固定的关键字，public abstract
2、这两个关键字修饰符，可以选择性省略。（今天刚学，所以不推荐）
3、方法的三要素，可以随意定义
*/

04_接口的抽象方法使用

注意将接口的实现方法与抽象类的实现方法进行对比，里面有许多相似（可参考 17_抽象方法和抽象类的注意事项）

/*
接口使用步骤：
1、接口不能直接使用，必须有一个“实现类”来“实现”该接口。
格式：
public class 实现类名称 implements 接口名称{
	// ....
}
2、接口的实现类必须覆盖重写（实现）接口中所有的抽象方法。
实现：去掉abstract关键字，加上方法体大括号。

3、创建实现类的对象，进行使用

注意事项：
如果实现类并没有覆盖重写所有的抽象方法，那么这个实现类自己就必须是抽象类。

*/

05_接口的默认方法定义

A和B这两个类已经被投入使用了，别的好多地方都在使用这个A，都在使用这个B。如果要是把它俩给变了，用到它们的地方都要跟着变，都会受到影响。那么现在的问题就是：如何保证A和B这两个类就是固定不动的，我就只管一个方法，但是接口当中还想再加一个方法，而且这个添加动作还让A和B不错，那如何解决这种矛盾呢？我们就需要让你新添加的这个methodABS2方法，这个新的方法拥有默认的方法体，而这种带有方法体的就叫做默认default方法。

/*
A和B这两个类已经被投入使用了，别的好多地方都在使用这个A，都在使用这个B。如果要是把它俩给变了，用到它们的地方都要跟着变，都会受到影响。那么现在的问题就是：如何保证A和B这两个类就是固定不动的，我就只管一个方法，但是接口当中还想再加一个方法，而且这个添加动作还让A和B不错，那如何解决这种矛盾呢？我们就需要让你新添加的这个methodABS2方法，这个新的方法拥有默认的方法体，而这种带有方法体的就叫做默认default方法。
*/

06_接口的默认方法使用

接口当中有一个新添加的方法，如果这个方法是抽象的，那么A和B两个抽象类一定要覆盖重写，否则它报错。但是我现在不想修改这两个实现类，那么你就必须有一个默认的方法。

/*
那么如何使用默认方法呢？默认方法会被你的实现类继承下去。

解决的问题是：A实现类就只有一个覆盖重写，没动。这个B实现类也没动。而这个MyInterfaceDefault中本来是一个方法，现在又新加了一个，新加的这一个，你这个A、B代码不用改却可以直接调用.

A和B实现类不用改，接口新添加的默认方法不要求你去修改A或者修改B。这就是默认方法之所以叫默认，它的含义所在。
*/

/*
1、接口的默认方法，可以通过接口实现类对象，直接调用。
2、接口的默认方法，也可以被接口实现类进行覆盖重写。

接口默认方法的用途非常广泛，可以用来解决接口升级的问题。
*/

07_接口的静态方法定义

静态方法一般就是直接通过类名称直接点

08_接口的静态方法使用

静态方法使用类名来调用。这里的是接口静态类，是通过接口名称.静态方法名称进行使用的

/*
为什么不能通过接口实现类的对象来调用接口当中的静态方法？
答：一个类可以实现多个接口，所以多个接口当中，静态方法会产生冲突，所以这是一种错误写法。
接口的正确写法：通过接口名称，直接调用其中的静态方法。格式是：接口名称.静态方法名（参数）

此前我们多次强调，静态跟谁有关系？静态跟类有关系，跟对象没有关系。所以new 一个对象是没有必要的。我直接通过接口名称调用静态方法才是正确的做法

*/

09_接口的私有方法定义

如果要是有方法体的两个方法之间他们重复的内容太多了，那么我们就需要抽取一把
默认方法1和默认方法2存在重复代码。重复写两遍不太好，我把它抽取出来，重复的内容我只写一遍

不让实现类单独实现这个method方法，这个时候就可以使用私有方法

// 问题描述：
// 我们需要抽取一个共有方法，用来解决两个默认方法之间重复代码的问题。但是这个共有方法不应该让实现类使用，应该是私有化的。
```[描述](https://img-blog.csdnimg.cn/124d06f9bcc8448794852af7fa401485.png)

```java
/*
问题描述：
我们需要抽取一个公有方法，用来解决两个默认方法之间重复代码的问题。但是这个共有方法不应该让实现类使用，应该是私有化的。

解决方案：
从java9开始，接口当中允许定义私有方法。
1、普通私有方法，解决多个默认方法之间重复代码问题
格式：
private 返回值类型 方法名称（参数列表）{
	方法体
}
2、静态私有方法，解决多个静态方法之间重复代码问题
格式：
private static 返回值类型 方法名称（参数列表）{
	方法体
}

*/

我们需要抽取一个公有方法，用来解决两个默认方法之间重复代码的问题。但是这个共有方法不应该让实现类使用，应该是私有化的。
接口类当中的默认方法，在实现类当中可以覆盖重写，也可以不覆盖重写。

10_接口的私有方法使用

接口当中静态方法也可能产生重复代码。
当是静态方法时：



静态的东西用起来非常简单，直接类名.方法名

11_接口的常量定义和使用

接口当中除了各种各样的方法，如抽象方法、静态方法、默认方法、私有方法。除了这些之外，还可以定义所谓的成员变量，但这可不是一般的成员变量，它从效果上看是接口上的常量。

/*
接口当中也可以定义“成员变量”，但是必须使用public static final三个关键字进行修饰。从效果上看，这其实就是接口的常量。
格式：
public static final 数据类型 常量名称=数据值；
备注：
一旦使用final关键字进行修饰，说明不可改变。
注意事项：
1、接口当中的常量，可以省略public static final，注意：不写也照样是这样。
2、接口当中的常量，必须进行赋值，不能不赋值。
3、接口中常量的名称，使用完全大写的字母，用下划线进行分隔。（推荐命名规则）

*/

12_接口的内容小结（重要）

13_继承父类并实现多个接口

一个类它的父类是唯一的，但是实现的接口可以有很多个。这点非常重要。

如果覆盖重写，这些抽象方法都得写；如果实现类没有覆盖重写所有接口当中的所有抽象方法，那么实现类就必须是一个抽象类。

不管你抽不抽象，有冲突的默认方法一定要覆盖重写。这是解决冲突的方式。


不管你抽不抽象，有冲突的默认方法一定要覆盖重写。这是解决冲突的方式。

/*
使用接口的对象，需要注意：
1、接口是没有静态代码块或者构造方法的。
2、一个类的直接父类是唯一的，但是一个类可以同时实现多个接口。
格式：
public class MyInterfaceImpl implements MyInterfaceA,MyInterfaceB{
	// 覆盖重写所有抽象方法
}
3、如果实现类所实现的多个接口当中，存在重复的抽象方法，那么只需要覆盖重写一次即可。
4、如果实现类没有覆盖重写所有接口当中的所有抽象方法，那么实现类就必须是一个抽象类。
5、如果实现类在实现的多个接口当中，存在重复的默认方法，那么实现类一定要对冲突的默认方法进行覆盖重写，
6、一个类如果直接父类当中的方法，和接口当中的默认方法产生了冲突，优先用父类当中的方法。
*/

14_接口之间的多继承

/*
1、类与类之间是单继承的。直接父类只有一个。
2、类与接口之间是多实现的。一个类可以实现多个接口。
3、接口与接口之间是多继承的。

注意事项：
1、多个父接口当中的抽象方法如果重复，没关系。
2、多个父接口当中的默认方法如果重复，那么子接口必须进行默认方法的覆盖重写。【而且带着default关键字】。
*/

15_多态的概述

继承性是多态性的前提。继承性在java当中的体现，除了有extends还有implements

小明是一个对象，这个对象既有学生形态，也有人类形态，一个对象拥有多种形态，这就是：对象的多态性。

16_多态的格式与使用

看右边new的是谁，它就运行谁

没有就往上找
多态就是：左父右子。右侧子类对象就被当做父类进行使用。一只猫被当做动物来看待，这是没有什么问题的，因为子类就是一个父类。
在这里体现了面向对象的多态性。

17_多态中成员变量的使用特点

只有方法才能覆盖重写，成员变量不能覆盖重写


访问成员方法时：看new的对象是谁，谁先调用。

/*
在多态中访问成员变量的两种方式：
1、直接通过对象名称访问成员变量：看等号左边是谁，优先用谁，没有则向上找。
2、间接通过成员方法访问成员变量：看该方法属于谁，优先用谁，没有则向上找、
*/

18_多态中成员方法的使用特点

/*
成员变量的使用规则和成员方法的使用规则是不一样的。
成员变量：编译看左边，运行还看左边
成员方法：编译看左边，运行看右边

*/

自我总结：成员变量的使用规则和成员方法的使用规则是不一样的。使用多态就是看左侧父类，如果想调用的方法和变量，左侧父类都有则编译通过可以使用，否则不能使用。

/*
多态中的口诀：
成员变量：编译看左边，运行还看左边
成员方法：编译看左边，运行看右边
*/

19_使用多态的好处

为什么推荐用多态的写法？
右边怎么去动它或者变它都不会影响左边。左边这部分是固定不变的，这样会使我们的代码更加灵活。

现在唯一要做的事情，就是调用work()方法，对其他的功能不关心。无论右边new的时候换成哪个子类对象，等号左边调用方法都不会改变。

20_对象的向上转型

对象的向上转型：父类引用指向子类对象

21_对象的向下转型

向上转型一定安全，向下转型有条件。

22_用instanceof关键字进行类型判断

你怎么知道父类的引用对象它本来是猫还是狗呢？
如果希望调用子类特有的方法，需要向下转型，那么你是希望转成猫呢？还是转成狗呢？万一要是写错了，根本来的不对应就会报错。

写instanceof也就是判断前面的对象能不能当做后面类型的实例。

23_笔记本USB接口案例_分析

24_笔记本USB接口案例_实现

左边笔记本电脑类是使用接口，右边鼠标类和键盘类是实现接口

/*
左父右子就是多态；左是接口，右是实现类也是多态

多态中的口诀：
成员变量：编译看左边，运行还看左边
成员方法：编译看左边，运行看右边
*/

/*
实现类能不能向上转型成为接口呢？可以
你这个接口作为参数，那我这个Keyboard向上转型就变成了USB

*/