Java学习之接口与多态篇
0x00 前言
在前面写的几篇文章里，讲了封装和继承，那么这篇文章就来讲讲第三大面向对象的特性多态吧，在此之前先接着上篇文章的抽象先来看看Java里面接口的应用。
0x01 接口
接口在java里面属于引用数据类型，是方法的集合。如果说的类的内部封装了成员变量、构造方法和成员方法，那么接口内部主要封装了方法，包括抽象方法，默认方法和静态方法，私有方法。
接口的定义和定义类差不多，定义接口需要使用到interface关键字。虽然说他也会被编译为class文件，但是他并不是一个类，而是另一种引用数据类型。
引用数据类型：数组、接口、类
接口的使用，他和抽象类一样不能直接被创建，但是他可以被实现使用implements关键字。
一个实现接口的类可以看作是接口的子类，需要实现接口里面所有的抽象方法，创建该类的对象，就可以调用方法了，否则他必须是抽象的子类。
定义格式：
public interface 接口名{
}
抽象方法使用 abstract 关键字修饰，可以省略，没有方法体。该方法供子类实现使用。
public interface InterFaceName {
public abstract void method();
}
接口里的默认方法和静态方法
默认方法：使用default进行修饰，不能省略，提供给子类或者子类重写使用。
静态方法：使用static修饰，提供给接口直接调用。
public interface MyInterface {
public static void method(){
//执行语句
}
public default void method2(){
//执行语句
}
}
接口里的私有方法和静态方法
私有方法和定义私有变量一样，使用private修饰，提供给接口的默认方法和静态方法调用。
pubilc interface InterfaceName{
}
实现接口
类和接口的关系为实现关系，这被称为类实现接口，这类可以称为接口的实现类，基本上和抽象类有点类似，也可以称为接口的子类。实现的动作蕾仕于继承，格式几乎一致，但是是使用implements关键字，而不是extends。
实现接口必须重写所有的抽象方法
集成了接口的默认方法，可以直接调用也可以重写
接口代码：
public interface MyInterface {
void eat();
void sleep();
}
实现类代码：
public class Zi implements MyInterface {
@Override
public void eat() {
System.out.println("吃");
}
@Override
public void sleep() {
System.out.println("睡");
}
}
main方法代码：
public static void main(String[] args) {
Zi zi = new Zi();
zi.eat();
zi.sleep();
}
接口默认方法代码实现：
定义接口：
public interface MyInterface {
default void eat() {
System.out.println("吃");
}
public default void sleep(){
System.out.println("睡");
}
}
实现类代码：
public class Zi implements MyInterface {
}
main方法代码：
public static void main(String[] args) {
Zi zi = new Zi();
zi.sleep();
zi.eat();
}
这里接口定义的第一个方法直接defalut使用这个关键字定义默认方法，第二个加上了public这两种写法都可以，前者是省略式的写法。
实现类的任何代码都没写，只写了一个继承，默认方法是默认就定义好的，可以不用写，从实例化对象直接调用，当然也可以在实现类里面进行重写。
接口静态方法使用
静态与.class 文件相关，只能使用接口名调用，不可以通过实现类的类名或者实现类的对象调用。
接口定义：
public interface MyInterface {
static void eat() {
System.out.println("吃");
}
}
实现类定义：
public class Zi implements MyInterface {
}
main方法代码：
public static void main(String[] args) {
MyInterface.eat();
}
这里可以看到在main方法里面，实例化一个对象，然后去访问eat方法是报错的，定义为静态的方法必须使用接口名进行访问。
私有方法的使用
私有方法：只有默认方法可以访问。
私有静态方法：只有默认方法和静态方法可以调用。
如果一个接口有多个默认方法并且重复，那么就可以提取出来封装到私有方法里面，供默认方法去调用他。
public interface LiveAble {
default void func(){
func1();
func2();
} p
rivate void func1(){
System.out.println("跑起来~~~");
} p
rivate void func2(){
System.out.println("跑起来~~~");
}
}
这种写法是jdk9的新特性，jdk8没有，此段描述纯属复制。
0x02 接口多实现
在前面说到因为java只支持单继承，所以一个类只能继承一个父类，但是对于接口来说，一个类是可以实现多个接口的，这就叫做接口的多实现，并且一个类里面可以继承一个父类，同时也实现多个接口。
格式：
class 类名 extends 父类名 impls 接口1，接口2{
...
}
或者
class 父类名 impls 接口1，接口2{
...
}
接口多实现多抽象方法
如果在多个接口中有重名的方法，该重名的方法只需重写一次。
接口多实现多个默认方法
接口中多个默认方法，实现类都可以继承使用。但是如果有重名的方法就必须重写一次。
接口1：
public interface MyInterface {
default void method1(){
System.out.println("我是一个没有感情的默认方法");
}
}
接口2：
public interface MyInterface2 {
default void method1(){
System.out.println("我是一个没有感情的默认方法");
}
}
实现类：
public class Zi implements MyInterface,MyInterface1 {
@Override
public void method1() {
System.out.println("没有感情的方法");
}
}
main方法代码：
public static void main(String[] args) {
Zi zi = new Zi();
zi.method1();
}
而接口中的静态方法就不会存在重名的问他，静态方法访问可以直接使用接口名访问静态方法。
优先级问题
一个类中如果计策了一个父类又实现了多个接口时，父类中的成员方和接口中的默认方法重名，子类就近选择执行的父类成员方法。
注意事项：
接口中，无法定义成员变量，但是可以定义常量，其值不可以改变，默认使用public static final修饰。
接口中，没有构造方法，不能创建对象。
接口中，没有静态代码块。
0x03 多态
多态是面向对象的第三大特性。
多态：指同一种行为，具有不同的表现形式。
多态前提：
1.继承或者实现
2.方法的重写
3.父类引用指向子类[格式]
格式：
父类类型 变量名 = new 子类对象;
变量名.方法名();
父类类型：指向子类对象继承的父类类型，或者是实现的父类接口类型。
当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，执行的是子类重写
后方法。
父类代码：
public abstract class Animal {
public abstract void play();
}
子类1代码：
public class Cat extends Animal {
@Override
public void play() {
System.out.println("撸猫");
}
}
子类2 代码：
public class Dog extends Animal{
@Override
public void play() {
System.out.println("撸狗");
}
}
main方法代码：
public static void main(String[] args) {
Animal cat = new Cat();
Animal dog = new Dog();
cat.play();
dog.play();
}
0x04 多态引用类型转换
多态的转型分为向上转型喝向下转型两种：
我们经常用到的就是向上转型，多态本身就是子类类型向父类类型向上转换的过程。
当父类引用指向子类对象的时候，这就是向上转型。
代码：
Antmal cat = new Cat();
向下转型：父类类型向子类类型向下转换的过程，这个过程是强制的。
一个已经向上转型的子类对象，将父类引用转为子类引用，可以使用强制类型转换的格式，便是向下转型。
格式：
子类类型 变量名 =（子类类型）父类变量名;
在这里来说一下为什么要使用转型
当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误。也就是说，不能调用子类拥
有，而父类没有的方法。编译都错误，更别说运行了。这也是多态给我们带来的一点"小麻烦"。所以，想要调用子
类特有的方法，必须做向下转型。
总结：如果要调用子类拥有而父类没有的方法的时候就要使用到向下转型。
父类代码：
public abstract class Animal {
public abstract void eat();
}
子类：
public class Cat extends Animal {
@Override
public void eat() {
System.out.println("吃鱼");
}
public void catchMouse(){
System.out.println("抓鱼");
}
}
main方法代码：
public static void main(String[] args) {
Animal cat = new Cat();
cat.eat();
Cat c =(Cat)cat;
c.catchMouse();
}
为了避免ClassCastException的发生，Java提供了 instanceof 关键字，给引用变量做类型的校验，格式如下：
变
量名 instanceof 数据类型
如果变量属于该数据类型，返回true。
如果变量不属于该数据类型，返回false。
所以，转换前，我们最好先做一个判断。
public class Test {
public static void main(String[] args) {
// 向上转型
Animal a = new Cat();
a.eat(); // 调用的是 Cat 的 eat
// 向下转型
if (a instanceof Cat){
Cat c = (Cat)a;
c.catchMouse(); // 调用的是 Cat 的 catchMouse
} else if (a instanceof Dog){
Dog d = (Dog)a;
d.watchHouse(); // 调用的是 Dog 的 watchHouse
}
}
}
0x05 结尾
接口与多态篇章更新完成，检测每天一个小总结。