15.接口，多态

1.接口

• 接口，是Java语言中一种引用类型，是方法的集合，如果说类的内部封装了成员变量、构造方法和成员方法，那么接口的内部主要就是封装了方法，包含抽象方法（JDK 7及以前），默认方法和静态方法（JDK 8），私有方法（JDK 9）。

• 接口的定义，它与定义类方式相似，但是使用 interface 关键字。它也会被编译成.class文件，但一定要明确它并不是类，而是另外一种引用数据类型。

• 引用数据类型：数组，类，接口。

• 接口的使用，它不能创建对象，但是可以被实现（ implements ，类似于被继承）。

• 一个实现接口的类（可以看做是接口的子类），需要实现接口中所有的抽象方法，创建该类对象，就可以调用方法了，否则它必须是一个抽象类。

1.实现

• 非抽象子类实现接口：

  1. 必须重写接口中所有抽象方法。
  2. 继承了接口的默认方法，即可以直接调用，也可以重写

2.使用

• 抽象方法的使用

  //定义接口：
  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();
      }
   }
  
  输出结果：
  吃东西
  晚上睡    
  

• 默认方法的使用

  • 继承默认方法

  //定义接口：
  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();
      }
  }
  输出结果：
  天上飞
  

  • 重写默认方法

  //定义接口：
  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();
      }
  }
  
  输出结果：
  自由自在的飞
  

• 静态方法的使用

  //定义接口：
  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.其他成员特点

• 接口中，无法定义成员变量，但是可以定义常量，其值不可以改变，默认使用public static final修饰。
• 接口中，没有构造方法，不能创建对象。
• 接口中，没有静态代码块。

2.多态

• 是指同一行为，具有多个不同表现形式。

• 前提

  • 继承或者实现【二选一】
  2. 方法的重写【意义体现：不重写，无意义】
  3. 父类引用指向子类对象【格式体现】

3.引用类型转换

1.向上转型

• 多态本身是子类类型向父类类型向上转换的过程，这个过程是默认的
• 父类类型 变量名 = new 子类类型();
  如：Animal a = new Cat();

2.向下转型

• 父类类型向子类类型向下转换的过程，这个过程是强制的
• 子类类型 变量名 = (子类类型) 父类变量名;
  如:Cat c =(Cat) a;

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