Java-04 接口（Interface）&多态

接口

接口的英文是Interface，作为开发者应该都很熟悉这个单词，比如常常说的API就是（Application Programming Interface）应用编程接口，提供给开发者调用的一组功能，无需提供源码

java中的接口就是一系列方法声明的集合，用来定义规范、标准

接口中可以定义的内容

• 可以定义：抽象方法，常量，嵌套类型，从Java 8开始可以定义：默认方法、静态方法

  • 上述可以定义的内容都是隐式public的，因此可以省略public关键字
  • 从Java9开始可以定义private方法

• 常量可以省略static final， 也就是说接口中不能定义实例变量

• 抽象方法可以省略abstract

• 不能自定义构造方法，不能定义初始化块，不能实例化

public interface Waiter {
  int AGE = 10;
  // 跟上一行代码完全等价
  // public static final int AGE = 10;
  public abstract void cleanUp();
  public abstract void cook();
}

接口细节

• 接口名称可以在任何使用类型的地方使用

• 一个类可以通过implements关键字实现一个或多个接口

  • 实现接口的类必须实现接口中定义的所有抽象方法，除非它是个抽象类
  • 如果一个类实现的多个接口中有相同的抽象方法，那么只需要实现一次
  • extends和implements可以一起使用，implements必须写在extends后面
  • 当父类、接口中的方法签名一样时，那么返回类型也必须一样

• 一个接口可以通过extends继承一个或多个接口

• 当多个父接口中的方法签名一样的时候，返回值也必须一样

抽象类与接口对比

抽象类和接口的用途还是有些相似的，该如何选择？

• 何时选择抽象类？

  • 在紧密相关的类之间共享代码
  • 需要public之外的访问权限(因为接口是隐式public的)
  • 需要定义实例变量、非final的静态变量（接口只能定义常量，不能定义实例变量）

• 何时选择接口？

  • 不相关的类实现相同的方法
  • 只是定义了行为，不关心谁实现了该行为
  • 想实现类型的多继承（类型的话只能继承于一个类型，不能多继承，但是可以实现多个接口，接口是可以多继承的）

接口的升级

当对接口进行升级时（比如，增加了接口中的方法），那么之前实现了该接口的类都需要进行修改（因为需要实现接口中定义的所有方法），java8之后提供了两种不需要改动其他类就对接口进行升级的方法

1. 默认方法(Default Mehod)
2. 静态方法

默认方法的使用

默认方法是以defalut修饰的实例方法，且默认方法需要有方法实现

// 默认方法需要有方法实现 
  default void test() {

  }

• 当一个类实现的接口中有默认方法时，这个类可以

  • 啥也不干，沿用接口的默认实现
  • 重写该默认方法
  • 重新声明默认方法，将默认方法声明为抽象方法(必须是在抽象类中)

• 当一个接口继承的父接口中有默认方法时，这个接口可以

  • 啥也不干，沿用接口的默认实现
  • 重写该默认方法
  • 重新声明默认方法，将默认方法声明为抽象方法

默认方法的细节

• 如果父类定义的非抽象方法与接口的默认方法相同时，最终调用的是父类的方法，也就是父类拥有更高的优先级

• 如果父类定义的抽象方法与接口的默认方法相同时，会要求子类实现该抽象方法

  • 可以通过super关键字调用接口的默认实现

• 如果接口定义的默认方法与其他接口定义的方法时，会要求子类实现此默认方法

静态方法

• 接口中定义的静态方法，只能通过接口名调用，不能被继承

public interface Waiter {
  static void eat(){
    System.out.println("接口的静态方法");
  }
}
// 通过接口名来调用静态方法
Waiter.eat();

多态

• 什么是多态？

  • 具有多种形态，同一操作作用于不同的对象有不同的执行结果

• 多态的体现

  • 父类类型指向子类对象
  • 调用子类重写的方法

• JVM会根据引用对象指向的具体对象来调用对应的方法

  • 这个行为叫做：虚方法调用(Virtual method invocation)
  • 类似于C++中的虚函数调用

跟OC中类似

类方法的调用细节

public class Animal {
  public static void run() {
    System.out.println("Animal -- run");
  }
}

public class Dog extends Animal {
  public static void run(){
    System.out.println("Dog -- run");
  }
}

    Animal.run();// Animal -- run
    Dog.run();// Dog -- run

    Dog dog = new Dog();
    // 实例也能调用类方法 但会有警告
    dog.run();// Dog -- run

    Animal dog2 = new Dog();
    // 这里调用的是Animal的类方法
    dog2.run();// Animal -- run

我们可能以为dog2会打印Dog的方法，其实不然，因为类方法跟对象实例无关，只跟类型有关，dog2调用run方法时会看dog2的类型，这里是Animal，所以会调用Animal的类方法

而且，Dog并不是重写了Animal的方法，因为在Java中只有实例方法才有重写/覆盖的概念，但是这里Dog和Animal中都是类方法，不存在重写

成员变量的访问细节

public class Person {
  public int age = 1;
  public int getPAge(){
    return age;
  }
}

public class Teacher extends Person {
  public int age = 3;
  @Override
  public int getPAge() {
    return age;
  }
  public int getTAge(){
    return age;
  }
}


Teacher tea1 = new Teacher();
System.out.println(tea1.age);// 3
System.out.println(tea1.getPAge());// 3
System.out.println(tea1.getTAge());// 3

Person tea2 = new Teacher();
// 这里访问的是Person的成员变量
System.out.println(tea2.age);// 1
System.out.println(tea2.getPAge());// 3

多态表现在实例方法的调用上，对于成员变量来说，会在其声明类型中查找，所以tea2的age会打印1