接口的概念

Java接口的概念：

讲的是狭义的接口类型。广义的接口是指类的接口、方法的接口。

初期理解，可以认为是一个特殊的抽象类

当抽象类中的方法都是抽象的，那么该类可以通过接口的形式来表示。

 

Java接口类似于纯抽象类，只包含常量和抽象方法，而没有变量和具体方法。从更深层次理解Java接口，是定义（规范、约束）与实现的分离。Java接口本身没有任何实现，所以Java接口比Java抽象类更抽象化。Java接口的方法只能是抽象的和公开的，Java接口不能有构造方法，Java接口可以有public 的，静态的final属性。

 

格式：

Interface{}

接口定义时，格式特点：

1.常见定义：常量，抽象方法

2.接口中的成员都有固定的修饰符

成员常量：public static final

成员函数：public abstract 

 

接口中的成员都是public的。

 

[html] view plaincopyprint?

1. interface Inter  
2. {  
3.     public static final int num = 3;  
4.     public abstract void show ();  
5. }  

 

其中，num 的修饰符除int外，可以全部去掉。

[html] view plaincopyprint?

1. interface Inter  
2. {  
3.     int num = 3;  
4.     void show ();  
5. }  

即使什么也不写，接口内的成员的修饰符没变，即num的修饰符是public static final ，show方法的修饰符是 public abstract 。  

    

接口是不可以创建对象的，因为有抽象方法，需要被子类实现，子类对接口中的抽象方法全部复写后，子类才能实例化，否则子类是一个抽象类。

 

 

接口与类之间的关系：实现 implements

 

 

接口可以被类多实现。弥补了Java 不能多继承的缺陷。

Java不能多继承的原因：

假如说有两个类：

[html] view plaincopyprint?

1. class A  
2. {  
3.     int num = 10;  
4.     void show ()  
5.     {  
6.         System.out.println(num);  
7.     }  
8. }  
9.   
10. class B  
11. {  
12.     int num  = 20;  
13.     void show ()  
14.     {  
15.         System.out.println(num);  
16.     }  
17. }  

再来一个类C同时继承这两个，那么调用C类对象的show方法，那么问题来了：调用的是哪个类中的show方法，输出的num的值又是多少？

这就是Java舍弃了多继承的原因。

 

为什么多继承不可以，多实现就可以？

这是因为接口所固定的成员修饰符。变量都是常量，方法都是抽象的，没有方法体，具体的实现由子类完成，所以就不会引起混乱。

 

 

那么如果多实现的两个接口中有相同的方法怎么办？

还是那句话，方法都是抽象的，具体的实现由子类完成。子类只需完成一次复写操作就可以覆盖掉接口中的同名方法。

 

[html] view plaincopyprint?

1. interface Inter  
2. {  
3.     public static final int num = 3;  
4.     public abstract void show ();  
5. }  
6.   
7. interface Inter_b  
8. {  
9.     public static final int num = 10;  
10.     public abstract void show ();  
11. }  
12.   
13. class Test implements Inter,Inter_b  
14. {  
15.     public void show ()  
16.     {  
17.         System.out.println(Inter.num+"\n"+Inter_b.num);  
18.     }  
19. }  
20.   
21. public class Interface  
22. {  
23.     public static void main (String[] args)  
24.     {  
25.         new Test().show ();  
26.     }  
27. }  

 

 

 

一个类在继承一个类的同时还能实现多个接口。

具体的形式如下：

class A extends B implements C,D

先继承，再实现。

其中A与B是类名，C与D是接口名

意思就是，定义类A继承了类B，同时实现接口C和D。

 

 

[html] view plaincopyprint?

1. interface Inter  
2. {  
3.     public static final int num = 3;  
4.     public abstract void show ();  
5. }  
6.   
7. interface Inter_b  
8. {  
9.     public static final int num = 10;  
10.     public abstract void show ();  
11. }  
12.   
13. class Ress  
14. {  
15.     int x = 20;  
16.     public void display ()  
17.     {  
18.         System.out.println("Res.show()"+x);  
19.     }  
20. }  
21.   
22. class Test extends Ress implements Inter,Inter_b  
23. {  
24.     public void show ()  
25.     {  
26.         System.out.println(Inter.num+"\n"+Inter_b.num);  
27.     }  
28. }  
29.   
30. public class Interface  
31. {  
32.     public static void main (String[] args)  
33.     {  
34.         new Test().show ();  
35.         new Test().display();  
36.     }  
37. }  

 

 

接口与接口之间的关系：

类与类之间是继承关系

类与接口之间是实现关系

接口与接口之间是继承关系

接口之间存在多继承。

 

 

[html] view plaincopyprint?

1. interface A  
2. {  
3.     int num = 0;  
4.     void show1 ();  
5. }  
6.   
7. interface B  
8. {  
9.     int num = 2;  
10.     void show2 ();  
11. }  
12.   
13. interface C extends A,B  
14. {  
15.     void show3 ();  
16. }  
17.   
18. class Test implements C  
19. {  
20.     public void show1 () {}  
21.     public void show2 () {}  
22.     public void show3 () {}  
23. }