接口的特点
1.1
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
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 接口与解耦合
除了实现多继承之外，接口最重要的作用就是解耦合。
lass 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 实现类的弱耦合。如下图所示：
