Java——接口

接口的特点

1、 所有属性都是公开静态常量

2、 所有方法都是公开抽象方法

abstract class MyAbstractClass{
    public static final int VALUE1 = 100; //属性是公开静态常量
    public static final int VALUE2 = 200; //第二个属性
    public abstract void m1(); //方法是公开抽象方法
    public abstract void m2(int n); //第二个方法
}
class MySubClass extends MyAbstractClass{#公开抽象方法
    public void m1(){}
    public void m2(int n){}
}

interface MyInterface{#接口
    public static final int VALUE1 = 100;
    public static final int VALUE2 = 200;
    public abstract void m1();
    public abstract void m2(int n);
}

interface 替代了 abstract class 这两个关键字。interface 关键字和 class 关键字类似，一个接口编译后会生成一个.class 文件；一个.java 文件中可以有多个接口，但是最多只能有一个公开的接口，且公开接口的接口名与文件名相同。

既然接口中所有属性都是公开静态常量，则接口中的属性，可以省略 public static final关键字；同样的，由于接口中所有方法都是公开抽象方法，因此可以省略 public abstract 关键字。因此，上面的 MyInterface 可以改写如下：

interface MyInterface{
    int VALUE1 = 100;
    int VALUE2 = 200; 
    void m1();
    void m2(int n); 
}

implements。使用这个关键字表示“实现”，类似于抽象类中子类继承父类的关系。

class MyImpl implements MyInterface{
    public void m1(){}
    public void m2(int n){}
}

1. 一个类实现接口，如果不希望这个类作为抽象类，则应该实现接口中定义的所有方法。

2. 接口中所有的方法都是公开方法。因此，在实现接口中的方法时，实现类的方法也必须写成公开的！由于类中的方法，默认访问修饰符是“default”，因此，在实现接口中的方法时，修饰符“public”不能省略。

除此之外，抽象类之间可以继承，同样的，接口之间也可以继承。接口之间继承时，使用的关键字同样为 extends。例如：

interface IA{
    void ma();
}
interface IB extends IA{
    void mb();
}

上面这个例子中，IB 接口继承自 IA 接口。因此，IB 中存在两个方法：ma 方法是从 IA接口中继承来的，mb 方法是 IB 接口自身定义的。如果有一个类要实现 IB 接口，则必须实现 ma 和 mb 两个方法，例如：

class IAIBImpl implements IB{
    public void ma(){}
    public void mb(){}
}

1.2 多继承

接口之间可以多继承。不同于 Java 中对于类之间的单继承的要求，接口之间没有这个限制。一个接口可以继承多个接口，例如下面这个例子：

interface IA{
    void ma();
    }
interface IB{
    void mb();
    }
interface IC extends IA, IB{ //IC 同时继承 IA 和 IB 两个接口
    void mc();
    }

除此之外，一个类在继承另外一个类的同时，还可以实现多个接口，例如下面的例子：

interface IA{
    void ma();
}
interface IB(){
    void mb();
}
//IC 继承自 IA，IB 接口。这里是接口的多继承
interface IC extends IA, IB{
    void mc();
}
interface ID{
    void md();
}
abstract class ClassE{
    public abstract void me();
}
    /*
    一个类可以继承自一个类，并实现多个接口
    MyImpl 继承自 ClassE 类，实现了 IC 和 ID 接口
    注意，先写继承自哪个类，再写实现了哪些接口
    */
class MyImpl extends ClassE implements IC, ID{
    //IC 接口中包含 ma、mb、mc 方法
    public void ma(){}
    public void mb(){}
    public void mc(){}
    //ID 接口中包含 md 方法
    public void md(){}
    //ClassE 中包含 me 方法
public void me(){}
}

接口和接口之间可以多继承；一个类在继承一个父类的同时，还能够实现多个接口。

1.3 接口与多态

有了接口的多继承特性，加上一个类能够实现多个接口，这样，接口结合多态，语法和概念都变得非常的灵活。

public class TestMyImpl{
public static void main(String args[]){
    IA ia = new MyImpl();
    System.out.println(ia instanceof IA);//true
    System.out.println(ia instanceof IB);//true
    System.out.println(ia instanceof IC);//true
    System.out.println(ia instanceof ID);//true
    System.out.println(ia instanceof ClassE);//true
    System.out.println(ia instanceof MyImpl);//true
    }
}

2 接口的作用

在 Java 中，接口主要用来实现两大功能：一是用接口实现多继承；二是用接口来进行解耦合。其中，后者是接口最重要的作用。

2.1 接口与多继承

首先，使用接口实现多继承，能够区分主要类型和次要类型。

父类体现了设备的共性，而子类体现了特性。

另外，单继承相对多继承的好处，就在于单继承具有简单性。使用单继承，类与类之间能够形成简单的树状结构。而对于多继承，类和类之间的关系相对要复杂的多，很有可能会形成复杂的网状结构。但是，用接口实现的多继承，则不会破坏类之间树状结构的简单性。这是因为这棵树是由类之间形成的，是事物主要类型所组成的关系。一个类实现再多的接口，有再多的次要类型，也不会改变其主要类型之间的树状结构。

2.2 接口与解耦合

除了实现多继承之外，接口最重要的作用就是解耦合。

class RedBulb {
    public void shine(){
    System.out.println(“Shine in Red”);
    }
}
class YellowBulb{
    public void shine(){
    System.out.println(“Shine in Yellow”);
    }
}
class GreenBulb{
    public void shine(){
        System.out.println(“Shine in Green”);
    }
}

class Lamp{
    private RedBulb bulb;
    public void setBulb(RedBulb bulb){
        this.bulb = bulb;
    }
    public void on(){
    bulb.shine();
    }
}
public class TestLamp{
    public static void main(String args[]){
    Lamp lamp = new Lamp();
    RedBulb rb = new RedBulb();
    lamp.setBulb(rb);
    lamp.on();
    }
}

由于 Lamp 类中的 bulb 属性是 RedBulb 类型，因此，一旦要修改，则必须要把 Lamp类中的属性类型进行修改，并且修改setBulb 方法的相应参数和实现。也就是说，当我们希望把 bulb 属性由 RedBulb 替换为 GreenBulb 的时候，必须修改 Lamp 类的代码。

也就是说，如果要想更换不同种类的灯泡，就要修改台灯的内部结构！这无疑是跟现实生活不相符合的。之所以产生这样的矛盾，原因在于 Lamp 类与 RedBulb 类型紧密联系在一起，形成了强耦合的关系，如下图：

下面我们使用接口来解决这样的问题。

interface Bulb{//首先，定义 Bulb 接口
    void shine();
}
class RedBulb implements Bulb{
    public void shine(){
        System.out.println(“Shine in Red”);
    }
}
class YellowBulb implements Bulb{
    public void shine(){
        System.out.println(“Shine in Yellow”);
    }
}
class GreenBulb implements Bulb{
    public void shine(){
        System.out.println(“Shine in Green”);
    }
}

class Lamp{
    private Bulb bulb;
    public void setBulb(Bulb bulb){
        this.bulb = bulb;
    }
    public void on(){
        bulb.shine();
    }
}
public class TestLamp{
    public static void main(String args[]){
    Lamp lamp = new Lamp();
    Bulb b1 = new RedBulb();
    lamp.setBulb(b1);
    lamp.on();
    Bulb b2 = new GreenBulb();
    lamp.setBulb(b2);
    lamp.on();
    }
}

Lamp 类的 bulb 属性被改为接口类型 Bulb，从而，Lamp 类与具体的实现类之间用 Bulb接口分离开了。当 Lamp 类希望把 bulb 属性由 RedBulb 对象变更为 GreenBulb 对象时，不需要修改任何自身代码。只需要调用 setBulb 方法，接受不同的 Bulb 接口的实现类就可以了，从而，Lamp 类通过 Bulb 接口，实现了与 Bulb 实现类的弱耦合。如下图所示：

3 接口回调