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

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

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　作者：尹正杰

版权声明：原创作品，谢绝转载！否则将追究法律责任。

 

 

 

一.接口的概念

　　接口是功能的集合，同样可看做是一种数据类型，是比抽象类更为抽象的“类”。

　　接口是抽象的一种机制，现实事物的共性抽取成类，将不同类中的同名方法抽象成抽象方法，形成抽象类，对类的成员变量和方法继续抽象的话，就形成接口，接口是类的最高级的抽象机制。接口中只有常量和抽象方法，接口是一种规范，实现一个接口，就需要实现其中的所有抽象方法。

　　接口只描述所应该具备的方法，并没有具体实现，具体的实现由接口的实现类（相当于接口的子类）来完成。这样将功能的定义与实现分离，优化了程序设计。请记住：一切事物均为功能，即一切事物均为接口。

 

二.接口的定义

　　与定义class不同，接口定义时需要使用interface关键字。

　　定义接口所在的仍为".java"文件，虽然声明时使用的为interface关键字编译后仍然会产生“.class”文件。这点可以让我们将接口看做是一种只包含了功能声明的特殊类。定义格式如下：

1 public interface 接口名{
2         抽象方法1；
3         抽象方法2；
4         抽象方法3；
5 }

　　使用interface代替了原来的class，其它步骤与定义类相同（接口中的方法均为公共访问的抽象方法，接口中无法定义普通的成员变量（成员变量均为常量，需要用关键字fanal修饰）），下面是定义一个接口的案例：

1 /*
2 @author :yinzhengjie
3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
4 EMAIL:y1053419035@qq.com
5 */
6 
7 public interface MyInterface {
8     public abstract void function();
9 }

 

三.类实现接口

1>.类实现接口的格式

　　类与接口的关系为实现关系，即类实现接口。实现的动作类似继承，只是关键字不同，实现使用关键字implements。其它类（实现类）实现接口后，就相当于声明：“我应该具备这个接口中的功能”。实现类仍然需要重写方法以实现具体的功能。格式如下：

1 class 类 implements 接口名{ 
2      实现接口中的抽象方法； 
3 }     

2>.接口是功能的集合　　

　　在类实现接口后，该类就会将接口中的抽象方法继承过来，此时该类需要重写该抽象方法，完成具体的逻辑。

　　　　a>.接口中定义功能，当需要具有该功能时，可以让类实现该接口，只声明了应该具备该方法，是功能的声明。

　　　　b>.在具体实现类中重写方法，实现功能，是方法的具体实现。

　　于是，通过以上两个动作将功能的声明与实现便分开了，此时请重写思考：类是实现事物的描述，而接口是功能的集合的含义。下面是我定义一个接口并用类去实现的简易代码：

 1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6 
 7 interface MyInterface {
 8     public abstract void function();
 9 }
10 
11 class MyInterfaceImpl implements MyInterface{
12     public void function(){
13         System.out.println("实现接口的子类，重写接口抽象方法！");
14     }
15 }
16 
17 public class MyInterfaceDemo{
18     public static void main(String[] args){
19         MyInterfaceImpl m = new MyInterfaceImpl();
20         m.function();
21     }
22 }
23 
24 /*
25 实现接口的子类，重写接口抽象方法！
26 */

 

四.接口中的成员变量的特点

1>.接口中成员变量的特点

　　a>.成员变量的特点，即没有变量，都是常量（固定格式：public static final 数据类型 变量名 = 值）；

　　b>.注意，public static final 修饰符，在接口的定义中可以省略不写，但是，不写并不等于没有！

 1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6 
 7 interface MyInterface {
 8     
 9     public static final int x = 3;
10     
11     //注意，public static final 修饰符，在接口的定义中可以省略不写，但是，不写并不等于没有！
12     y = 6;    
13 }

2>.接口中成员方法的特点

　　接口中修饰方法的固定格式为：“public abstract 返回值类型 方法名（参数列表）”。

 1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6 
 7 interface MyInterface {
 8     
 9     public static final int x = 3;
10     
11     public abstract void show1();
12     
13     //public abstract 修饰符是选择性书写，不管你写不写，这个修饰符默认都是存在的！
14     void show2();
15 }
16 
17 class MyInterfaceImpl implements MyInterface{
18     public void show1(){
19         System.out.println("show1()...");
20     }
21     public void show2(){
22         System.out.println("show2()...");
23     }
24 }
25 
26 public class MyInterfaceDemo{
27     public static void main(String[] args){
28         MyInterfaceImpl m = new MyInterfaceImpl();
29         m.show1();
30         m.show2();
31     }
32 }
33 
34 /*
35 以上代码执行结果如下：
36 show1()...
37 show2()...
38 */

3>.实现(implements)类还是一个抽象类

　　接口是不可以创建对象的，子类必须覆盖掉接口所有的抽象方法后，子类才可以实例化。否则子类还是一个抽象类。

 1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6 
 7 interface MyInterface {
 8     
 9     public abstract int getMax(int[] arr);
10     
11     public abstract int getMin(int[] arr);
12     
13 }
14 
15 class MyInterfaceImpl implements MyInterface{
16     public int getMax(int[] arr){
17         int max = arr[0];
18         for(int i=0;i<arr.length;i++){
19             if(arr[i] > max){
20                 max = arr[i];
21             }
22         }
23         return max;
24     }
25     public int getMin(int[] arr){
26         int min = arr[0];
27         for(int i=0;i<arr.length;i++){
28             if(arr[i] < min){
29                 min = arr[i];
30             }
31         }
32         return min;
33     }
34 }
35 
36 public class MyInterfaceDemo{
37     public static void main(String[] args){
38         MyInterfaceImpl m = new MyInterfaceImpl();
39         int[] arr = {1,2,3,4,5,6,7,8};
40         System.out.printf("数组中最大值是：%d,最小值是:%d\n",m.getMax(arr),m.getMin(arr));
41         
42     }
43 }
44 
45 /*
46 以上代码执行结果如下：
47 数组中最大值是：8,最小值是:1
48 */

 

五.接口的多实现(implements)

　　接口最重要的体验：解决多继承的弊端，将多继承这种机制在Java中通过多实现完成了。

1>.怎么解决多继承的弊端呢？

 　　弊端：多继承时，当多个父类有相同功能时，子类调用会产生不确定性，其实核心原因就是在于多继承父类中功能有主题，而导致调用运行时，不确定运行哪个主体内容。

2>.为什么多实现能解决呢？

 　　因为接口中的功能都没有方法体，由子类来明确。我们可以看下面这个案例：

 1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6 
 7 interface A {
 8     public abstract void a();
 9     void d();
10 }
11 
12 interface B {
13     public abstract void b();    
14     void d();
15 }
16 
17 class C implements A,B{
18     public void a(){
19         System.out.println("C.a()");
20     }
21     public void b(){
22         System.out.println("C.b()");
23     }
24     public void d(){
25         System.out.println("C.d()");
26     }
27 }
28 
29 
30 public class MyInterfaceDemo{
31     public static void main(String[] args){
32         C c = new C();
33         c.a();
34         c.b();
35         c.d();
36         
37     }
38 }
39 
40 /*
41 以上代码执行结果如下：
42 C.a()
43 C.b()
44 C.d()
45 */

 

六.类在继承类的同时实现(implements)多接口

　　接口和类之间可以通过实现产生关系，同时也学习了类与类之间可以通过继承产生关系。当一个类已经继承了一个父类，它又不需要扩展额外的功能，这时接口就派上了用场了。子类通过继承父类扩展功能，通过继承扩展的功能都是子类应该具备的基础功能。如果子类想要继续扩展其它类中的功能呢？这时通过实现接口来完成。

　　一个类在继承一个类的同时，还可以实现多个接口，代码如下：

 1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6 
 7 interface A {
 8     public abstract void a();
 9 }
10 
11 interface B {
12     public abstract void b();    
13 }
14 
15 abstract class C{
16     public abstract void d();
17 }
18 
19 class D extends C implements A,B{
20     public void a(){
21         System.out.println("D.a()");
22     }
23     public void b(){
24         System.out.println("D.b()");
25     }
26     public void d(){
27         System.out.println("D.d()");
28     }
29 }
30 
31 
32 public class MyInterfaceDemo{
33     public static void main(String[] args){
34         D d = new D();
35         d.a();
36         d.b();
37         d.d();
38     }
39 }
40 
41 /*
42 以上代码执行结果如下：
43 D.a()
44 D.b()
45 D.d()
46 */

 

七.接口的多继承

　　多个接口之间可以使用extends进行继承，在开发中如果多个接口中存在相同方法，这时若有个类实现了这些接口，那么就要实现接口中的方法，由于接口中的方法是抽象方法，子类实现后也不会发生调用的不确定性。以下是一个接口继承多个接口的案例：

 1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6 
 7 interface A {
 8     public abstract void a();
 9 }
10 
11 interface B {
12     public abstract void b();    
13 }
14 
15 interface C{
16     public abstract void c();
17 }
18 
19 interface D extends A,B,C{
20     public abstract void d();
21 }

 

八.接口在开发中的好处

1>.接口的出现扩展了功能；

2>.接口其实就是暴漏出来的规则；

3>.接口的出现降低了耦合性，即设备与设备之间实现了解耦；

　　接口的出现方便后期使用和维护，一方是在使用接口（如电脑），一方在实现接口（如U盘）。

 

九.接口和抽象的区别

1>.相同点

　　a>.都位于继承的顶端，用于被其它类实现或继承；

　　b>.都不能直接实例化对象；

　　c>.都包含抽象方法，其子类都必须覆写这些抽象方；

2>.区别

　　a>.抽象类为部分方法提供实现，避免子类重复实现这些方法，提高代码复用性；接口只能包含抽象方法；

　　b>.一个类只能继承一个直接父类（可能是抽象类），却可以实现多个接口；接口弥补了Java的单继承；

　　c>.抽象类是这个事物中应该具备的内容，继承体系是一种“is....a”关系（比如，猫啊，虎啊，蛇啊，猪啊都是动物）；

　　d>.接口是这个事物中的额外内容，继承体系是一种“like...a”关系（就好比猫和蛇是宠物）；

3>.二者的选用

　　a>.优先选用接口，尽量少用抽象类；

　　b>.需要定义子类的行为，又要为子类提供共性功能时才选用抽象类；