Java基础-面向接口（interface）编程
作者：尹正杰
版权声明：原创作品，谢绝转载！否则将追究法律责任。
一.接口的概念
接口是功能的集合，同样可看做是一种数据类型，是比抽象类更为抽象的“类”。
接口是抽象的一种机制，现实事物的共性抽取成类，将不同类中的同名方法抽象成抽象方法，形成抽象类，对类的成员变量和方法继续抽象的话，就形成接口，接口是类的*的抽象机制。接口中只有常量和抽象方法，接口是一种规范，实现一个接口，就需要实现其中的所有抽象方法。
接口只描述所应该具备的方法，并没有具体实现，具体的实现由接口的实现类（相当于接口的子类）来完成。这样将功能的定义与实现分离，优化了程序设计。请记住：一切事物均为功能，即一切事物均为接口。
二.接口的定义
与定义class不同，接口定义时需要使用interface关键字。
定义接口所在的仍为".java"文件，虽然声明时使用的为interface关键字编译后仍然会产生“.class”文件。这点可以让我们将接口看做是一种只包含了功能声明的特殊类。定义格式如下：
public interface 接口名{
抽象方法1；
抽象方法2；
抽象方法3；
}
使用interface代替了原来的class，其它步骤与定义类相同（接口中的方法均为公共访问的抽象方法，接口中无法定义普通的成员变量（成员变量均为常量，需要用关键字fanal修饰）），下面是定义一个接口的案例：
/*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
EMAIL:y1053419035@qq.com
*/ public interface MyInterface {
public abstract void function();
}
三.类实现接口
1>.类实现接口的格式
类与接口的关系为实现关系，即类实现接口。实现的动作类似继承，只是关键字不同，实现使用关键字implements。其它类（实现类）实现接口后，就相当于声明：“我应该具备这个接口中的功能”。实现类仍然需要重写方法以实现具体的功能。格式如下：
class 类 implements 接口名{
实现接口中的抽象方法；
}
2>.接口是功能的集合
在类实现接口后，该类就会将接口中的抽象方法继承过来，此时该类需要重写该抽象方法，完成具体的逻辑。
a>.接口中定义功能，当需要具有该功能时，可以让类实现该接口，只声明了应该具备该方法，是功能的声明。
b>.在具体实现类中重写方法，实现功能，是方法的具体实现。
于是，通过以上两个动作将功能的声明与实现便分开了，此时请重写思考：类是实现事物的描述，而接口是功能的集合的含义。下面是我定义一个接口并用类去实现的简易代码：
/*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
EMAIL:y1053419035@qq.com
*/ interface MyInterface {
public abstract void function();
} class MyInterfaceImpl implements MyInterface{
public void function(){
System.out.println("实现接口的子类，重写接口抽象方法！");
}
} public class MyInterfaceDemo{
public static void main(String[] args){
MyInterfaceImpl m = new MyInterfaceImpl();
m.function();
}
} /*
实现接口的子类，重写接口抽象方法！
*/
四.接口中的成员变量的特点
1>.接口中成员变量的特点
a>.成员变量的特点，即没有变量，都是常量（固定格式：public static final 数据类型 变量名 = 值）；
b>.注意，public static final 修饰符，在接口的定义中可以省略不写，但是，不写并不等于没有！
/*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
EMAIL:y1053419035@qq.com
*/ interface MyInterface { public static final int x = 3; //注意，public static final 修饰符，在接口的定义中可以省略不写，但是，不写并不等于没有！
y = 6;
}
2>.接口中成员方法的特点
接口中修饰方法的固定格式为：“public abstract 返回值类型 方法名（参数列表）”。
/*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
EMAIL:y1053419035@qq.com
*/ interface MyInterface { public static final int x = 3; public abstract void show1(); //public abstract 修饰符是选择性书写，不管你写不写，这个修饰符默认都是存在的！
void show2();
} class MyInterfaceImpl implements MyInterface{
public void show1(){
System.out.println("show1()...");
}
public void show2(){
System.out.println("show2()...");
}
} public class MyInterfaceDemo{
public static void main(String[] args){
MyInterfaceImpl m = new MyInterfaceImpl();
m.show1();
m.show2();
}
} /*
以上代码执行结果如下：
show1()...
show2()...
*/
3>.实现(implements)类还是一个抽象类
接口是不可以创建对象的，子类必须覆盖掉接口所有的抽象方法后，子类才可以实例化。否则子类还是一个抽象类。
/*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
EMAIL:y1053419035@qq.com
*/ interface MyInterface { public abstract int getMax(int[] arr); public abstract int getMin(int[] arr); } class MyInterfaceImpl implements MyInterface{
public int getMax(int[] arr){
int max = arr[0];
for(int i=0;i<arr.length;i++){
if(arr[i] > max){
max = arr[i];
}
}
return max;
}
public int getMin(int[] arr){
int min = arr[0];
for(int i=0;i<arr.length;i++){
if(arr[i] < min){
min = arr[i];
}
}
return min;
}
} public class MyInterfaceDemo{
public static void main(String[] args){
MyInterfaceImpl m = new MyInterfaceImpl();
int[] arr = {1,2,3,4,5,6,7,8};
System.out.printf("数组中最大值是：%d,最小值是:%d\n",m.getMax(arr),m.getMin(arr)); }
} /*
以上代码执行结果如下：
数组中最大值是：8,最小值是:1
*/
五.接口的多实现(implements)
接口最重要的体验：解决多继承的弊端，将多继承这种机制在Java中通过多实现完成了。
1>.怎么解决多继承的弊端呢？
弊端：多继承时，当多个父类有相同功能时，子类调用会产生不确定性，其实核心原因就是在于多继承父类中功能有主题，而导致调用运行时，不确定运行哪个主体内容。
2>.为什么多实现能解决呢？
因为接口中的功能都没有方法体，由子类来明确。我们可以看下面这个案例：
/*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
EMAIL:y1053419035@qq.com
*/ interface A {
public abstract void a();
void d();
} interface B {
public abstract void b();
void d();
} class C implements A,B{
public void a(){
System.out.println("C.a()");
}
public void b(){
System.out.println("C.b()");
}
public void d(){
System.out.println("C.d()");
}
} public class MyInterfaceDemo{
public static void main(String[] args){
C c = new C();
c.a();
c.b();
c.d(); }
} /*
以上代码执行结果如下：
C.a()
C.b()
C.d()
*/
六.类在继承类的同时实现(implements)多接口
接口和类之间可以通过实现产生关系，同时也学习了类与类之间可以通过继承产生关系。当一个类已经继承了一个父类，它又不需要扩展额外的功能，这时接口就派上了用场了。子类通过继承父类扩展功能，通过继承扩展的功能都是子类应该具备的基础功能。如果子类想要继续扩展其它类中的功能呢？这时通过实现接口来完成。
一个类在继承一个类的同时，还可以实现多个接口，代码如下：
/*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
EMAIL:y1053419035@qq.com
*/ interface A {
public abstract void a();
} interface B {
public abstract void b();
} abstract class C{
public abstract void d();
} class D extends C implements A,B{
public void a(){
System.out.println("D.a()");
}
public void b(){
System.out.println("D.b()");
}
public void d(){
System.out.println("D.d()");
}
} public class MyInterfaceDemo{
public static void main(String[] args){
D d = new D();
d.a();
d.b();
d.d();
}
} /*
以上代码执行结果如下：
D.a()
D.b()
D.d()
*/
七.接口的多继承
多个接口之间可以使用extends进行继承，在开发中如果多个接口中存在相同方法，这时若有个类实现了这些接口，那么就要实现接口中的方法，由于接口中的方法是抽象方法，子类实现后也不会发生调用的不确定性。以下是一个接口继承多个接口的案例：
/*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
EMAIL:y1053419035@qq.com
*/ interface A {
public abstract void a();
} interface B {
public abstract void b();
} interface C{
public abstract void c();
} interface D extends A,B,C{
public abstract void d();
}
八.接口在开发中的好处
1>.接口的出现扩展了功能；
2>.接口其实就是暴漏出来的规则；
3>.接口的出现降低了耦合性，即设备与设备之间实现了解耦；
接口的出现方便后期使用和维护，一方是在使用接口（如电脑），一方在实现接口（如U盘）。
九.接口和抽象的区别
1>.相同点
a>.都位于继承的顶端，用于被其它类实现或继承；
b>.都不能直接实例化对象；
c>.都包含抽象方法，其子类都必须覆写这些抽象方；
2>.区别
a>.抽象类为部分方法提供实现，避免子类重复实现这些方法，提高代码复用性；接口只能包含抽象方法；
b>.一个类只能继承一个直接父类（可能是抽象类），却可以实现多个接口；接口弥补了Java的单继承；
c>.抽象类是这个事物中应该具备的内容，继承体系是一种“is....a”关系（比如，猫啊，虎啊，蛇啊，猪啊都是动物）；
d>.接口是这个事物中的额外内容，继承体系是一种“like...a”关系（就好比猫和蛇是宠物）；
3>.二者的选用
a>.优先选用接口，尽量少用抽象类；
b>.需要定义子类的行为，又要为子类提供共性功能时才选用抽象类；