java接口例子

“interface”（接口）关键字使抽象的概念更深入了一层。我们可将其想象为一个“纯”抽象类。它允许创建者规定一个类的基本形式：方法名、自变量列表以及返回类型，但不规定方法主体。接口也包含了基本数据类型的数据成员，但它们都默认为static和final。接口只提供一种形式，并不提供实施的细节。
接口这样描述自己：“对于实现我的所有类，看起来都应该象我现在这个样子”。因此，采用了一个特定接口的所有代码都知道对于那个接口可能会调用什么方法。这便是接口的全部含义。所以我们常把接口用于建立类和类之间的一个“协议”。有些面向对象的程序设计语言采用了一个名为“protocol”（协议）的关键字，它做的便是与接口相同的事情。
为创建一个接口，请使用interface关键字，而不要用class。与类相似，我们可在interface关键字的前面增加一个public关键字（但只有接口定义于同名的一个文件内）；或者将其省略，营造一种“友好的”状态。
为了生成与一个特定的接口（或一组接口）相符的类，要使用implements（实现）关键字。我们要表达的意思是“接口看起来就象那个样子，这儿是它具体的工作细节”。除这些之外，我们其他的工作都与继承极为相似。下面是乐器例子的示意图：

具体实现了一个接口以后，就获得了一个普通的类，可用标准方式对其进行扩展。
可决定将一个接口中的方法声明明确定义为“public”。但即便不明确定义，它们也会默认为public。所以在实现一个接口的时候，来自接口的方法必须定义成public。否则的话，它们会默认为“友好的”，而且会限制我们在继承过程中对一个方法的访问——Java编译器不允许我们那样做。
在Instrument例子的修改版本中，大家可明确地看出这一点。注意接口中的每个方法都严格地是一个声明，它是编译器唯一允许的。除此以外，Instrument5中没有一个方法被声明为public，但它们都会自动获得public属性。如下所示：

2. //: Music5.java
3. // Interfaces
4. import java.util.*;
6. interface Instrument5 {
7.   // Compile-time constant:
8.   int i = 5; // static & final
9.   // Cannot have method definitions:
10.   void play(); // Automatically public
11.   String what();
12.   void adjust();
13. }
15. class Wind5 implements Instrument5 {
16.   public void play() {
17.     System.out.println("Wind5.play()");
18.   }
19.   public String what() { return "Wind5"; }
20.   public void adjust() {}
21. }
23. class Percussion5 implements Instrument5 {
24.   public void play() {
25.     System.out.println("Percussion5.play()");
26.   }
27.   public String what() { return "Percussion5"; }
28.   public void adjust() {}
29. }
31. class Stringed5 implements Instrument5 {
32.   public void play() {
33.     System.out.println("Stringed5.play()");
34.   }
35.   public String what() { return "Stringed5"; }
36.   public void adjust() {}
37. }
39. class Brass5 extends Wind5 {
40.   public void play() {
41.     System.out.println("Brass5.play()");
42.   }
43.   public void adjust() { 
44.     System.out.println("Brass5.adjust()");
45.   }
46. }
48. class Woodwind5 extends Wind5 {
49.   public void play() {
50.     System.out.println("Woodwind5.play()");
51.   }
52.   public String what() { return "Woodwind5"; }
53. }
55. public class Music5 {
56.   // Doesn't care about type, so new types
57.   // added to the system still work right:
58.   static void tune(Instrument5 i) {
59.     // ...
60.     i.play();
61.   }
62.   static void tuneAll(Instrument5[] e) {
63.     for(int i = 0; i < e.length; i++)
64.       tune(e[i]);
65.   }
66.   public static void main(String[] args) {
67.     Instrument5[] orchestra = new Instrument5[5];
68.     int i = 0;
69.     // Upcasting during addition to the array:
70.     orchestra[i++] = new Wind5();
71.     orchestra[i++] = new Percussion5();
72.     orchestra[i++] = new Stringed5();
73.     orchestra[i++] = new Brass5();
74.     orchestra[i++] = new Woodwind5();
75.     tuneAll(orchestra);
76.   }
77. } ///:~

代码剩余的部分按相同的方式工作。我们可以自由决定上溯造型到一个名为Instrument5的“普通”类，一个名为Instrument5的“抽象”类，或者一个名为Instrument5的“接口”。所有行为都是相同的。事实上，我们在tune()方法中可以发现没有任何证据显示Instrument5到底是个“普通”类、“抽象”类还是一个“接口”。这是做是故意的：每种方法都使程序员能对对象的创建与使用进行不同的控制。