接 口

有時必須從幾個類中派生出一個子類，繼承它們所有的屬性和方法。但是，Java不支持多重繼承。有了接口，就可以得到多重繼承的效果。

接口(interface)是抽象方法和常量值的定義的集合。

從本質上講，接口是一種特殊的抽象類，這種抽象類中只包含常量和方法的定義，而沒有變量和方法的實現。

接口定義舉例

public interface Runner {
　　int id = 1;
　　public void start();
　　public void run();
　　public void stop();
}

接口的特點：

　　用 interface 來定義。

定義Java類的語法格式：

　　< modifier> class < name> [extends < superclass>]
　　[implements < interface> [,< interface>] ] {

接口應用舉例

public interface Runner {
　　public void start();
　　public void run();
　　public void stop();
}
public class Person implements Runner {
　　public void start() {
　　　　// 準備工作：彎腰、蹬腿、咬牙、瞪眼 // 開跑
　　}
　　public void run() {
　　　　// 擺動手臂
　　　　// 維持直線方向
　　}
　　public void stop() {

一個類可以實現多個無關的接口

interface Runner {
　　public void run();
}
interface Swimmer {
　　public double swim();
}
class Animal {
　　public int eat(){
　　　　…
　　}
}
class Person extends Animal implements Runner,Swimmer{
　　public void run() {……}
　　public double swim() {……}
　　public int eat() {……}
}

與繼承關系類似，接口與實現類之間存在多態性

public class Test {
　　public static void main(String args[]) {
　　　　Test t = new Test();
　　　　Person p = new Person();
　　　　t.m1(p);
　　　　t.m2(p);
　　　　t.m3(p);
　　}
　　public String m1(Runner f) { f.run(); }
　　public void m2(Swimmer s) {s.swim();}
　　public void m3(Animal a) {a.eat();}
}

如果實現接口的類中沒有實現接口中的全部方法，必須將此類定義為抽象類。 接口也可以繼承另一個接口，使用extends關鍵字。

interface MyInterface {
　　String s=“MyInterface”;
　　public void absM1();
}
interface SubInterface extends MyInterface {
　　public void absM2();
}
public class SubAdapter implements SubInterface {
　　public void absM1() {
　　　　System.out.println(“absM1”);
　　}
　　public void absM2() {
　　　　System.out.println(“absM2”);
　　}
}

實現類SubAdapter必須給出接口SubInterface以及父接口MyInterface中所有方法的實現

 1 /**
 2  * 接口: 抽象方法和常量的集合. 實際上接口更是一種規範!
 3  * 
 4  * 關於接口的提示:
 5  * 
 6  * 1. 實現接口的類中必須提供接口中所有方法的具體實現內容。 若該類為抽象類, 另當別論. 
 7  * 2. 多個無關的類可以實現同一個接口
 8  * 3. 與繼承關系類似, 接口與實現類之間存在多態性 
 9  */
10 public class TestInterface {
11     public static void main(String[] args) {
12     
13         System.out.println(Dao.DAO_NAME);
14         
15         Dao dao = new DaoImpl();
16         
17         ComparableCircle cc1 = new ComparableCircle(2);//練習題的測試
18         ComparableCircle cc2 = new ComparableCircle(7);
19         
20         System.out.println(cc1.compareTo(cc2)); 
21     }
22 }
23 //1. 用 interface 來定義。
24 interface Dao{
25     //2. 接口中的所有成員變量都默認是由 public static final 修飾的。 在聲明變量時必須直接賦值.
26     //常量標識符的書寫要求: 字母都大寫, 多個單詞使用 _ 連接
27     String DAO_NAME = "DAONAME";
28     
29     //3. 接口中的所有方法都默認是由public abstract修飾的。接口沒有構造方法。
30     void save(Object obj);
31     
32     Object get();
33 }
34 
35 interface Test{}
36 //5. 接口也可以繼承另一個接口，使用extends關鍵字。
37 interface Test2 extends Test{}
38 
39 class BaseDao{}
40 
41 //4. 實現接口使用 implements 關鍵字. 若一個類既實現接口, 有繼承了父類, 需要把 extends 關鍵字放在前面,
42 //即先繼承父類, 後實現多個接口.一個類可以實現多個無關的接口, 若實現多個接口, 使用 , 分割. 
43 class DaoImpl extends BaseDao implements Dao, Test{
44 
45     @Override
46     public Object get() {
47         return null;
48     }
49 
50     @Override
51     public void save(Object obj) {
52     }
53 }
54 
55 class DaoImpl2 implements Dao{
56 
57     @Override
58     public void save(Object obj) {
59     }
60 
61     @Override
62     public Object get() {
63         return null;
64     }
65 }

練習

定義一個接口用來實現兩個對象的比較。

interface CompareObject {
　　public int compareTo(Object o);
　　//若返回值是 0 , 代表相等; 若為正數，代表當前對象大；負數代表當前對象小
}

定義一個Circle類。

 1 public class Circle {
 2     protected double radius;
 3 
 4     public double getRadius() {
 5         return radius;
 6     }
 7 
 8     public void setRadius(double radius) {
 9         this.radius = radius;
10     }
11 
12     public Circle(double radius) {
13         this.radius = radius;
14     }
15 }

定義一個ComparableCircle類，繼承Circle類並且實現CompareObject接口。在ComparableCircle類中給出接口中方法compareTo的實現體，用來比較兩個圓的半徑大小。

 1 /**
 2  * 定義一個ComparableCircle類，繼承Circle類並且實現CompareObject接口。
 3  * 在ComparableCircle類中給出接口中方法compareTo的實現體，用來比較兩個圓的半徑大小。
 4  */
 5 public class ComparableCircle extends Circle implements CompareObject {
 6 
 7     public ComparableCircle(double radius) {
 8         super(radius);
 9     }
10 
11     @Override
12     public int compareTo(Object o) {
13         
14         //1. 檢驗 o 是否為 Circle 類型
15         if(o instanceof Circle){
16             Circle circle = (Circle) o;
17             //2. 比較半徑
18             return (int)(this.radius - circle.radius);
19         }
21         return 0;
22     }
23 }

定義一個測試類TestInterface，創建兩個ComaparableCircle對象，調用compareTo方法比較兩個類的半徑大小。

　　ComparableCircle cc1 = new ComparableCircle(3);
　　ComparableCircle cc2 = new ComparableCircle(5);
         
　　System.out.println(cc1.compareTo(cc2)); 

高級類特性----接口(intertface)