java学习面向对象之接口

上一节当中我们说道抽象类，抽象类当中的方法可以是抽象的也可以是非抽象的，那么当抽象类中所有方法都是抽象的时候，我们就可以把它重新定义为接口。代码示例：

1 abstract class Animal
2 {
3 
4     abstract void eat();
5     abstract void goToBed();
6 
7 }

上述代码写成接口的形式为：

1 interface Animals
2 {
3 
4     public void eat();
5     public void goToBed();
6 
7 }

在接口当中的方法，也只能是方法名称，没有方法体。

类与类当中存在的关系是继承关系，那么类与接口之间是什么关系呢？类与接口之间的关系就是实现的关系，类实现接口。类与类当中只能够单继承，作为体系的扩展延伸，但是类与接口之间的实现，就对类做了功能上的扩展。同时接口的出现，也是java支持多继承的表现。虽然java不支持类的多继承，但是java中接口是可以多实现的，也就是说可以做到跟多继承相像的多功能上的扩展。并且，实现和继承是可以同时实现的。

类与接口的实现：

比如我们现在有个笔记本电脑，笔记本电脑是继承自电脑的，具有电脑所有的功能，但是笔记本本身又特有，折叠这个特殊的功能。我们可以这样定义，笔记本电脑继承自电脑这个抽象类，同时实现了折叠的这个功能。我们用代码来体现下：

 1 /**
 2 *抽象类Pc抽取出了Pc当中必须实现的
 3 *一些功能
 4 */
 5 abstract class Pc
 6 {
 7     /**
 8     *抽象类方法connectNet(),实现连接网络的方法
 9     *没有返回值
10     */
11     abstract void connectNet();
12     /**
13     *抽象类方法hasMouse(),实现电脑都有鼠标的功能
14     *没有返回值
15     */
16     abstract void hasMouse();
17 
18 }
19 
20 
21 /**
22 *接口ZheDie，提供折叠的功能
23 */
24 interface ZheDie
25 {
26     /**
27     *zheDie()提供折叠的方法
28     *没有返回值
29     */
30     public abstract void zheDie();
31 
32 }
33 
34 /**
35 *笔记本电脑继承了电脑这个体系，证明笔记本电脑是属于电脑的
36 *，具有电脑的所有功能以及属性。同时他又实现了折叠，这个特殊的
37 *功能。
38 */
39 class BookPc extends Pc implements ZheDie
40 {
41     /**
42     *实现了连网功能
43     */
44     public void connectNet()
45     {
46 
47         System.out.println("BookPc can connectNet");
48 
49     }
50     /**
51     *实现了鼠标功能
52     */
53     public void hasMouse()
54     {
55 
56         System.out.println("BookPc has a Mouse");
57 
58     }
59     /**
60     *实现了折叠的功能
61     */
62     public void zheDie()
63     {
64 
65         System.out.println("BookPc can be zheDie");
66 
67     }
68 
69 }
70 
71 class InterDemo2
72 {
73 
74     public static void main(String[] args) {
75         
76         new BookPc().zheDie();
77 
78     }
79     
80 
81 }

接口当中除了有方法之外，还可以有属性:

1 interface Demo
2 {
3 
4     public static final int a = 10;
5 
6 }

那么接口都有哪些细节需要注意呢？

1、接口不同于类，接口的定义方法是interface关键字不是class关键字。

2、接口只能被类用implement关键字实现不能被类继承，但是接口与接口之间可以被继承

3、接口可以实现类的多继承，也就是多实现。

4、接口中的方法都是抽象的并且是公开的，包括属性，也就是接口当中的属性还有方法前面的修饰词都是固定的。如果不加修饰词的情况下，在编译的时候会给加上的。

5、接口当中的方法还有成员变量都是公开的。成员函数用public abstract修饰，成员变量用public static final 修饰。因为类是实现接口，而不是继承接口。

6、接口当中的方法，必须被要实现这个接口的类全部实现。否则，这个实现了这个接口的类就是一个抽象类。

7、接口的出现，避免了单继承的局限性

java利用接口实现多继承：

在java当中不支持多继承，因为这样存在不确定性方法一样，不知道调用哪个？。但是java当中为了支持多继承，就用了“多实现”。多继承的意义存在于：提供功能，提高扩展性。

一个类可以实现多个接口。

 1 interface A
 2 {
 3 
 4     public void show1();
 5 
 6 }
 7 
 8 interface B
 9 {
10 
11     public void show2();
12 
13 }
14 
15 class Test implements    A,B //这个地方就体现了java通过多实现的方式，实现了多继承
16 {
17 
18     public void show1()
19     {
20 
21         System.out.print("Show1()");
22 
23     }
24 
25     public void show2()
26     {
27 
28         System.out.print("Show2()");
29 
30     }
31 
32 }
33 
34 class InterDemo3
35 {
36 
37     public static void main(String[] args) {
38         
39         Test t = new Test();
40         t.show1();
41         t.show2();
42 
43     }
44 
45 }

多实现需要注意的地方：

1、多实现的时候，由于没有方法体，就没有了两个方法，同时具有不同的方法体，且当实现的时候不知道该实现哪个方法这个不确定性的隐患。因为即使一个类实现了多个接口的时候，多个接口当中又具有相同方法的时候，这个时候相同的方法都是抽象方法，并且这些个抽象的方法在被类实现的时候，就被一个方法覆盖了，所以并不存在不确定性。

2、在抽象方法当中，返回值可以定义，方法接收的参数也是可以定义的。

 1 interface A
 2 {
 3 
 4     public void show();
 5 
 6 }
 7 
 8 interface B
 9 {
10 
11     public void show(int a,int b);
12 
13 }
14 
15 class Test implements    A,B 
16 {
17 
18     public void show()
19     {
20 
21         System.out.print("Show1()");
22 
23     }
24 
25     public void show(int a , int b)
26     {
27 
28         System.out.print("a + b = "+(a+b));
29 
30     }
31 
32 }
33 
34 class InterDemo3
35 {
36 
37     public static void main(String[] args) {
38         
39         Test t = new Test();
40         t.show();
41         System.out.println();
42         t.show(7,8);
43 
44     }
45 
46 }

这个样子写是正确的，但是这个样子写就是错误的：

 1 interface A
 2 {
 3 
 4     public void show();
 5 
 6 }
 7 
 8 interface B
 9 {
10 
11     public int show();//这样子写是错误的
12 
13 }
14 
15 class Test implements    A,B 
16 {
17 
18     public void show()
19     {
20 
21         System.out.print("Show1()");
22 
23     }
24 
25     public int show()
26     {
27 
28         return 1;
29 
30     }
31 
32 }
33 
34 class InterDemo3
35 {
36 
37     public static void main(String[] args) {
38         
39         Test t = new Test();
40         t.show();
41         System.out.println();
42         t.show();
43 
44     }
45 
46 }

这个就叫做，调用的不确定性。

接口与接口之间的关系，接口与接口之间是继承关系，并且是多继承的关系。因为接口当中的抽象方法，就避免了不确定性，比如：

 1 interface AA
 2 {
 3 
 4     public void show1();
 5 
 6 }
 7 
 8 interface BB
 9 {
10 
11     public void show2();
12 
13 }
14 
15 interface CC extends AA,BB
16 {
17 
18 
19 
20 }

这个就是接口与接口之间的继承关系，并且是多继承关系。

这样，当一个类实现CC这个接口的时候，就同时必须实现两个方法，即：

1 class Test implements CC
2 {
3 
4     public void show1(){}
5     public void show2(){}
6 
7 }

接口的特点：

1、接口是对外曝露的规则；

2、接口是对程序的扩展；

3、接口能够降低程序的耦合性；

4、接口可以用来多实现。

5、类与接口之间是实现的关系，一个类可以继承自一个类的同时，实现多个接口。而接口与接口之间是继承且是多继承的关系。

为了更形象的说明这个特点，我们来举一个例子来说一下，就拿笔记本电脑的这个例子来说：

早期的笔记本电脑是没有usb接口的，因为早期的笔记本电脑是把所需要的功能直接嵌入到笔记本当中，这样我们就可以用了。但是这个时候就出现了一个问题，就是如果我们不习惯笔记本的触摸板，想把触摸板替换成鼠标的话，我们就需要把笔记本拆开，并且把触摸板上面的两个线接入到鼠标上面，这样鼠标就可以使用了。同时如果我们这个时候笔记本键盘坏掉了，我们应该怎么办呢，我们也需要把笔记本拆开把键盘上的线引出来，接到我们完好的键盘上面。在做这些事情的时候，我们就会发现一个问题，这样来回的接线，会显得我们的笔记本电脑不够人性化，我们就在想，如果我们在生产笔记本的时候，可以预先保留几个特定规格的且有特定规则的接口，来供我们使用，这样就大大提高了笔记本的扩展性，和使用性。比如说，笔记本的生产厂家，在生产笔记本的时候，提前预留了这个接口。同时，鼠标、键盘厂家也按照这个接口做了一些鼠标和键盘出来，这样当我们不想用原装的时候，就可以利用这个usb接口直接接外接的键盘或者鼠标。这就就显得方便了许多，同样我们电脑主板上面也有许多这样的接口，不如PCI接口啊，内存接口啊，等等之类的。

我们用代码来体现的话就是：

 1 interface Usb
 2 {
 3 
 4     public void open();
 5     public void close();
 6 
 7 }
 8 
 9 
10 class UMouse implements Usb
11 {
12 
13     public void open()
14     {
15 
16         System.out.println("Mouse has opened");
17 
18     }
19 
20     public void close()
21     {
22 
23         System.out.println("Mouse has closed");
24 
25     }
26 
27 }
28 
29 class UKeypbord implements Usb
30 {
31 
32     public void open()
33     {
34 
35         System.out.println("Keybord has opened");
36 
37     }
38 
39     public void close()
40     {
41 
42         System.out.println("Keybord has closed");
43 
44     }
45 
46 }
47 
48 class BookPc
49 {
50 
51     public static void main(String[] args) {
52         
53         BookPc b = new BookPc();
54         b.method(null);
55         b.method(new UMouse());
56         b.method(new UKeypbord());
57     }
58 
59     private void method(Usb u)
60     {
61         if(u!=null){
62             u.open();
63             u.close();
64         }
65     }
66 
67 }

这里来说一下这个例子是如何体现接口的特点的：

1、定义接口，这个时候提供了给外界使用，并且鼠标、键盘厂商必须实现的两个方法，设备的关闭和开启。这个就是对外曝露的规则。

2、因为在笔记本出厂之前就实现了对这个功能的扩展，所以这个也是对笔记本电脑功能上的扩展。

3、同时在利用接口的同时，就不用把所有的代码都写在笔记本这个类当中，这样就降低了程序的耦合性，这样当我们要增加外加设备的时候，比如说要增加一个usb摄像头，这个时候，我们就可以在外边定义一个摄像头的类，然后实现usb这个接口中的所有方法，之后，在pc当中直接调用就好了。

以上就是接口的好处还有优点。

接口和抽象类的异同点总结：

1、共性：都是不断抽取出来的抽象概念。

2、异性一：抽象类体现继承关系，一个类只能单继承。接口体现实现的关系，一个类可以多实现。

3、异性二：抽象类是继承，是is a关系，在定义该体系当中基本共性的内容。接口是实现，是like a关系，在定义体系额外功能。举个例子来说，学生都具有学习的功能，但是打架的功能就是额外的，有的孩子不打架，有的就是天天打架。在这个地方我们用一个例子来形容下：

在我们生活当中犬又分为导盲犬、搜救犬等等，这个是按照功能来划分的，有的狗没有，有的狗就有。但是他们有一个共性就是都是犬，犬就是一个体系基本的功能，比如有叫，而导盲、搜救这些都属于额外功能，我们用代码来体现下。

 1 abstract class Dog
 2 {
 3 
 4     abstract public void houJiao();
 5 
 6 }
 7 
 8 interface DaoMang
 9 {
10 
11     public void lookWay();
12 
13 }
14 
15 interface SouJiu
16 {
17 
18     public void giveHelp();
19 
20 }
21 
22 class DaoMangDog extends Dog implements DaoMang
23 {
24 
25     public void houJiao()
26     {
27 
28         System.out.println("Flow me!");
29 
30     }
31 
32     public void lookWay()
33     {
34 
35         System.out.println("I can give you right way to home");
36 
37     }
38 
39 }
40 
41 class SouJiuDog extends Dog implements SouJiu
42 {
43 
44     public void houJiao()
45     {
46 
47         System.out.println("Is someone need Help?");
48 
49     }
50 
51     public void giveHelp()
52     {
53 
54         System.out.println("Ok I can give you a hand");
55 
56     }
57 
58 }
59 
60 class InterDemo6
61 {
62 
63     public static void main(String[] args) {
64         
65         new SouJiuDog().houJiao();
66         new DaoMangDog().houJiao();
67 
68     }
69 
70 }

4、异性三：抽象类当中有构造函数还有非抽象方法，可以直接供子类来使用。而接口当中只能存在抽象方法，并且都是公开属性，且有固定的修饰符。