进阶:接口

• 接口也是一种引用数据类型，编译之后也是一个class字节码文件。

• 接口是完全抽象的（抽象类是半抽象的）。也可以说接口是特殊的抽象类。

  • 语法：

  • [修饰符列表] interface 接口名{}

  • 接口支持多继承，一个接口可以继承多个接口。\

  • 接口中只包含：常量和抽象方法。没有其他内容。

  • 接口中所以的元素都是public修饰

  • 接口中抽象方法中的public abstract 可以省略。

  • 接口中方法都是抽象方法，接口中方法不能有方法体。

  • 接口中的常量public static final 可以省略。

  public class InterfaceTest{
    public static void main(String[] args){
        System.out.println(MyMath.PI);
    }
  }
  
  //定义接口
  interface A{
  
  }
  
  interface B extends A{
  
  }
  
  interface C extends A,B{
  
  }
  
  interface MyMath{
    
    public static final double PI = 3.1415;
    double PI = 3.1415;
  
    public abstract int sum(int a,int b);
    //接口中都是抽象方法，public abstract 可否省略。可以
    int sum(int a, int b);
    
    int sub(int a,int b);
  }
  

• 类和类之间叫继承，类和接口直接叫实现。

• 继承：extends

• 实现：implements

• 当一个非抽象的类实现接口的话，必须将接口中所以的抽象方法全部实现（覆盖/重写）

  public class Test{
    public static void main(String[] args){
        //接口不可以new
        MyMath m = new MymathImpl();
        //调用接口里面的方法，面向接口编程
        m.sum(1,2);
    }
  }
  
  //特殊的抽象类，完全抽象的，接口。
  interface MyMath{
    
    double PI = 3.1415;
  
    int sum(int a, int b);
    
    int sub(int a,int b);
  }
  
  //这样没问题
  //abstract class MymathImpl implements MyMath{
  //}
  
  //这个类名字随意，非抽象类
  class MymathImpl implements MyMath{
    //接口的访问权限必须是public。接口中的访问权限为public，实现的类不能再低。
    public int sum(int a, int b){
        return a+b;
    }
    
    public int sub(int a,int b){
        return a-b;
    }
  }
  

  • 接口与接口之间可以多继承，那么一个类可以实现多个接口吗？
    • 可以
  • 一个类可以同时实现多个接口。
  • 弥补了Java中类与类之间的单继承的缺陷。
  • 接口A和接口B没有继承关系，可以互转，但是在运行时可能会出现ClassCastException异常。
  • 无论向上转型还是向下转型，两种类型必须有继承关系，没有继承关系编译器会报错，（接口不适用），运行有问题，还是需要用instanceof 。

  public class Test{
    public static void main(String[] args){
        A a = new D();
        //a.m2();   error
        B b = new D();
        C c = new D();
        
        //调用其他接口方法可以转型（接口转型）
        B b2 = (B)a;
        b2.m2();
        
        D d = (D)a;
        d.m2();
        
        M m = new E();
        //经过测试，接口与接口之间在金乡强制类型转换时，没有继承关系，也可以强转。
        //但是一定注意，运行时可能会出现ClassCastException异常。编译没问题，运行有问题。
        if(m instanceof K){
            K k = (K)m;
        }
        
    }
  }
  
  interface K{
  
  }
  
  interface M{
  
  }
  
  class E implements M{
    
  }
  
  interface A{
    void m1();
  }
  
  interface B{
    void m2();
  }
  
  interface C{
    void m3();
  }
  
  class D implements A,B,C{
    //实现A接口中的m1
    public void m1(){
    
    }
    //实现B接口中的m2
    public void m2(){
    
    }
    //实现C接口中的m3
    public void m3(){
    
    }
  }
  

• extends在前implements在后。

  public class Test{
    public static void main(String[] args){
        Flyable f = new Cat();  //
        f.fly();
        
        Flyable p = new Pig();  //
        p.fly();
    }
  }
  
  class Animal{
    
  }
  
  //接口通常提取的是行为。
  interface Flyable{
    void fly();
  }
  
  class Cat extends Animal implements Flyable{
    public void fly(){
        System.out.println("飞翔");
    }
  }
  
  //没有这个接口，则不能飞
  class Snake extends Animal{
    
  }
  
  //想非就插翅膀。
  class Pig extends Animal implements Plyable{
    public void fly(){
        System.out.println("Pig飞翔");
    }
  }
    
  //没写extends，默认继承于Object。
  class Fish implements Flyable{
    public void fly(){
        System.out.println("Fish飞翔");
    }
  }
  

• 一个非抽象类，必须将接口中所有方法实现。

• 一个类可以同时实现多个接口。

• extends在前，implements在后，可以共存。使用接口可以用多态。

• 接口在开发中作用类似于多态在开发中的作用。

• 多态：面向抽象编程，不要面向具体编程，降低程序的耦合度，提高程序的扩展力。

• 接口在开发中作用：

  • 完全抽象，面向接口编程。

  • public interface FoodMenu{
        void shiZiChaoJiDan();
        void yuXiangRouSi();
    }
    

    public class Customer{
        //使用has a描述的统一以属性方式存在
        //以is a统一以继承方式存在
        private FoodMenu foodMenu;
        
        public Customer{
            
        }
        public Customer(FoodMenu foodMenu){
            this.foodMenu = foodMenu;
        }
        
        public void setFoodMenu(FoodMenu foodmenu){
            this.foodMenu = foodMenu;
        }
        
        public FoodMen getFoodMenu(){
            return foodMenu;
        }
        
        public void order(){
                //FoodMenu fm = this.getFoodMenu();//get方法拿菜单
                foodMenu.shiZiChaoJiDan();
                foodMenu.yuXiangRouSi();
        }
    }
    

    public class ChinaCooker implements FoodMenu{
        public void shiZiChaoJiDan(){
            System.out.Println("ChinaCooker shiZiChaoJiDan");
        }
        public void yuXiangRouSi(){
            System.out.Println("ChinaCooker yuXiangRouSi");
        }
    }
    

    public class AmericaCooker implements FoodMenu{
        public void shiZiChaoJiDan(){
            System.out.Println("AmericaCooker shiZiChaoJiDan");
        }
        public void yuXiangRouSi(){
            System.out.Println("AmericaCooker yuXiangRouSi");
        }
    }
    

    public class Test{
        public static void main(String[] args){
            FoodMenu cooker1 = new ChinaCooker();
            
            Customer customer = new Customer(cooker1);
            
            customer.order();
        }
    }
    

面向接口编程，可以降低耦合度，提高扩展力。符合OCP开发原则。

接口的使用离不开多态机制。

接口可以**解耦合**。

任何一个接口都有调用者和实现者。

接口可以将调用者和实现者解耦合。

调用者面向接口调用。

实现者面向接口编写实现。

• 以后进行大项目开发，一般是将项目分离成一个模块一个模块的，模块与模块之间采用接口衔接，降低耦合度。

• is a(继承）: Cat is a Animal ，继承关系。 A extends B

• has a （关联）: I has a Pen, 表示关联关系，通常以属性的形式存在。A{B b;}

• like a（实现）: Cooker like a FoodMenu，实现关系，类实现接口。A implements B

• 抽象类和接口的区别：

  • 抽象类是半抽象的，接口是完全抽象的。
  • 抽象类有构造方法，接口没有构造方法。
  • 类与类直接只能单继承，接口与接口之间支持多继承。
  • 一个类可以同时实现多个接口，一个抽象类只能继承一个类（单继承）。
  • 接口中只允许出现常量和抽象方法。
  • 接口一般对行为的抽象，用的比较多，抽象类较少。