Day10-接口-多态

一.接口

A.接口的定义和使用

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

1.定义一个接口的格式：

public interface 接口名称{
	//接口内容
}

2.接口中的内容：【熟记】

1.Java 7,接口内容包含:a.常量 b.抽象方法
2.Java 8,接口内容还包含：c.默认方法 d.静态方法
3.Java 9,接口内容还包含：e.私有方法
总结：常量、抽象方法、默认方法、静态方法、私有方法

3.接口使用步骤：

1.接口不能直接使用，必须有一个”实现类“来”实现“该接口。
格式：

public class 实现类名称 interImplements 接口名称 {
	//...
}

2.接口的实现类必须覆盖重写(实现)接口中所有的抽象方法
去掉abstract关键字，加上方法体大括号。
3.创建实现类的对象，进行使用。
注意事项：
如果实现类并没有覆盖重写接口中所有的抽象方法，那么这个实现类自己就必须是抽象类。

B.重点讲接口中的内容:

1.在接口中定义抽象方法：

在任何版本的Java中，接口都能定义抽象方法。
格式：

public interface 接口名称{
	public abstract 返回值类型 方法名称(参数列表);
}

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

public interface MyInterfaceAbstract {
    //这是一个抽象方法
    public abstract void methodAbs1();
    //这也是抽象方法
    abstract void methodAbs2();
    //这也是抽象方法
    public void methodAbs3();
    //这也是抽象方法
    void methodAbs4();
}

2.在接口中定义默认方法–Java 8开始

接口中的默认方法，可以解决接口升级的问题
从Java 8开始，接口中允许定义默认方法。
格式：

public interface 接口名称 {
	public defalut 返回值类型 方法名称(参数列表) {
		方法体
	}
}

牢记：
1.接口的默认方法，可以通过接口实现类对象，直接调用。
2.接口的默认方法，也可以通过接口实现类进行覆盖重写。

3.在接口中定义静态方法–Java 8开始

从Java 8开始，接口当中允许定义静态方法。
格式：

public interface 接口名称 {
	public static 返回值类型 方法名称(参数列表) {
		方法体
	}
}

接口的静态方法调用：【重点】
1.不能通过接口实现类的对象来调用接口中的静态方法，错误写法。
2.要通过接口名称，直接调用其中的静态方法：
格式：接口名称.静态方法(参数)；

4.在接口中定义私有方法–Java 9开始

问题描述：
我们需要抽取一个公共的方法，用来解决两个默认方法或两个静态方法之间重复代码的问题。但是这个共有的方法只能接口中的默认方法或静态方法能调用，实现类不可以使用，那么就应该把这个方法私有话。

从Java 9开始，接口当中允许定义私有方法：

1.普通私有方法，解决多个默认方法之间重复的代码问题

格式：

public interface 接口名称 {
	private 返回值类型 方法名称(参数列表){
		方法体
	}
}

2.静态私有方法，解决多个静态方法之间重复的代码问题

格式：

public interface 接口名称 {
	private static 返回值类型 方法名称(参数列表){
		方法体
	}
}

5.在接口中定义常量【重点】

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

C.接口内容的小结【熟背】

一.接口中的内容：

在Java 9+版本中，接口的内容可以有:(备注：下面的内容中被[ ]括住的内容，在代码中可以省略不写)
1.在接口中成员变量其实就是常量，格式：
[public] [static] [final] 数据类型 常量名称(大写，下划线分割) = 数据值；
注意：
a.常量必须进行赋值，而且一旦赋值不能改变。
b.常量名称完全大写，用下划线进行分割。

2.接口中的最重要的就是抽象方法，格式：
[public] [abstract] 返回值类型 方法名称(参数列表)；
注意：实现类必须覆盖重写接口中所有的抽象方法，除非实现类是抽象方法。

3.从Java 8开始，接口里允许定义默认方法，格式：
[public] default 返回值类型 方法名称(参数列表) {方法体}
注意：默认方法也可以被覆盖重写

4.从Java 8开始，接口里允许定义静态方法，格式：
[public] static 返回值类型 方法名称(参数列表) {方法体}
注意：应该通过接口名称进行调用，不能通过实现类对象调用接口静态方法。

5.从Java 9+开始，接口里允许定义私有方法，格式：
普通私有方法：private 返回值类型 方法名称(参数列表) {方法体}
静态私有方法：private static 返回值类型 方法名称(参数列表) {方法体}
注意：private的方法只有接口自己才能调用，不能被实现类或别人使用

二.使用接口的注意事项：

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

D.接口与接口的多继承关系

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

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

public interface MyInterface extends MyInterfaceA, MyInterfaceB {
    public abstract void method();

    @Override
    public default void methodDefault() {
    }
}

二.多态性

面向对象三大特征：封装性，继承性，多态性。
extends继承或者implements实现，是多态的前提。
一个对象拥有多种形态，就是对象的多态性。

代码中体现多态性，其实就是一句话：父类引用指向子类对象。

1.多态的格式：

父类名称 对象名称 = new 子类名称();
或者
接口名称 对象名称 = new 实现类名称();

public class Demo {
    public static void main(String[] args) {
        //多态的写法
        //左侧父类的引用，指向了右侧子类的对象
        Fu obj = new Zi();

        obj.method();//子类方法
        obj.methodFu();
    }
}

2.多态情况下访问成员变量的两种方式：

a.直接通过对象名称访问成员变量：等号左边是谁，优先用谁，没有则向上找，不能向下找。
b.间接通过成员方法访问成员变量：看该方法属于谁，优先用谁，没有则向上找。

3.多态情况下访问成员方法的方式：

看new的是谁，就有先用谁，没有就向上找。
口诀：编译看左边，运行看右边。

4.多态情况下访问成员变量和成员方法的对比：

成员变量：编译看左边，运行也看左边。
成员方法：编译看左边，运行看右边。

public class Demo02 {
    public static void main(String[] args) {
        Fu obj = new Zi();//多态

        obj.method();//父子都有，优先用子
        obj.methodFu();//子类没有，父类有，向上找到父类

        //编译看左，左边是Fu,Fu当中没有methodZi方法，所以编译报错。
        //obj.methodZi();//错误写法！
    }
}

5.多态的好处

无论右边new的时候换成哪个子类对象，等号左边调用方法都不会变化。

6.对象的向上转型

对象的向上转型，其实就是多态写法。
格式：父类名称 对象名 = new 子类名称();
含义：右侧创建一个子类对象，把它当作父类来看待使用。
例如：Animal animal = new Cat();创建了一直猫，当作动物看待。从小范围的猫，向上转型成为更大范围的动物。
【注意事项】：向上转型一定是安全的。但是也有一个弊端：对象一旦向上转型为父类，那么就无法调用子类原本特有的内容。

7.对象的向下转型

对象的向下转型，其实就是一个【还原】动作。
格式：子类名称 对象名 = (子类名称)父类对象;
含义：将父类对象，【还原】成为本来的子类对象。
例如：Animal animal = new Cat();//本来是猫，向上转型成为动物。
Cat cat = (Cat) animal;//本来是猫，已经被当作动物，还原回来成为本来的猫
注意事项：
a.必须保证对象本来创建的时候，就是猫，才能向下转型成为猫。
b.如果对象创建的时候本来不是猫，现在非要向下转型成为猫，就会报错：ClassCastException类转换异常。

/*
向上转型一定是安全的。但是也有一个弊端：对象一旦向上转型为父类，那么就无法调用子类原本特有的内容。

解决方案：用对象的向下转型【还原】
 */
public class Demo {
    public static void main(String[] args) {
        //对象的向上转型，就是，父类引用指向子类对象。
        Animal animal = new Cat();//本来创建的时候是一只猫
        animal.eat();

        //animal.catchMouse();//错误写法！

        //向下转型，进行“还原”动作
        Cat cat = (Cat) animal;
        cat.catchMouse();

        //下面是错误的向下转型
        //本来new的是一只猫，现在非要当做狗。
        //错误写法；编译不会报错，但是运行会出现异常：
        //java.lang.ClassCastException  类转换异常
        Dog dog = (Dog) animal;
    }
}

instanceof关键字

如何让才能知道一个父类引用的对象，本来就是子类呢
格式：对象 instanceof 类名称
这将得到一个boolean值结果，也就是判断前面的对象能不能当作后面类型的实例。

public class Demo {
    public static void main(String[] args) {
        Animal animal = new Cat();//本来是一只猫
        animal.eat();

        //如果希望调用子类特有方法，需要向下转型
        //判断一下父类引用animal本来是不是Dog
        if (animal instanceof Dog) {
            Dog dog = (Dog) animal;
            dog.watchHouse();
        }

        //判断一下父类引用animal本来是不是Cat
        if (animal instanceof Cat) {
            Cat cat = (Cat) animal;
            cat.catchMouse();
        }

        giveMeAPet(new Dog());
    }

    public static void giveMeAPet(Animal animal) {
        if (animal instanceof Dog) {
            Dog dog = (Dog) animal;
            dog.watchHouse();
        }

        if (animal instanceof Cat) {
            Cat cat = (Cat) animal;
            cat.catchMouse();
        }
    }
}