接口（Java基础）

接口

接口：

微观概念：接口代表了某种能力

宏观概念：接口是一种标准

简单的说，接口就是一种被规范的标准，只要符合这个标准都可以通用，接口的表现

在于对行为的抽象。

就好比USB，每个厂商生产的USB我们都可以用，这是因为他们

有同一个标准，这里USB就是接口。

格式：

interface 接口名{}

public interface 接口名

接口只能包含：公共静态常量，公共抽象方法，（JDK8之后支持 普通方法）

特点：

1.接口中都是抽象方法和常量，不可能有非抽象方法，常量必须赋值

常量默认被public static final修饰

方法默认被public static abstract修饰

public interface Usb {
   //公共静态常量
   public static final double VERSION = 1.7;//double VERSION = 1.7;
   //默认 public static final
​
   //公共抽象方法
   public abstract void M1();//void M1();
   //默认 public static abstract
   void M2();
}

2.多态的实例化用implement关键字

public interface Usb {}定义一个接口
​
public class SubFan implements Usb {}创建一个类实现接口

3.接口不能被实例化，可以实现多态的形式实现实例化

public interface Usb {}定义一个接口
​
public class SubFan implements Usb {}创建一个类实现接口
​
public class Demo {
    public static void main(String[] args){
        SubFan fan = new SubFan();
        Usb Fan = new SubFan();
    }
}

4.多态的前提：

• 有继承或实现关系

• 有方法的重写

• 有父类或父接口引用指向子类或实现类对象

5.接口的实现类

必须重写接口中的所有方法，不想重写 则可以是抽象类（加上abstract）

但是子类继承了该抽象类必须重写接口中的方法

6.接口只能被public修饰

类与接口的关系

• 类和类之间是继承关系 （单继承）

• 接口和接口之间是继承关系 （多继承）

• 类和接口之间是实现关系（类实现接口）

类只支持单继承(即一个子类只有一个父类)，可以实现多个类

public class  A  extends  B implements C,B,D....{}

接口之间可以多重继承

public interface a extends b,c,d.....{}

常量接口

将多个常量统一定义在一个接口,方便管理

public interface Standard {
   double PI = Math.acos(-1);
   int N = (int)6.02e23;
}

接口的使用

public interface Usb {
   //公共静态常量
   public static final double VERSION = 1.7;
   //默认 public static final
​
   //公共抽象方法
   public abstract void M1();
   void M2();
   //默认 public abstract
}
​
public class SubFan implements Usb {
    @Override
    public void M1(){
        System.out.println("这是子类M1的方法");
    }
    @Override
    public void M2(){
        System.out.println("这是子类M2的方法");
    }
}
​
public class Demo {
    public static void main(String[] args){
        SubFan fan = new SubFan();
        Usb Fan = new SubFan();
        fan.M1();
        fan.M2();
        Fan.M1();
        Fan.M2();
    }
}
/*输出
这是子类M1的方法
这是子类M2的方法
这是子类M1的方法
这是子类M2的方法
*/
​
//============================================================================//
​
//接口作为一种标准
public interface Usb {
   void server();
}
​
public class UsbFan implements Usb{
    @Override
    public void server() {
        System.out.println("电风扇正在工作");
    }
}
​
public class Computer implements Usb {
    //
    Usb usb;
    @Override
    public void server() {
        System.out.println("电脑正在运行");
    }
}
​
public class Demo {
    public static void main(String[] args){
        Computer com = new Computer();
        com.server();
​
        com.usb = new UsbFan();
        com.usb.server();
    }
}
/*输出
电脑正在运行
电风扇正在工作
*/

接口多重继承的好处

定义了许多接口，如果一个设备要同时实现那么多接口将是不小的开销，对于同能

同类的可以把他用一个接口继承起来，这样这个接口就要了那些接口的全部功能，我们

使用类只要实现一个就可以了。

public interface Usb {
   void usb();
}
​
public interface Type_c {
    void typec();
}
​
public interface Charge{
    void charge();
}
​
public interface Computer extends Usb,Type_c,Charge {}
//接口继承接口

接口回调

先有接口的使用者，后有接口的实现者