接口是 Java 程序开发中很重要的一种思想，准确地讲不仅仅是 Java 编程，对于其他高级编程语言来说接口也是非常重要的，在实际开发中使用非常广泛。
接口是由抽象类衍生出来的一个概念，并由此产生了一种编程方式：面向接口编程。我们已经掌握了面向对象编程思想，那什么是面向接口编程呢？
面向接口编程不是一种思想，更准确地讲它应该是一种编程方式。
面向接口编程就是将程序的业务逻辑进行分离，以接口的形式去对接不同的业务模块。接口只串联不实现，真正的业务逻辑实现交给接口的实现类来完成。当用户需求变更的时候，只需要切换不同的实现类，而不需要修改串联模块的接口，减少对系统的影响。
上面这段解释不是很容易理解，我们通过一个现实生活中的例子来类比面向接口编程。
我们都知道计算机可以通过 USB 插口来连接外部设备，例如鼠标、U盘、散热架等。假如没有 USB 插口这种配置，那么外部设备就是固定在计算机上的，不能更换。例如一个鼠标固定在计算机上，但我现在希望换成 U 盘，怎么办呢？我们可能就需要把计算机拆了，重新组装计算机和 U 盘的内部连接。同理，每一次希望更换外置设备的时候，都需要把计算机拆了，移除之前的结构并重新组装，这种方式很显然是不可取的。维护成本太高，效率太低，用专业的语言来描述，叫作耦合性太高，模块和模块结合得太紧密，不灵活，要更换就必须重新构建内部组成来替换原有的结构。
但是有了 USB 插口之后，上述问题就迎刃而解了。通过 USB 插口连接到电脑上的外部设备是非常灵活的，即插即用，需要更换就拔掉旧的，把新的设备插入即可，这就是接口的思想。在设计制作计算机的时候，不需要考虑到底是跟鼠标、U 盘还是散热架连接，只需要把这个对接的部分提取出来，设计成一个接口。计算机内部只需要跟这个接口进行连接即可，你插入鼠标，计算机就识别鼠标，插入 U 盘就识别 U 盘。USB 插口就相当于接口，鼠标、U 盘、散热架就相当于接口的实现类，这样就很好理解了。
使用 USB 插口的方式可以很好地实现计算机与外部设备之间的各种切换，这是因为它们的连接是松散的、不紧密的，用专业的语言来讲就叫作低耦合，模块和模块之间连接松散，自然很容易切换。这里我们又引出来耦合性这个概念，很显然在实际开发中应该尽量降低程序的耦合性，以提高程序的扩展性，便于维护。
面向接口编程就具备以下优点：
能够最大限度地解耦，降低程序的耦合性；
使程序易于扩展；
有利于程序的后期维护。
了解完接口的概念，以及我们为什么要使用接口，接下来就是如何使用接口了。
如何使用接口
接口在 Java 中是独立存在的一种结构，和类相似，我们需要创建一个接口文件，Java 中用 class 关键字来标识类，用 interface 来标识接口，基本语法如下：
public interface 接口名{
public 返回值 方法名(参数列表);
}
看到定义接口的基本语法，你有没有一种很熟悉的感觉？没错，接口与抽象类非常相似，同样是定义了没有实现的方法，只是一个抽象的概念，没有具体实现。
接口其实就是一个极度抽象的抽象类。为什么这么说呢？抽象类的概念我们知道，一个类中一旦存在没有具体实现的抽象方法，那么该类就必须定义为抽象类，同时抽象类中是允许存在非抽象方法的。但是接口完全不同，接口中不能存在非抽象方法，必须全部是抽象方法，所以我们说接口是极度抽象的抽象类。
因为接口中全部是抽象方法，所以修饰抽象方法的 abstract 可以省略，不需要添加在方法定义处。当然，在定义方法时添加 abstract，程序也不会报错。
我们知道了接口中的方法必须全部是抽象的，那么接口中可以存在成员变量吗？答案是肯定的，接口中可以定义成员变量，但是有如下要求：
不能定义 private 和 protected 修饰的成员变量，只能定义 public 和默认访问权限修饰的成员变量。
接口中的成员变量在定义时必须被初始化。
接口中的成员变量都是静态常量，即可以直接通过接口访问，同时值不能被修改。
关于接口的创建，参考如下的代码：
public interface MyInterface {
public int ID = 0;
String NAME = "";
public void test();
}
接口定义完成，接下来如何使用呢？对于类的使用我们已经很熟悉了，首先需要实例化一个类的对象，然后通过对对象的操作来完成功能。但是接口的使用就大不一样了，因为接口是不能被实例化的，它描述的是一个抽象的信息，抽象的信息当然是没有实例的。
我们需要实例化的是接口的实现类。实现类就是对接口的抽象方法进行具体实现的，实现类本身就是一个普通的 Java 类，创建实现类的基本语法如下：
public class 实现类名 implements 接口名{
public 返回值 方法名(参数列表){
}
}
通过关键字 implements 来指定实现类具体要实现的接口，在实现类的内部需要对接口的所有抽象方法进行实现，同时要求访问权限修饰符、返回值类型、方法名和参数列表必须完全一致，例如：
public class MyImplements implements MyInterface{
@Override
public void test() {
// TODO Auto-generated method stub
System.out.println("实现了接口的抽象方法");
}
}
在这里接口与继承也有一个可以对比的地方，继承只能实现单继承，即一个子类只能继承一个父类。接口可以多实现，即一个实现类可以同时实现多个接口。如何去理解这句话呢？
接口实际上描述的是功能，让某个类实现接口，就是让该类具备某些功能。类比现实生活中的例子，一个孩子只能有一个亲爹，所以是单继承，但是一个孩子可以同时具备多个技能，所以是多实现。例如：
public interface MyInterface {
public void fly();
}
public interface MyInterface2 {
public void run();
}
public class MyImplements implements MyInterface,MyInterface2{
@Override
public void fly() {
// TODO Auto-generated method stub
System.out.println("实现了fly的功能");
}
@Override
public void run() {
// TODO Auto-generated method stub
System.out.println("实现了run的功能");
}
}
public class Test {
public static void main(String[] args) {
MyImplements myImplements = new MyImplements();
myImplements.fly();
myImplements.run();
}
}
运行结果为：
实现了fly的功能
实现了run的功能
面向接口编程的实际应用
面向接口编程是一种常用的编程方式，可以有效地提高代码的复用性，增强程序的扩展性和维护性，我们通过下面这个例子来学习什么是面向接口编程。
某工厂生产成品 A，主要由设备 A 来完成生产，用程序模拟这一过程。分别创建 Factory 类和 EquipmentA 类，并将 EquipmentA 设置为 Factory 的成员变量，在 Factory 的业务方法中调用 EquipmentA 的方法来完成生产，具体实现代码如下：
1) 定义 EquipmentA 类：
public class EquipmentA {
public void work() {
System.out.println("设备A运行，生产成品A");
}
}
2) 定义 Factory 类：
public class Factory {
private EquipmentA equipmentA;
//getter、setter方法
public void work() {
System.out.println("开始生产...");
this.equipmentA.work();
}
}
3) Test 类中的工厂开始生产成品：
public class Test {
public static void main(String[] args) {
EquipmentA equipmentA = new EquipmentA();
Factory factory = new Factory();
factory.setEquipmentA(equipmentA);
factory.work();
}
}
运行结果为：
开始生产...
设备A运行，生产成品A
现在工厂接了一份新订单，要求生产成品 B，需要设备 B 来完成生产，用程序实现这一过程，首先需要创建 EquipmentB 类，同时修改 Factory 内部的属性，代码如下：
1) 定义 EquipmentB 类：
public class EquipmentB {
public void work() {
System.out.println("设备B运行，生产成品B");
}
}
2) 修改 Factory 类，将成员变量的数据类型改为 EquipmentB：
public class Factory {
private EquipmentB equipmentB;
//getter、setter方法
public void work() {
System.out.println("开始生产...");
this.equipmentB.work();
}
}
3) 在 Test 类中完成生产：
public class Test {
public static void main(String[] args) {
EquipmentB equipmentB = new EquipmentB();
Factory factory = new Factory();
factory.setEquipmentB(equipmentB);
factory.work();
}
}
运行结果为：
开始生产...
设备B运行，生产成品B
这种方式需要修改 Factory 类的内部结构，如果此时需求又改回到生产成品 A 或者生产成品 C，就需要创建新的类，同时再次修改 Factory 类的属性信息，这种当需求发生变更就要频繁修改类结构的方式是我们应该避免的。这种结构的程序扩展性非常差，如何改进呢？使用面向接口编程即可。
将 Equipment 以接口的形式集成到 Factory 类中，具体实现如下：
1) 定义 Equipment 接口：
public interface Equipment {
public void work();
}
2) 定义 Equipment 接口的实现类 EquipmentA 和 EquipmentB：
public class EquipmentA implements Equipment{
@Override
public void work() {
// TODO Auto-generated method stub
System.out.println("设备A运行，生产成品A");
}
}
public class EquipmentB implements Equipment{
@Override
public void work() {
// TODO Auto-generated method stub
System.out.println("设备B运行，生产成品B");
}
}
3) 修改 Factory 类，将 Equipment 接口设置为成员变量：
public class Factory {
private Equipment equipment;
//getter、setter方法
public void work() {
System.out.println("开始生产...");
this.equipment.work();
}
}
4) Test 类中的工厂生产成品 A：
public class Test {
public static void main(String[] args) {
Equipment equipment = new EquipmentA();
Factory factory = new Factory();
factory.setEquipment(equipment);
factory.work();
}
}
运行结果为：
开始生产...
设备A运行，生产成品A
如果此时需要生产成品 B，修改起来就方便多了。因为嵌入到 Factory 类中的是接口，所以 Factory 类不需要修改，只需要将 EquipmentB 组件以接口的形式赋给 Factory 实例对象即可，Test 类中修改一处代码，代码如下：
public class Test {
public static void main(String[] args) {
Equipment equipment = new EquipmentB();
Factory factory = new Factory();
factory.setEquipment(equipment);
factory.work();
}
}
运行结果为：
开始生产...
设备B运行，生产成品B