摘要：類似于中的事件驅動函數，當有事件發生時候，通過回調函數，通知主函數。一旦或內的某個函數觸發了某個事件，就能通過監聽接口發送給主函數，類似中的事件回調函數。父類與子類通過實現接口調用，此時即為父類本身。

  
http://homeway.me/

查了一些國內資料，都說java中extended與implements的區別是，一個類只能有一個繼承，一個類可以有多個容器。

后來去看了些國外資料。

在我理解上，interface就是一個公共的類，可以包含公共函數、變量。

Java接口是用于指定一組抽象方法的類來實現一個抽象類型。

當一個類實現一個接口，它必須繼承所有的內聲明的抽象方法，好像簽訂了一份合同，并履行協議。

先來看看怎么聲明一個接口，文件保存為 InterFace.java：

public class InterFace {
    public static void main(String[] args) {
        MyTest x = new MyTest();
        x.speak();
        x.say();
        x.fuck();
    }
}
class MyTest implements MyInterface2, MyInterface3 {
    @Override
    public void speak() {
        System.out.println("MyTest Called => jump() =>"+MyInterface.hello);
    }
    @Override
    public void fuck() {
        System.out.println("MyTest Called => fuck()");
    }
    @Override
    public void say() {
        System.out.println("MyTest Called => say()");
    }    
}
interface MyInterface1{
    public String hello = "hello";
    public void speak();
}
interface MyInterface2{
    public int num = 1;
    public void fuck();
}
// 接口之間可以相互繼承
interface MyInterface3 extends MyInterface1{
    public void say();
}

輸出如下：

$javac InterFace.java
$java InterFace

MyTest Called => jump() =>hello
MyTest Called => say()
MyTest Called => fuck()

這里我們聲明了3個接口，并且interface3繼承自interface1，所以當類容器導入接口interface3就會導入父類接口interface1。

只要添加了容器implements，就會包含接口中的所有東西，所以必須在MyTest類中添加該重寫函數，否則找不到該函數會報錯。

再看下面一個例子，多個類共同使用一個interface接口，保存為Account.java：

interface Transaction {
    int BALANCE = 500;
    Object transaction(Object input);
}
class CurrentAccount implements Transaction {
    int bal;
    public Object transaction(Object input) {
        this.bal = BALANCE - (int)input;
        return bal;
    }
    public String toString() { return "Current acc"; }
}
class SavingsAccount implements Transaction {
    int bal;
    public Object transaction(Object input) {
        this.bal = BALANCE + (int)input;
        return bal;
    }
    public String toString() { return "Savings acc"; }
}
public class Account {
    public static void payment(Transaction t, Object input) {
        System.out.println(t + " is debited:   " +  t.transaction(input));
    }
    public static void deposit(Transaction t, Object input) {
        System.out.println(t + " is credited:   " +  t.transaction(input));
    }
    public static void main(String[] args) {
        Integer input = new Integer(600);
        deposit(new SavingsAccount(), input);
        payment(new CurrentAccount(), input);
    }
}

代碼輸出：

$javac Account.java
$java Account

Savings acc is credited:   1100
Current acc is debited:   -100

一個接口可以供多個類共同使用，并且多個類之間使用不沖突，這樣看來，interface倒有點像是靜態函數了。

觀察一下這兩個實現類活期賬戶和儲蓄賬戶自動的向上轉型在接受Transaction接口Account類中的方法。

payment()和deposit()方法利用我們所講的戰略設計模式，代表了接口的實現完全脫鉤的一個實例。

從理論上說，你可以適應任何類，只需使它們符合的界面，使用這些方法。

對于接口與容器，我見過的一個更具有實用價值的地方，在于類之間的監聽函數調用。

類似于js中的事件驅動函數，當有事件發生時候，通過回調函數，通知主函數。

實例代碼如下，文件命名為Homeway.java：

public class Homeway {
    public static void main(String[] args) {
        System.out.println("
=======================Implements======================
");
        ClassImplements mClassImplements = new ClassImplements();
        mClassImplements.run();
    }
}
class ClassImplements implements Implements1.Listener {
    public Implements1 mImplements1 = null;
    public ClassImplements(){
        mImplements1 = new Implements1();
        mImplements1.setListener(this);
    }
    @Override
    public void onCallStart(){
        System.out.println("ClassImplements => onCallStart()");
    }
    @Override
    public void onCallStop(){
        System.out.println("ClassImplements => onCallStop()");
    }
    public void run(){
        mImplements1.run();
    }
}
//test 2level implements for class
class Implements1 implements Implements2.Listener {
    private Listener mListener;
    private Implements2 mImplements2;
    public Implements1(){
        mImplements2 = new Implements2();//把當前類傳給下個類
        mImplements2.setListener(this);
        System.out.println("Init Implements1 =>...");
    }
    public static interface Listener {
        void onCallStart();
        void onCallStop();
    }
    public void setListener(Listener listener) {
        mListener = listener;
    }
    @Override
    public void onCallStart(){
        System.out.println("Implements1 => onCallStart()");
        mListener.onCallStart();//call at Implements1 and then throw to ClassImplements
    }
    @Override
    public void onCallStop(){
        System.out.println("Implements1 => onCallStop()");
        mListener.onCallStop();//call at Implements1 and then throw to ClassImplements
    }
    public void run(){
        this.mImplements2.run();
    }
}

//3 level implement test
class Implements2{
    private Listener mListener;
    public Implements2(){
        System.out.println("Init Implements2 =>...");
    }
    public static interface Listener {
        void onCallStart();
        void onCallStop();
    }
    public void setListener(Listener listener) {
        mListener = listener;
    }
    public void onCallStart(){
        System.out.println("Implements2 => onCallStart()");
    }
    public void onCallStop(){
        System.out.println("Implements2 => onCallStop()");
    }
    public void run() {
        System.out.println("Run some functions and then callback from Listener...");
        mListener.onCallStart();
        mListener.onCallStop();
    }

}

輸出如下：

$javac Homeway.java
$java Homeway
=======================Implements======================
Init Implements2 =>...
Init Implements1 =>...
Run some functions and then callback from Listener...
Implements1 => onCallStart()
ClassImplements => onCallStart()
Implements1 => onCallStop()
ClassImplements => onCallStop()

我們先是聲明了類ClassImplements，這個是我們的主類，并且implements了Implements1.Listener通過一個Listener建立了監聽接口，

然后Implements1又implements了Implements2.Listener建立了第2級的監聽。

一旦Implements1或Implements2內的某個函數觸發了某個事件，就能通過監聽接口發送給主函數ClassImplements，類似js中的事件回調函數。

父類與子類通過Listener實現接口調用，此時Listener即為父類本身。

大致的模型如下：

implements容器與interface接口在java類中有很多很好用的模型，有時間該多去研究研究。

《Java Interfaces》

《Java interfaces and the concept of multiple inheritance》

《Java Interface Example, Explanation, and Implementation》