[JavaSE-09]接口和多态

1、接口

1.1 概述

  接口，是Java语言中一种引用类型，是方法的集合，如果说类的内部封装了成员变量、构造方法和成员方法，那么接口的内部主要就是封装了方法，包含抽象方法（JDK 7及以前），默认方法和静态方法（JDK 8），私有方法（JDK 9）。
  接口的定义，它与定义类方式相似，但是使用 interface 关键字。它也会被编译成.class文件，但一定要明确它并不是类，而是另外一种引用数据类型。（引用数据类型：数组，类，接口。）
  接口的使用，它不能创建对象，但是可以被实现（ implements ，类似于被继承）。一个实现接口的类（可以看做是接口的子类），需要实现接口中所有的抽象方法，创建该类对象，就可以调用方法了，否则它必须是一个抽象类。
  其实编程语言的接口跟现实中的接口一个意思，但不要理解成接口产品。举个例子，USB接口是一种输入输出接口的技术规范，而鼠标、键盘和U盘等是USB规范的接口产品。电脑制造商会按照接口协议制作USB母口，不需要和鼠标、键盘生产商进行合作，大家都按照这个规范来生产，产品之间就可以通用，这个规范就是接口，如果还是不太明白什么意思，下面会举例说明。

1.2 定义格式

//基本格式
public interface 接口名称 {
    // 抽象方法
    // 默认方法
    // 静态方法
    // 私有方法
}

//含有抽象方法
public interface InterFaceName {
    public abstract void method();
}

//含有默认方法和静态方法
public interface InterFaceName {
    //默认方法：使用default修饰，不可省略，供子类调用或者子类重写。
    public default void method() {
        // 执行语句
    }
    //静态方法：使用static修饰，供接口直接调用。
    public static void method2() {
        // 执行语句   
    }
}

//含有私有方法和私有静态方法
//私有方法：使用private修饰，供接口中的默认方法或者静态方法调用。
public interface InterFaceName {
    private void method() {
        // 执行语句
    }
}

1.3、基本的实现

  类与接口的关系为实现关系，即类实现接口，该类可以称为接口的实现类，也可以称为接口的子类。实现的动作类似继承，格式相仿，只是关键字不同，实现使用 implements 关键字。
  所谓接口的实现，就等同于使用USB规范制造USB产品，比如鼠标、键盘等。JAVA的接口要用类来实现，就好像用这个规范做了一个鼠标类模板，然后用这个鼠标类生产出的鼠标就带有USB接口，可以使用USB功能。

1.3.1 抽象方法的使用

//基本格式
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.3.2 默认方法的使用

  可以继承，可以重写。

//定义接口
public interface LiveAble {
    public default void fly(){
        System.out.println("天上飞");
    }
}

//继承
public class Animal implements LiveAble {
// 继承，什么都不用写，直接调用    
}

//重写
public class Animal implements LiveAble {
    @Override
    public void fly() {
        System.out.println("自由自在的飞");
    }
}

1.3.3 静态方法的使用

  静态与.class 文件相关，只能使用接口名调用，不可以通过实现类的类名或者实现类的对象调用。

//定义接口
public interface LiveAble {
    public static void run(){
        System.out.println("跑起来~~~");
    }
}

//类实现接口
public class Animal implements LiveAble {
// 无法重写静态方法    
}

//使用接口调用静态方法
LiveAble.run();

1.3.4 私有方法的使用

  私有方法只有默认方法可以调用，私有静态方法则默认方法和静态方法都可以调用。

public interface LiveAble {
    default void func(){
        func1();
        func2();
    }
    private void func1(){
        System.out.println("跑起来~~~");
    }
    private void func2(){
        System.out.println("跑起来~~~");
    }
}

1.4 接口的多实现

  在继承体系中，一个类只能继承一个父类。而对于接口而言，一个类是可以实现多个接口的，这叫做接口的多实现。并且，一个类能继承一个父类，同时实现多个接口。
  说白了，接口就是一种弥补类不能多继承缺点的机制。假如没有接口，而鼠标产品又不只是只有USB规范，还有其他很多规范集一身，如果用继承父类的做法来，必须继承很多个父类，而JAVA又规定只能有一个亲爹（只能继承一个父类），所以有了接口这个设定。

//定义多个接口
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");
    }
}

1.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");
    }
}

2、多态

  多态是继封装、继承之后，面向对象的第三大特性。生活中，比如跑的动作，小猫、小狗和大象，跑起来是不一样的。再比如飞的动作，昆虫、鸟类和飞机，飞起来也是不一样的。可见，同一行为，通过不同的事物，可以体现出来的不同的形态。多态，描述的就是这样的状态。
  说白了，多态指的是父类有很多子类实现的意思。比如：动物有“走”这个方法，因为不同的动物子类走的方法千奇百怪，所以说动物有多种状态的“走”，这就叫多态了。在JAVA中也是这个意思，可以通过多个案例进行理解。

2.1 如何体现JAVA的多态

/*	
	多态体现的格式：
	父类类型 变量名 = new 子类对象；
	变量名.方法名();
*/

Fu f = new Zi();
f.method();

  当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，执行的是子类重写后方法。

public abstract class Animal { 
    public abstract void eat(); 
} 

class Cat extends Animal { 
    public void eat() { 
        System.out.println("吃鱼"); 
    } 
} 

class Dog extends Animal { 
    public void eat() { 
        System.out.println("吃骨头"); 
    } 
}

public class Test {
    public static void main(String[] args) {
        // 多态形式，创建对象
        Animal a1 = new Cat(); 
        // 调用的是 Cat 的 eat
        a1.eat();         
        // 多态形式，创建对象
        Animal a2 = new Dog();
        // 调用的是 Dog 的 eat
        a2.eat();              
    } 
}

2.2 为什么要用到多态

  看到上面小节体现多态的格式，很多新手会觉得莫名其妙，为什么不直接创建子类对象调用子类方法，而是要这样写？其实，是因为在实际开发的过程中，经常要用到父类类型作为方法形式参数，传递子类对象给方法，进行方法的调用。通过代码来理解：

public abstract class Animal { 
    public abstract void eat(); 
} 

class Cat extends Animal { 
    public void eat() { 
        System.out.println("吃鱼"); 
    } 
} 

class Dog extends Animal { 
    public void eat() { 
        System.out.println("吃骨头"); 
    } 
}

public class Test {
    public static void main(String[] args) {
        // 多态形式，创建对象
        Cat c = new Cat(); 
        Dog d = new Dog();
        // 调用showCatEat
        showCatEat(c);
        // 调用showDogEat
        showDogEat(d);
        /*
        以上两个方法, 均可以被showAnimalEat(Animal a)方法所替代
        而执行效果一致
        */
        showAnimalEat(c);
        showAnimalEat(d);
    }
    public static void showCatEat (Cat c){
        c.eat();
    }
    public static void showDogEat (Dog d){
        d.eat();
    }
    public static void showAnimalEat (Animal a){
        a.eat();
    }
}

  由于多态特性的支持， showAnimalEat方法的Animal类型，是Cat和Dog的父类类型，父类类型接收子类对象，当然可以把Cat对象和Dog对象，传递给方法。不仅仅是替代，在扩展性方面，无论之后再多的子类出现，我们都不需要编写showXxxEat方法了，直接使用showAnimalEat都可以完成。
  和接口的作用很像，showAnimalEat只认Animal类型的变量，只要是这个类的子类，照单全收。就跟接口的应用，只要是实现接口的类的对象，就可以进行使用。所以，多态的好处体现在可以使程序编写的更简单，并有良好的扩展。

2.3 引用类型转换

  所谓引用类型转换，和基本类型转换意思一样，就是一个类型转为另一个类型，不同的是引用类型转换是子类和父类之间的转换，子类转为父类叫做向上转型，父类转为子类叫做向下转型。
  中国有句话叫做“青出于蓝而胜于蓝”，也就是说，父类有的，子类肯定有，子类有的，父类不一定有。那么在向上转型的安全的，这个过程也是默认的，因为只需要把父类没有的删去就行。但是向下转型就得强制了，因为你不知道子类比父类多了什么东西。

//向上转型：父类类型  变量名 = new 子类类型();
Animal a = new Cat();

//向下转型：子类类型 变量名 = (子类类型) 父类变量名;
Cat c =(Cat) a;

  当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误。也就是说，不能调用子类拥有，而父类没有的方法。编译都错误，更别说运行了。这也是多态给我们带来的一点"小麻烦"。所以，想要调用子类特有的方法，必须做向下转型。通过下面代码进一步理解：

abstract class Animal {
    abstract void eat();
}

class Cat extends Animal {
    public void eat() {
        System.out.println("吃鱼");
    }

    public void catchMouse() {
        System.out.println("抓老鼠");
    }
}

class Dog extends Animal {
    public void eat() {
        System.out.println("吃骨头");
    }

    public void watchHouse() {
        System.out.println("看家");
    }
}

public class Test {
    public static void main(String[] args) {
        // 向上转型 
        Animal a = new Cat();
        a.eat();  // 调用的是 Cat 的 eat               
        // 向下转型 
        Cat c = (Cat) a;
        c.catchMouse();  // 调用的是 Cat 的 catchMouse        
    }
}

  转型的过程中，一不小心就会遇到这样的问题，请看如下代码：

public class Test {
    public static void main(String[] args) {
        // 向上转型 
        Animal a = new Cat();
        a.eat();               // 调用的是 Cat 的 eat
        // 向下转型 
        Dog d = (Dog) a;
        d.watchHouse();        // 调用的是 Dog 的 watchHouse 【运行报错】
    }
}

  这段代码可以通过编译，但是运行时，却报出了 ClassCastException ，类型转换异常！这是因为，明明创建了Cat类型对象，运行时，当然不能转换成Dog对象的。这两个类型并没有任何继承关系，不符合类型转换的定义。为了避免ClassCastException的发生，Java提供了 instanceof 关键字，给引用变量做类型的校验，所以，转换前，我们最好先做一个判断，代码如下：

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

3、总结

  多态的定义格式是等号左边是父类声明，等号右边是子类对象。接口机制是补充了类的不足，接口中有抽象方法，所以接口必须先实现，然后实现类来创建对象。使用多态的时候存在向上转型和向下转型的问题，只需要记住“青出于蓝而胜于蓝”的原则，即父类有的，子类一定有，反之不成立。
  （本章内容为自学笔记，转载请注明来源，有错误地方欢迎评论区指出。）