很久沒有看到如此精闢的文章了!作者寫得實在太好了!正在學JAVA或者想了解抽象類與介面的朋友,絕對不可錯過!本人極力推薦!

1. OOP中介面與抽象類的區別
2. Java語言介面與繼承的本質
3. 深入理解介面和抽象類
    

OOP中介面與抽象類的區別

OOP中的INTERFACE和ABSTRACT CLASS是兩個不同的概念

我們在使用的時候往往將兩個混在一起使用，不做什麼區別，大家可能在定義上對他們的區別有不少見解

這裡我不用什麼專業術語什麼的，一個字“煩”,我們就以最簡單的白話來討論.

其實這兩個東西在使用上是有很大區別的，我自己鬱悶了好半天才有所領悟

在我們對一個實體進行抽象的時候將他先分類處理，把他的屬性跟主要方法劃分為一個類，我們這時候就用到了ABSTRACT CLASS，而INTERFACE則是用來增加功能的直接對外的。

一般應用裡邊，介面是直接對外的，抽象類其次，最後才是具體實現方法的類。

我們用一個簡單的例子說明：

我們現在要分析“計算機”這個實體

首先計算機部件有(主機,顯示器)我們,然後分析部件的行為,主機可以(開機,關機),顯示器也可以(開啟,關閉),這些都是計算機的基本功能,也是必須的

abstract Class jisuanji{

String zhuji,xianshiqi;

abstract zj_on();

abstract zj_off();

abstract xsq_on();

abstract xsq_off();

}

以上就是電腦這個實體的基本組成,但是我們的電腦不光有這些裝置,我們還需要鍵盤,滑鼠什麼的,這些都是必須的,否則電腦這個東西將不能完成他的基本任務我們可以用繼承來實現他

abstract class PC extends jisuanji{

String shubiao,jianpan;

abstract sb_click();

abstract sb_dblclack();

}

我們將計算機的完整部件基本上做好了,但是我們PC是一個多功能裝置,不是每個人都用他來做基本的計算工作的,我們可以用他來看電影,聽音樂什麼的,這個時候我們就需要對他的功能進行擴充,這些裝置不一定是電腦上需要的,這裡就用到interface

我們的電腦現在只需要基本的功能和播放音樂的功能,我們用介面去實現他

interface music{

public void play();

}

這裡我們播放音樂的功能也就生成了

將這些功能整合在一起

class Computer extends PC implements music{

<具體實現>

}

這裡我們就將一個有音樂功能的電腦做成了，我們可能還需要其他功能，在這個時候我們就可以充分利用介面的優點來做到這些功能的隨意增加。

說完了具體的例子，我們回過頭來看介面跟抽象類在使用上的區別，抽象類在使用的時候是將主要功能封裝起來，在主要部件上的增添（比如電腦的更新換代上）通過抽象類來實現，而介面則偏向於對附加功能的增刪管理上。

這時候有人會問，為什麼要那麼複雜的去定義一個抽象類又去定義一個介面呢？將這些功能集中起來寫在一個類裡邊多方便，有好理解。這種想法在解決小問題的時候顯得得心應手，又好理解，又好寫。

但是我們在解決複雜問題的時候採用這種方法就會暴露出很多的弊端：

我們在解決一個複雜問題的時候就需要先將他簡單的分類，然後針對分類在進行細化，先考慮問題的解決順序什麼的，最後對問題的每個模組都有了掌握之後，我們再對其進行過程的編寫。這樣我們在面對一個複雜的問題時就會顯得得心應手，而那種寫在一起的方法則不能將問題考慮周全，即使勉強考慮周全了，估計程式碼也就沒幾個人能看懂了，使用起來也顯得很煩瑣，找不到個頭緒。

事物不是一成不變的，他是在不斷的發展，可能有很多變化，我們經常需要對一個已存在的程式進行功能的擴充和刪除，使用這裡我們分析的方法可以很有條理的去解決這個問題（將主要功能的增加用類的繼承來實現，而將輔助功能的新增用介面去管理和分類，這樣條理分明），在解決複雜問題和做很多修改的時候不必去大量更改程式碼。

OOP這種思想幫助我們解決了很多複雜的問題，這裡不在一一列舉，只說我們這裡的重點。

 Java語言介面與繼承的本質

大多數人認為，介面的意義在於頂替多重繼承。眾所周知Java沒有c++那樣多重繼承的機制，但是卻能夠實作多個介面。其實這樣做是很牽強的，介面和繼承是完全不同的東西，介面沒有能力代替多重繼承，也沒有這個義務。介面的作用，一言以蔽之，就是標誌類的類別（type of class）。把不同型別的類歸於不同的介面，可以更好的管理他們。OO的精髓，我以為，是對物件的抽象，最能體現這一點的就是介面。為什麼我們討論設計模式都只針對具備了抽象能力的語言（比如c++、java、c#等），就是因為設計模式所研究的，實際上就是如何合理的去抽象。（cowboy的名言是“抽象就是抽去像的部分”，看似調侃，實乃至理）。
　　設計模式中最基礎的是工廠模式（Factory），在我最近的一個很簡單的應用中，我想盡量的讓我的程式能夠在多個數據庫間移植，當然，這涉及很多問題，單是如何相容不同DBMS的SQL就讓人頭痛。我們不妨先把問題簡單化，只考慮如何連線不同的資料庫。

　　假設我有很多個類，分別是Mysql.java、SQLServer.java、Oracle.java、DB2.java，他們分別連線不同的資料庫，統一返回一個Connection物件，並且都有一個close方法，用於關閉連線。只需要針對你的DBMS，選擇不同的類，就可以用了，但是我的使用者他會使用什麼資料庫？我不知道，我希望的是儘量少的修改程式碼，就能滿足他的需要。我可以抽象如下介面：

　　package org.bromon.test;
　　public interface DB
　　{
　　java.sql.Connection openDB(String url,String user,String password);
　　void close();
　　}

　　這個介面只定義兩個方法，沒有任何有實際意義的程式碼，具體的程式碼由實作這個介面的類來給出，比如Mysql.java：

　　Package org.bromon.test;
　　import java.sql.*;
　　public class Mysql implements DB
　　{
　　private String url=”jdbc:mysql:localhost:3306/test”;
　　private String user=”root”;
　　private String password=””;
　　private Connection conn;
　　public Connection openDB(url,user,password)
　　{
　　　　//連線資料庫的程式碼
　　}

　　public void close()
　　{
　　　　//關閉資料庫
　　}
　　}

　　類似的當然還有Oracle.java等等，介面DB給這些類歸了個類，在應用程式中我們這樣定義物件：

　　org.bromon.test.DB myDB;
使用myDB來操作資料庫，就可以不用管實際上我所使用的是哪個類，這就是所謂的“開-閉”原則。但是問題在於介面是不能例項化的，myDB=new DB()，這樣的程式碼是絕對錯誤的，我們只能myDB=new Mysql()或者myDB=new Oracle()。麻煩了，我還是需要指定具體例項化的是哪個類，用了介面跟沒用一樣。所以我們需要一個工廠：
　　package org.bromon.test;
　　public class DBFactory
　　{
　　public static DB Connection getConn()
　　{
　　　　Return(new Mysql());
　　}
　　}

　　所以例項化的程式碼變成：myDB=DBFactory.getConn()；

　　這就是23種模式中最基礎的普通工廠(Factory)，工廠類負責具體例項化哪個類，而其他的程式邏輯都是針對DB這個介面進行操作，這就是“針對介面程式設計”。責任都被推卸給工廠類了，當然你也可以繼續定義工廠介面，繼續把責任上拋，這就演變成抽象工廠(Abstract Factory)。

　　整個過程中介面不負責任何具體操作，其他的程式要連線資料庫的話，只需要構造一個DB物件就OK，而不管工廠類如何變化。這就是介面的意義----抽象。

　　繼承的概念不用多說，很好理解。為什麼要繼承呢？因為你想重用程式碼？這絕對不是理由，繼承的意義也在於抽象，而不是程式碼重用。如果物件A有一個run()方法，物件B也想有這個方法，所以有人就Class B extends A。這是不經大腦的做法。如果在B中例項化一個A，呼叫A的Run()方法，是不是可以達到同樣的目的？如下：

　　Class B
　　{
　　A a=new A();
　　a.run();
　　}

　　這就是利用類的聚合來重用程式碼，是委派模式的雛形，是GoF一貫倡導的做法。

　　那麼繼承的意義何在？其實這是歷史原因造成的，最開始的OO語言只有繼承，沒有介面，所以只能以繼承來實現抽象，請一定注意，繼承的本意在於抽象，而非程式碼重用（雖然繼承也有這個作用），這是很多Java爛書最嚴重的錯誤之一，它們所造成的陰影，我至今還沒有完全擺脫，壞書害人啊，尤其是入門類的，流毒太大。什麼時候應該使用繼承？只在抽象類中使用，其他情況下儘量不使用。抽象類也是不能例項化的，它僅僅提供一個模版而已，這就很能說明問題。

　　軟體開發的萬惡之源，一是重複程式碼而不是重用程式碼，二是爛用繼承，尤以c++程式設計師為甚。Java中取締多重繼承，目的就是制止爛用繼承，實是非常明智的做法，不過很多人都不理解。Java能夠更好的體現設計，這是讓我入迷的原因之一。

深入理解介面和抽象類

abstract class和interface是Java語言中對於抽象類定義進行支援的兩種機制，正是由於這兩種機制的存在，才賦予了Java強大的面向物件能力。abstract class和interface之間在對於抽象類定義的支援方面具有很大的相似性，甚至可以相互替換，因此很多開發者在進行抽象類定義時對於abstract class和interface的選擇顯得比較隨意。其實，兩者之間還是有很大的區別的，對於它們的選擇甚至反映出對於問題領域本質的理解、對於設計意圖的理解是否正確、合理。本文將對它們之間的區別進行一番剖析，試圖給開發者提供一個在二者之間進行選擇的依據。

理解抽象類

abstract class和interface在Java語言中都是用來進行抽象類（本文中的抽象類並非從abstract class翻譯而來，它表示的是一個抽象體，而abstract class為Java語言中用於定義抽象類的一種方法，請讀者注意區分）定義的，那麼什麼是抽象類，使用抽象類能為我們帶來什麼好處呢？

在面向物件的概念中，我們知道所有的物件都是通過類來描繪的，但是反過來卻不是這樣。並不是所有的類都是用來描繪物件的，如果一個類中沒有包含足夠的資訊來描繪一個具體的物件，這樣的類就是抽象類。抽象類往往用來表徵我們在對問題領域進行分析、設計中得出的抽象概念，是對一系列看上去不同，但是本質上相同的具體概念的抽象。比如：如果我們進行一個圖形編輯軟體的開發，就會發現問題領域存在著圓、三角形這樣一些具體概念，它們是不同的，但是它們又都屬於形狀這樣一個概念，形狀這個概念在問題領域是不存在的，它就是一個抽象概念。正是因為抽象的概念在問題領域沒有對應的具體概念，所以用以表徵抽象概念的抽象類是不能夠例項化的。

在面向物件領域，抽象類主要用來進行型別隱藏。我們可以構造出一個固定的一組行為的抽象描述，但是這組行為卻能夠有任意個可能的具體實現方式。這個抽象描述就是抽象類，而這一組任意個可能的具體實現則表現為所有可能的派生類。模組可以操作一個抽象體。由於模組依賴於一個固定的抽象體，因此它可以是不允許修改的；同時，通過從這個抽象體派生，也可擴充套件此模組的行為功能。熟悉OCP的讀者一定知道，為了能夠實現面向物件設計的一個最核心的原則OCP(Open-Closed Principle)，抽象類是其中的關鍵所在。

從語法定義層面看abstract class和interface

在語法層面，Java語言對於abstract class和interface給出了不同的定義方式，下面以定義一個名為Demo的抽象類為例來說明這種不同。

使用abstract class的方式定義Demo抽象類的方式如下：

abstract class Demo ｛
abstract void method1();
abstract void method2();
…
｝

使用interface的方式定義Demo抽象類的方式如下：

interface Demo {
void method1();
void method2();
…
}

在abstract class方式中，Demo可以有自己的資料成員，也可以有非abstarct的成員方法，而在interface方式的實現中，Demo只能夠有靜態的不能被修改的資料成員（也就是必須是static final的，不過在interface中一般不定義資料成員），所有的成員方法都是abstract的。從某種意義上說，interface是一種特殊形式的abstract class。

對於abstract class和interface在語法定義層面更多的細節問題，不是本文的重點，不再贅述，讀者可以參閱參考文獻〔1〕獲得更多的相關內容。

從程式設計層面看abstract class和interface

從程式設計的角度來看，abstract class和interface都可以用來實現"design by contract"的思想。但是在具體的使用上面還是有一些區別的。

首先，abstract class在Java語言中表示的是一種繼承關係，一個類只能使用一次繼承關係。但是，一個類卻可以實現多個interface。也許，這是Java語言的設計者在考慮Java對於多重繼承的支援方面的一種折中考慮吧。

其次，在abstract class的定義中，我們可以賦予方法的預設行為。但是在interface的定義中，方法卻不能擁有預設行為，為了繞過這個限制，必須使用委託，但是這會增加一些複雜性，有時會造成很大的麻煩。

在抽象類中不能定義預設行為還存在另一個比較嚴重的問題，那就是可能會造成維護上的麻煩。因為如果後來想修改類的介面（一般通過abstract class或者interface來表示）以適應新的情況（比如，新增新的方法或者給已用的方法中新增新的引數）時，就會非常的麻煩，可能要花費很多的時間（對於派生類很多的情況，尤為如此）。但是如果介面是通過abstract class來實現的，那麼可能就只需要修改定義在abstract class中的預設行為就可以了。

同樣，如果不能在抽象類中定義預設行為，就會導致同樣的方法實現出現在該抽象類的每一個派生類中，違反了"one rule，one place"原則，造成程式碼重複，同樣不利於以後的維護。因此，在abstract class和interface間進行選擇時要非常的小心。

從設計理念層面看abstract class和interface

上面主要從語法定義和程式設計的角度論述了abstract class和interface的區別，這些層面的區別是比較低層次的、非本質的。本小節將從另一個層面：abstract class和interface所反映出的設計理念，來分析一下二者的區別。作者認為，從這個層面進行分析才能理解二者概念的本質所在。

前面已經提到過，abstarct class在Java語言中體現了一種繼承關係，要想使得繼承關係合理，父類和派生類之間必須存在"is a"關係，即父類和派生類在概念本質上應該是相同的（參考文獻〔3〕中有關於"is a"關係的大篇幅深入的論述，有興趣的讀者可以參考）。對於interface 來說則不然，並不要求interface的實現者和interface定義在概念本質上是一致的，僅僅是實現了interface定義的契約而已。為了使論述便於理解，下面將通過一個簡單的例項進行說明。

考慮這樣一個例子，假設在我們的問題領域中有一個關於Door的抽象概念，該Door具有執行兩個動作open和close，此時我們可以通過abstract class或者interface來定義一個表示該抽象概念的型別，定義方式分別如下所示：

使用abstract class方式定義Door：

abstract class Door {
abstract void open();
abstract void close()；
}

使用interface方式定義Door：

interface Door {
void open();
void close();
}

其他具體的Door型別可以extends使用abstract class方式定義的Door或者implements使用interface方式定義的Door。看起來好像使用abstract class和interface沒有大的區別。

如果現在要求Door還要具有報警的功能。我們該如何設計針對該例子的類結構呢（在本例中，主要是為了展示abstract class和interface反映在設計理念上的區別，其他方面無關的問題都做了簡化或者忽略）？下面將羅列出可能的解決方案，並從設計理念層面對這些不同的方案進行分析。

解決方案一：

簡單的在Door的定義中增加一個alarm方法，如下：

abstract class Door {
abstract void open();
abstract void close()；
abstract void alarm();
}

或者

interface Door {
void open();
void close();
void alarm();
}

那麼具有報警功能的AlarmDoor的定義方式如下：

class AlarmDoor extends Door {
void open() { … }
void close() { … }
void alarm() { … }
}

或者

class AlarmDoor implements Door ｛
void open() { … }
void close() { … }
void alarm() { … }
｝

這種方法違反了面向物件設計中的一個核心原則ISP（Interface Segregation Priciple），在Door的定義中把Door概念本身固有的行為方法和另外一個概念"報警器"的行為方法混在了一起。這樣引起的一個問題是那些僅僅依賴於Door這個概念的模組會因為"報警器"這個概念的改變（比如：修改alarm方法的引數）而改變，反之依然。

解決方案二：

既然open、close和alarm屬於兩個不同的概念，根據ISP原則應該把它們分別定義在代表這兩個概念的抽象類中。定義方式有：這兩個概念都使用abstract class方式定義；兩個概念都使用interface方式定義；一個概念使用abstract class方式定義，另一個概念使用interface方式定義。

顯然，由於Java語言不支援多重繼承，所以兩個概念都使用abstract class方式定義是不可行的。後面兩種方式都是可行的，但是對於它們的選擇卻反映出對於問題領域中的概念本質的理解、對於設計意圖的反映是否正確、合理。我們一一來分析、說明。

如果兩個概念都使用interface方式來定義，那麼就反映出兩個問題：1、我們可能沒有理解清楚問題領域，AlarmDoor在概念本質上到底是Door還是報警器？2、如果我們對於問題領域的理解沒有問題，比如：我們通過對於問題領域的分析發現AlarmDoor在概念本質上和Door是一致的，那麼我們在實現時就沒有能夠正確的揭示我們的設計意圖，因為在這兩個概念的定義上（均使用interface方式定義）反映不出上述含義。

如果我們對於問題領域的理解是：AlarmDoor在概念本質上是Door，同時它有具有報警的功能。我們該如何來設計、實現來明確的反映出我們的意思呢？前面已經說過，abstract class在Java語言中表示一種繼承關係，而繼承關係在本質上是"is a"關係。所以對於Door這個概念，我們應該使用abstarct class方式來定義。另外，AlarmDoor又具有報警功能，說明它又能夠完成報警概念中定義的行為，所以報警概念可以通過interface方式定義。如下所示：

abstract class Door {
abstract void open();
abstract void close()；
}
interface Alarm {
void alarm();
}
class AlarmDoor extends Door implements Alarm {
void open() { … }
void close() { … }
void alarm() { … }
}

這種實現方式基本上能夠明確的反映出我們對於問題領域的理解，正確的揭示我們的設計意圖。其實abstract class表示的是"is a"關係，interface表示的是"like a"關係，大家在選擇時可以作為一個依據，當然這是建立在對問題領域的理解上的，比如：如果我們認為AlarmDoor在概念本質上是報警器，同時又具有Door的功能，那麼上述的定義方式就要反過來了。

結論

abstract class和interface是Java語言中的兩種定義抽象類的方式，它們之間有很大的相似性。但是對於它們的選擇卻又往往反映出對於問題領域中的概念本質的理解、對於設計意圖的反映是否正確、合理，因為它們表現了概念間的不同的關係（雖然都能夠實現需求的功能）。這其實也是語言的一種的慣用法，希望讀者朋友能夠細細體會