10_接口

百知教育 - 孙帅 - 10_接口

01_接口的基础语法

• 接口（特殊的抽象类）语法：

  1. 属性都是 公开静态常量 public static final
  2. 方法都是 公开抽象方法 public abstract
  3. 没有构造方法

• 实现接口语法：

  class 类名 implements 接口名
• 一个类实现接口，如果这个类不希望称为抽象类，就必须实现接口中的所有抽象方法

02_接口和类的关系

• 接口之间可以定义 多继承 关系

• 一个类在继承另外一个类的同时，还能实现多个接口（先继承再实现接口）

• 代码（编译通过）：

  package day12;
  public class TestInterface{
   public static void main(String[] args){
    MyClass mc = new MyClass();
    IA a = mc;
    IB b = mc;
    IC c = mc;
    ID d = mc;
    ClassE e = mc;
    a.m1();
    a.m2();
    b.m3();
    c.m4();
    d.m3();
    d.m4();
    d.m5();
    e.m6();
   }
  }
  abstract class ClassA{
   public static final int A = 10;
   public static final int B = 20;
   public abstract void m1();
   public abstract void m2();
  }
  interface IA{
   public static final int A = 10;
   public static final int B = 20;
   public abstract void m1();
   public abstract void m2();
  }
  interface IB{
   void m3();
  }
  interface IC{
   void m4();
  }
  interface ID extends IB,IC{
   void m5();
  }
  abstract class ClassE{
   public abstract void m6();
  }
  class MyClass extends ClassE implements IA,ID{
   public void m1(){}
   public void m2(){}
   public void m3(){}
   public void m4(){}
   public void m5(){}
   public void m6(){}
  }

03_多继承的复杂性

• 子类引用可以直接赋值给父类引用

• 父类引用需要强转才能赋值给子类引用

• 没有继承关系的两种类型之间不能强转赋值

• 强转的两种类型中，如果包含接口类型，强转代码一定能编译通过

• 代码(编译通过)：

  package day12;
  public class TestMultiInheritance{
   public static void main(String[] args){
    Animal a = new Dog();
    Dog d = (Dog)a;
    Person p = (Person)d;  //难理解！
   }
  }
  class Animal{
  }
  class Dog extends Animal{}
  interface Person{}

04_接口与多继承

• 接口的出现虽然能给出部分多继承的逻辑，但并不是为了多继承。

05_接口的解耦合

• 耦合的定义：

  强调的是对象与对象之间的关系紧密程度，关系紧密为强耦合，松散为弱耦合。

• 面向对象强调的是弱耦合性

• 接口作为标准，使接口的使用者和接口的实现者分离，从而实现弱耦合关系。

• 代码：

  package day12;
  public class TestInterface2{
   public static void main(String[] args){
    RedBulb bulb1 = new RedBulb();
    Light light = new Light();
    
    light.setBulb(bulb1);
    light.powerOn();
    
    YellowBulb bulb2 = new YellowBulb();
    
    light.setBulb(bulb2);
    light.powerOn();
   }
  }
  class Light{
   private Bulb bulb;
   public void setBulb(Bulb bulb){
    this.bulb = bulb;
   }
   public void powerOn(){
    bulb.shine();
   }
  }
  interface Bulb{
   void shine();
  }
  class RedBulb implements Bulb{
   public void shine(){
    System.out.println("发出红光");
   }
  }
  class YellowBulb implements Bulb{
   public void shine(){
    System.out.println("发出黄光");
   }
  }

• 运行结果：

06_接口的回调

• 概念：

  程序员负责 实现接口，从而实现接口中的方法， 而不用关心方法何时被谁调用。

• 代码：

  package day12;
  public class TestSort{
   public static void main(String[] args){
    Student[] a = new Student[]{
     new Student("Zhang",30),
     new Student("Liu",20),
     new Student("Wang",33),
     new Student("Xue",29)
    };
    java.util.Arrays.sort(a);
    
    for(int i = 0; i < a.length; i++){
     a[i].print();
    }
   }
  }
  class Student implements Comparable<Student>{
   String name;
   int age;
   public Student(String name, int age){
    this.name = name;
    this.age = age;
   }
   public void print(){
    System.out.println("Student name="+name+"  age="+age);
   }
   
   /*
   this与s比较大小
   this < s (this排在s前面） 返回值负数
   this > s (this排在s后面)  返回正数
   this == s(谁先谁后无所谓) 返回0
   */
   public int compareTo(Student s){
    System.out.println("hehe");
    if(this.age < s.age) return -1;
    else if(this.age > s.age) return 1;
    else return 0;
   }
  }

• 运行结果：

  

07_接口进阶

• 接口的三种类型：

  • 接口里面有些抽象方法
  • 常量接口：定义一些常量
  • 标记接口：用来标记某个类

• 缺省适配模式：

  • 定义：
    先写一个接口，再写一个实现该接口的抽象类（实现内容为空）。
  • 意义：
    是一种设计模式。发布接口时同时发布这样一个抽象类，给别人多种选择。

• 代码（编译通过）：

  package day13;
  public class TestInterface3{
   public static void main(String[] args){
    Animal[] as = {};
    int count = 0;
    for(int i = 0; i < as.length; i++){
     if(as[i] instanceof Pet) count++;
    }
   }
  }
  interface Const{
   int A = 10;
   double B = 2.5;
  }  //常量接口
  interface Empty{}  //标记接口
  class Animal{}
  class Dog extends Animal implements Pet{}
  class Cat extends Animal implements Pet{}
  class Tiger extends Animal{}
  class Bear extends Animal{}
  class Fish extends Animal implements Pet{}
  interface Pet{}
  //缺省适配模式
  interface IA{
   void m1();
   int m2();
   String m3();
  }
  abstract class AbstractA{
   public void m1(){}
   public int m2(){return 0;}
   public String m3(){return null;}
  }