面向对象--接口

抽象类是从多个类中抽象出来的模板，若要将这种抽象进行得更彻底，则可以提炼出一种更加特殊的抽象类，也就是接口，接口里不能包含普通方法，接口里的所有方法都是抽象

方法。Java8中对接口进行了改进，允许在接口中定义默认方法，默认方法可以提供方法实现。这篇博客针对Java8之前的版本，关于Java8所有的改进我会后面相关分类中统一来

整理。

接口的概念

生活中听说过的USB接口其实并不是我们所看到的那些插槽，而是那些插槽所遵循的一种规范；而我们看到的那些插槽是根据USB规范设计出来的实例而已，也就说插槽是USB的

实例；对应不同型号的USB设备而言，他们各自的USB插槽都需要遵循一个规范，遵守这个规范就可以保证插入插槽的设备能与主板正常通信，对于同一种型号的主板上的多个

USB插槽，他们有相同的数据交换方式，相同的实现细节，可认为他们都是同一个类的不同实例。

软件系统的各模块之间也应该采用面向接口的耦合，从而尽量降低各模块之间的耦合，为系统提供更好的可扩展性和可维护性。

因此，接口定义的是多个类共同的公共行为规范，这些行为是与外部交流的通道，这就意味着接口通常定义一组公用方法。

如何理解接口，要从本质上去理解接口这个概念，也就是7个字，规范和实现分离。

接口的定义

定义接口使用interface关键字，接口定义的基本语法如下：

[修饰符] interface 接口名 extends 父接口1,父接口2...
{
    零个到多个抽象方法定义。。。
    零个到多个内部类，接口，枚举定义。。。
    零个到多个默认方法或类方法定义（Java1.8）
}

关于上面语法的详细说明如下：

1），修饰符可以是public或者省略的default，如果省略了public访问控制符，则默认采用包权限访问控制符，即只有在相同包接口下才可以访问该接口

2），接口名与类名一样，建议遵守Java可读性规范，使用驼峰规则，接口名通常使用形容词

3），一个接口可以有多个字节父接口，但接口只能继承接口，不能继承类

下面定义一个接口：

/**
 * 定义一个接口
 * 
 * @author LinkinPark
 */
public interface LinkinPark
{
	// 接口中的属性默认添加public static final三个修饰符
	String name1 = "LinkinPark";
	public static final String name2 = "NightWish";

	// 接口中的方法默认添加public abstract两个修饰符
	void sayHi1();
	public abstract void sayHi2();

	// 接口中定义的内部类，内部接口，内部枚举默认添加public static两个修饰符
	class Linkin1
	{
	}
	public static class Linkin2
	{
	}
}

定义一个接口，对于接口里定义的静态常量而言，他们是接口相关的，因此系统会自动为这些成员变量增加static和final两个修饰符。也就是说， 在接口中定义成员变量时，不管是

否使用public static final修饰符，接口里的成员变量总是使用这三个修饰符来修饰，而且接口里没有构造器和初始化块，因此接口里定义的成员变量只能在定义时指定默认值。

这点拿出来说主要是因为这点一直是Java存在的一个争论，就是说接口中是否应该定义属性，而且该属性是静态属性。接口本身就是一种规范，体现了实现和规范分离的设计原

则，所以规则中就不应该包含任何与具体实现相关的内容。但是我经常这么使用，比如在一个项目中，我一般不会写静态常量类，我一般都是写一个接口，里面定义一堆堆静态常

量，使用的时候直接把这个类实现那个接口就好了。至于这样到底好还是不好，我这里不做分析了，个人习惯而已。

接口的继承

接口的继承和类继承不一样，接口完全支持多继承，即一个接口可以有多个直接父接口。和类继承相似，子接口扩展某个父接口，将会获得父接口里定义的所有抽象方法，常量。

一个接口继承多个父接口时，多个父接口排在extends关键字之后，多个父接口之间以英文逗号“,”隔开。

/**
 * 接口的继承
 * 
 * @author LinkinPark
 */
public interface LinkinPark extends Linkin1, Linkin2
{
	public static void main(String[] args)
	{
		// 获得父类中所有的属性(静态常量)和方法(抽象方法)
		System.out.println(LinkinPark.name);
		System.out.println(LinkinPark.age);
	}
}

interface Linkin1
{
	String name = "LinkinPark";

	void sayHi();
}

interface Linkin2
{
	Integer age = 25;
}

接口的使用

接口不能用于创建实例，但接口可以用于声明引用类型变量。当使用接口来声明引用类型变量时，这个引用类型变量必须引用到其实现类的对象。除此之外，接口的主要用途就是

被实现类实现，归纳起来，接口主要有如下用途：

1），定义变量，也可用于进行强制类型转换

2），调用接口中定义的常量

3），被其他类实现

一个类可以实现一个或多个接口，继承使用extends关键字，实现则使用implements关键字。因为一个类可以实现多个接口，这也是Java为单继承灵活性不足所做的补充。

[修饰符] class 类名 implements 接口1, 接口2...
{
	类体部分。。。
}

1），接口的实现必须在 extends 之后

2），实现接口的方法必须是 public 类型

3），接口不能创建实例，但是可以声明引用类型的变量

实现接口和继承父类相似，一样可以获得所实现接口里定义的常量，方法。一个类实现了一个或多个接口之后，这个类必须完全实现这些接口里所定义的全部抽象方法，也就是重

写这些抽象方法，否则，该类将保留从父接口那里继承到的抽象方法，该类也必须定义成抽象类。

值得注意的一点是，实现接口方法时，必须使用public访问控制修饰符，因为接口里的方法都是public的，而实现类重写父类方法时访问权限只能相等或更大，所以实现类实现接口

里的方法只能使用public访问权限。

/**
 * 接口的实现
 * 
 * @author LinkinPark
 */
public class LinkinPark implements Linkin
{
	public static void main(String[] args)
	{
		Linkin linkin = new LinkinPark();
		linkin.sayHi();
		// 你用你优雅的姿势say hi
	}

	@Override
	public void sayHi()
	{
		System.out.println(hi);
	}
}

interface Linkin
{
	String hi = "你用你优雅的姿势say hi";

	void sayHi();
}

接口和抽象类

接口和抽象类很像，他们都具有如下特征：

1），都位于继承的顶端，用于被其他实现或继承

2），都不能实例化

3），都包含抽象方法，其子类都必须重写这些抽象方法

当然接口和抽象类之间的差别也非常大，这种差别主要体现在两者的设计目的上。接口体现的一种规范，对于接口的实现者而言，接口规定了实现者必须向外提供哪些服务，对于

接口的调用者而言，接口规定了调用者可以调用哪些服务，以及如何调用这些服务。当一个程序中使用接口时，接口是多个模块间的耦合标准，当在多个应用程序之间使用接口

时，接口是多个程序之间的通信标准。

从某种程序上来看，接口类似于整个系统的总纲，它规定了系统各模块应该遵循的标准，因此一个系统中的接口不应该经常改变，一旦接口被改写，对整个系统甚至其他系统的影

响将是辐射式的，导致系统中大部分类都需要改写。

抽象类则不一样，抽象类作为系统中多个子类的共同父类，它所体现的是一种模板式设计。抽象类作为多个子类的抽象父类，可以被当成系统实现过程中的中年产品，这个中间产

品实现了系统的部分功能，但这个产品依然不能当成最终产品，必须有更进一步的完善，这中完善可能是几种不同的方式。

具体编码方面，接口和抽象类存在如下差别：

1），接口中只能包含抽象方法和默认方法，不能为普通方法提供方法实现，抽象类则完全可以包含普通方法

2），接口里不能定义静态方法，抽象类里可以定义静态方法

3），接口里只能定义静态常量，不能定义普通成员变量，抽象类则既可以定义普通成员变量，也可以定义静态常量

4），接口里不包含构造器，抽象类可以包含构造器，注意抽象类里的构造器并不是用于创建对象，而是让其子类调用这些构造器来完成属于抽象类的初始化操作

5），一个类最多只能有一个直接父类，包括抽象类，但一个类可以实现多个接口，通过实现多个接口来弥补Java单继承的不足

接口和抽象类的选用：

1），优先选用接口，尽量少用抽象类，编程时面向接口编程

2），需要定义子类的行为，又要为子类提供共性功能时才选用抽象类，主要用于模板模式

面向接口编程

前面的整理已经说到了，接口体现的是一种规范和实现分离的设计哲学，充分利用接口可以极好的降低程序各模块之间的耦合，从而提高系统的可扩展性和可维护性。基于这种原

则，很多软件架构设计理论都倡导面向接口编程，而不是面向实现类编程，希望通过面向接口编程来降低程序的耦合。

具体的面向接口编程有两种常用的设计模式，工厂模式和命令者模式。关于设计模式我会在其他的分类中整理，这里不做赘述。

举一个实际的例子，先来看下面代码：

public class LinkinPark
{
	public static void main(String[] args)
	{
		LinkinPark linkin = new LinkinPark();
		linkin.sayHi();
		// 你用你优雅的姿势say hi
	}

	public void sayHi()
	{
		System.out.println("你用你优雅的姿势say hi");
	}
}

如果因为需求变化，上面的LinkinPark类要进行迭代，比如说类名的重新命名，比如说里面的sayHi方法重新实现，都将导致上面直接引用LinkinPark实例的代码做修改，都将导致

上面调用实例sayHi方法的代码做修改，改动量太大。一个简单的类都如此，如果在多个模块中，同样也是由类来组合和关联，将来一旦做迭代，改动量简直无法相信。除此之外，

就代码的可读性来说，使用接口表示一种规范，代码的含义也清清楚楚，有的时候我们并不关心一个方法的具体实现，我们只用关心方法签名和方法功能，这个时候面向接口编程

更加有助于我们对于整个代码的快速理解。高内聚，低耦合，一直是编程领域最高的境界，当然编码是一种艺术，好多的设计好多的理念好多的技巧还需我们一点一点来积累。