Java基础-面向接口（interface）编程

　　　　　　　　　　　　　　　　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>.需要定义子类的行为，又要为子类提供共性功能时才选用抽象类；