【Java】接口(interface)的定义和使用

1.什么是接口

Java为单继承，当父类的方法种类无法满足子类需求时，可实现接口扩容子类能力。
即：Java中使用抽象类/父类表示通用属性时，每个类只能继承一个类，假如子类已经从一个父类继承了，就不能再继续继承另外的父类。但每个类可以实现多个接口，这样子类就拥有了更多的能力。

微观概念：接口是一种能力和约定。

• 接口的定义：代表了某种能力
• 方法的定义：能力的具体要求

2.接口的语法

API(应用程序编程接口): Application Program Interface
接口相当于特殊的抽象类，定义方式、组成部分与抽象类类似。
接口的定义语法：

interface 接口名 { }

接口的定义要求：

• 没有构造方法，不能创建对象
• 只能定义：公开静态常量、公开抽象方法

public interface MyInterface {
    public static final String FIELD = "value";
    public abstract void method();
}
//public 关键字仅限用于接口在于其同名文件中被定义

interface MyInterface {
      // 公开静态常量(只能): public static final
      public static final String A = "hello";
      String D = "good"; // public static final 默认隐式存在、修饰
      
      // 公开抽象方法(只能): public abstract
      public abstract void method();
      void m(); // public abstract 默认隐式存在、修饰
}

接口与抽象类的【相同】：

• 可编译为字节码文件(.class)
• 不能创建对象(接口不是类，也没有构造方法)
• 可以作为引用类型
• 具备Object类中所定义的方法

接口与抽象类的【不同】：

• 所有属性都只能且默认是公开静态常量，隐式使用public static final修饰
• 所有方法都只能且默认是公开抽象方法，隐式使用public abstract修饰
• 没有构造方法、没有动态/静态代码块

接口的使用语法：

    // 增加/赋予1种/多种能力（逗号分隔） [约定]
    calss Sub extends Super implements 接口名,接口名 {
        @OverRide
        public 返回值 method() { ... }
    }

3.接口的规范

• 任何类在实现接口时，必须实现接口中所有的抽象方法，否则此类为抽象类。
• 实现接口中抽象方法，访问修饰符必须是public。

4.接口引用

同父类一样，接口也可声明为引用，并指向真实类对象。
注意：

• 使用接口引用作为方法形参，实现更自然的多态（只关注能力-具备能力的类对象均可传入）
• 仅可调用接口中所声明的方法，不可调用实现类中独有的方法
• 可强转回真实类本身类型，进行独有方法调用（注意判断真实类对象 instanceof）

接口引用的应用（伪代码示例-eclipse可编译运行）

/* (可编译通过的伪代码) */
// 使用接口引用作为方法形参，实现更自然的多态（只关注能力-具备能力的类对象均可传入）
public class TestApply {
      public static void main(String[] args) {
            // 接口应用伪代码
            System.out.println("接口应用伪代码");
      }
}
abstract class 船 implements 会漂浮的 {
      public abstract void 漂浮(); // 子类去覆盖
}
class 小舟 extends 船 {
      public void 漂浮() {}
}
class 游艇 extends 船 {
      public void 漂浮() {}
}
class 木筏 extends 船 {
      public void 漂浮() {}
}
class 纸壳 {}
class 纸壳箱 extends 纸壳 implements 会漂浮的 {
      public void 漂浮() {
            System.out.println("纸壳箱通过胶带多次山绕，具备了可以承载重量后，漂浮在水面上");
      }
}
class 瓶子 {}
class 矿泉水瓶 extends 瓶子 implements 会漂浮的 {
      public void 漂浮() { }
}
class 树 {}
class 大木头 extends 树 implements 会漂浮的 {
      public void 漂浮() { }
}
class GameTeam {
//    public void 过汉江 (船 boat) {
      public void 过汉江 (会漂浮的 n) { // 使用接口引用作为方法形参，实现更自然的多态（关注行为、能力）
            System.out.println("n可以传入具备 会漂浮的 能力的对象均可-多态");
      }
}
interface 会漂浮的 {
      public abstract void 漂浮();
}

接口引用指向实现类对象，以及强转回实现类对象

/* interface.java */
// 定义了一种能力：会跑的
interface Runnable {
      public abstract void run();
}
// 定义了一种能力：会游的
interface Swimmable {
      public abstract void swim();
}
// 定义了一种能力：会爬的
interface Climbable {
      void climb();
}
// 定义了一种能力：会飞的
interface Flyable {
      void fly();
}

/* TestApplyInterface.java */
public class TestApplyInterface {
      public static void main(String[] args) {
            Animal a = new Dog(); // 多态：父类引用指向子类对象
            
            // 接口引用指向实现类对象，仅可调用接口中所声明的方法
            Runnable r = new Dog(); // 指向一个会跑的xxx
            r.run();
            r = new Cat();
            r.run();
            r = new Bus();
            r.run();
            
            // 接口引用可强转回类的真实对象，进行独有的属性和方法的调用
            if (r instanceof Bus) {
                  Bus b = (Bus)r;
                  System.out.println(b.seatNum);
            }
      }
}
class Animal{
      String breed;
      int age;
      String sex;
      
      public void eat() {}
      public void sleep() {}
}
// implements 接口名 ： 增加/赋予一种能力 [约定]
class Dog extends Animal implements Runnable,Swimmable { // 实现--->落地
      String furColor;
      
      public void run() {
            System.out.println("狗在奔跑...");
      }
      @Override
      public void swim() {
            System.out.println("狗在游泳...");
      }
}
// implements 接口名,接口名 : 增加/赋予多种能力（逗号分隔） [约定]
class Cat extends Animal implements Runnable,Climbable{
      String furColor;
      
      public void run() {
            System.out.println("猫在奔跑...");
      }
      
      public void climb() {
            System.out.println("猫在爬树...");
      }
}
class Fish extends Animal{
      //public void swim() {}
}
class Bird extends Animal{
      //public void fly() {}
}
class Bus implements Runnable{
      int seatNum = 50;
      @Override
      public void run() {
            System.out.println("公交车在跑...");
      }
}

输出：
狗在奔跑…
猫在奔跑…
公交车在跑…
50