接口

接口

一、基本介绍

官方解释：Java接口是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为（功能）。

接口就是给出一些没有实现的方法，封装到一起，到某个类要使用的时候，再根据具体情况把这些方法写出来。接口是解决Java无法使用多继承的一种手段，但是接口在实际中更多的作用是制定标准的。

语法：

interface 接口名{
    //属性
    //方法（1、抽象方法 2、默认实现方法 3、静态方法）
}

class 类名 implements 接口名{
    //自己的属性；
    //自己的方法；
    //必须实现的接口的抽象方法
}

小结：

1. 在 jdk7.0 前，接口里的所有方法都没有方法体，即都是抽象方法。
2. jdk8.0后，接口可以有静态方法，默认方法，也就是说接口里可以有方法的具体实现。
3. 一个接口也能够拥有方法和属性，但是在接口中声明的方法默认是抽象的，接口中的属性默认为public static final。
4. 在接口中被default标记的方法为普通方法，可以直接写方法体，并且不强制实现类重写此方法。

二、使用细节

1. 接口不能被实例化。

2. 接口中所有方法都是 public方法，接口中的抽象方法，可以不用abstract修饰。

   

3. 一个普通类实现接口，就必须将该接口的所有方法都实现,可以使用 alt+insert 快捷键。

4. 抽象类可以不实现接口的抽象方法。

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

6. 接口中的属性，只能是final的，而且是public static final修饰符，比如：
   int n1 = 10;等价于 public static final int n1 = 10;（必须初始化）

7. 接口中属性的访问形式：接口名.属性名。

8. 接口不能继承其他的类，但是可以继承多个别的接口。

   interface ID extends IB,IC{}
   

9. 接口的修饰符只能是 public 和默认，这点和类的修饰符一样。

10. 如果一个类实现两个有同名方法的接口，则那个同名方法必须被重写。

11. 如果一个子类实现的接口的方法和父类的一个方法同名，则继承的是父类的方法，类优先于接口。

12. 类可以通过 类名.属性名访问到接口中的属性

三、实现接口 VS 继承类

1. 接口和继承解决的问题不同

   继承的价值在于：解决代码的复用性和可维护性。

   接口的价值在于：设计，设计好各种规范（方法），让其他类去实现这些方法。即更加的灵活。

2. 接口比继承更加灵活

   接口比继承更加灵活，继承是满足 is - a 的关系，而接口只需满足 like - a 的关系。

3. 接口在一定程度上实现代码解耦。[即 接口规范性 + 动态绑定]

四、接口的多态特性

1. 多态参数

   package com.hspedu.interface_;
   
   public class InterfacePolyParameter {    
       public static void main(String[] args) {        		//接口的多态表现        
    		//接口类型的变量 if01 可以指向 实现了 IF 接口的对象实例        
           IF anIf = new Monster();        
           anIf = new Car();        
           //继承的多态        
           //父类类型的变量 a 可以指向 实现l IF 接口的对象实例        
           AAA a = new BBB();        
           a = new CCC();    
       }
   }
   
   interface IF{}
   class Monster implements IF{}
   class Car implements IF{}
   
   class AAA{}
   class BBB extends AAA{}
   class CCC extends AAA{}
   

2. 多态数组

   package com.hspedu.interface_;
   
   public class InterfacePolyArr {
       public static void main(String[] args) {
           Usb[] usbs = new Usb[2];
           usbs[0] = new Phone_();
           usbs[1] = new Camera_();
   
           /*
           给Usb数组中，存放 Phone_ 和 Camera 对象，Phone_类还有一个特有的方法call()，
           请遍历Usb数组，如果是Phone_对象，除了调用Usb接口定义的方法外，
           还需要调用Phone_特有方法 call
           * */
           for (int i = 0; i < usbs.length; i++) {
               usbs[i].work();//动态绑定
               //和前面一样，我们仍需进行类型的向下转型
               if (usbs[i] instanceof Phone_){
                   ((Phone_) usbs[i]).call();
               }
           }
       }
   }
   
   interface Usb{
       void work();
   }
   
   class Phone_ implements Usb{
       public void call(){
           System.out.println("手机可以打电话...");
       }
   
       @Override
       public void work() {
           System.out.println("手机在工作中...");
       }
   }
   
   class Camera_ implements Usb{
       @Override
       public void work() {
           System.out.println("相机在工作中...");
       }
   }
   

3. 接口存在多态传递现象

   package com.hspedu.interface_;
   
   
   /**
    * 接口多态传递现象
    */
   public class InterfacePolyPass {
       public static void main(String[] args) {
           //接口类型的变量可以指向，实现该接口的类的对象实例
           IG ig = new Teacher();
           //如果IG 继承了 IH 接口 ，而Teacher类实现了 IG接口
           //那么实际上就相当于Teacher类也实现了 IH接口
           //这就是所谓的 接口多态传递现象
           IH ih = new Teacher();
       }
   }
   
   
   interface IH{
       void hi();
   }
   interface IG extends IH{}
   class Teacher implements IG{
       @Override
       public void hi() {
   
       }
   }