Java学习笔记之接口

一、接口的概念与定义

首先考虑一个简单的接口的定义：

public interface Output
{
    int MAX_LINE = 40;
    void out();
    void getData(String msg);
}

• 定义接口使用关键字interface
• 修饰符interface前面的public可以省略，如果省略，则采用默认访问控制，即只有在相同包结构的代码才可以访问此接口
• 接口不可以有构造方法（区别于类中的构造方法）
• 接口里面的所有成员，包括常量、方法等都是public访问权限，所以在定义接口里面的成员时，可以省略访问控制修饰符，非要修饰一下子，也只能用public
• 接口里面的属性（即成员变量）只能是常量，而且全部具有public, static, final三种性质，因此，在接口里面，如下两行语句完全等价：

int MAX_LINE = 40;
public static final MAX_LINE = 40;

• 接口里面的方法只能是抽象方法，即只声明一下函数类型，名称和参数列表，但是不可以提供具体实现

二、接口的继承

考虑如下代码：

 1 interface A
 2 {
 3     int PROP_A = 5;
 4     void testA();
 5 }
 6 interface B
 7 {
 8     int PROP_B = 6;
 9     void testB();
10 }
11 interface C extends A, B
12 {
13     int PROP_C = 7;
14     void testC();
15 }
16
17 public class myJavaTest
18 {
19     public static void main(String[] args)
20     {
21         System.out.println(C.PROP_A);
22         System.out.println(C.PROP_B);
23         System.out.println(C.PROP_C);
24
25     }
26 }

输出：

5

6

7

• 接口的继承和类的继承不一样，接口支持多继承，多个父接口排在extends关键字之后，多个父接口之间用逗号隔开，如上面11行所示,子接口C继承了父接口A和B
• 子接口继承类父接口之后，可以获得它们的成员常量的访问权限。如21 -23行通过子接口C可以访问父接口A,B的成员常量PROP_A和PROP_B

三、接口的实现和定义

考虑如下程序：

 1 interface Output
 2 {
 3     int MAX_LINE = 4;
 4     void out();
 5     void getData(String msg);
 6 }
 7
 8 interface Product
 9 {
10     int getProductTime();
11 }
12
13 //实现简单的打印作业
14 public class Printer implements Output, Product
15 {
16     private String[] printData = new String[MAX_LINE];
17     private int dataNum = 0; // 记录需要打印的作业数
18
19     public void out()
20     {
21         while (dataNum > 0)
22         {
23             System.out.println("打印机打印" + printData[0]);
24
25             //把作业队列整体前移一位，并将剩下的作业数减1
26             System.arraycopy(printData, 1, printData, 0, --dataNum);
27         }
28
29     }
30
31     @Override
32     public int getProductTime() {
33         // TODO Auto-generated method stub
34         return 45;
35     }
36
37     @Override
38     public void getData(String msg)
39     {
40         if (dataNum >= MAX_LINE)
41         {
42             System.out.println("输出队列已满，添加失败");
43         }
44         else
45         {
46             //把打印数据添加到队列里，作业数加1
47             printData[dataNum++] = msg;
48         }
49     }
50     public static void main(String[] args)
51     {
52         //创建一个Printer对象，当成Output使用
53         Output O = new Printer();
54         O.getData("123");
55         O.getData("456");
56         O.getData("789");
57         O.getData("ABC");
58         O.getData("def");
59         O.out();
60         //创建一个Printer对象，当成Product使用
61         Product P = new Printer();
62         System.out.println(P.getProductTime());
63     }
64 }

输出：

输出队列已满，添加失败
打印机打印123
打印机打印456
打印机打印789
打印机打印ABC
45

• 接口不能用于实例化，但是接口可以声明引用类型的变量，如53行，接口Output声明了一个引用变量O的类型是Output，61行，接口Product声明了一个引用变量P的类型是Product.
• 接口的实现需要用类，通常形式如下：

  [修饰符] class 类名 extends 父类 implements 接口1， 接口2..
  {
      类体部分
  }

  implements是表明这个类实现接口的关键字，一个类可以实现多个接口，多个接口之间用逗号隔开，如上述程序14行所示

• 一个类可以继承一个父类，并同时实现多个接口，此时，implements部分必须放在extends部分之后
• 一个类声明实现一个或者多个接口之后，则这个类必须完全实现这些接口里所定义的全部抽象方法（抽象方法就是那些只声明而没有实现的方法）；否则该类将保留从父接口那里继承的抽象方法，于是该类也必须定义成抽象类。

上述程序用类Printer实现了Output接口和Product接口，于是，Printer对象既可以赋给Output变量（53行）也可以赋给Product变量（61行），好像Printer类既是Output类的子类，也是Output类的子类，这就是传说中的Java的模拟多继承。

Java学习笔记之接口,布布扣,bubuko.com