實用抽象類和接口的區別（接口與抽象類有何區別）

抽象類和接口又什么好處

從這個問題我們可以衍生出兩個問題：

1.?????為什么要用抽象類？

2.????? 為什么要使用接口？

企業單位在面試的時候經常會問到！

答案綜合考慮以下方面：

1：強調不但應該具有什么能力，而且應該具有什么特性，并且一些能力有共同的處理細節的時候，可以用抽象類；

2：只強調應該具有什么能力的時候，并且處理細節可能完全不同，就考慮用接口；

3：抽象類考慮從上到下的繼承和擁有，接口考慮從左到右的規范；

==============================================================

使用接口定義行為，由于接口是特殊的抽象類，也就可以使用抽象類定義行為，抽象類同時能夠實現行為；但僅是定義行為時，就可使用接口，因為接口能夠更有效地分離定義與實現，為代碼的維護和修改帶來方便。

==============================================================

1，??抽象類提供了一部分功能的實現，如果子類的功能實現和父類的功能實現是相同的，可以使用抽象

2，??接口只規定了類的函數規范，沒有具體實現。

==============================================================

面向對象的經典是面向抽象編程。

所以，用抽象的型別統一類型，來進行操作，有利于以后的擴展，移植，復用！！

==============================================================

其實抽象類的一個好處是類不能被實例化，最大的好處就是通過方法的覆蓋來實現多態的屬性。也就是運行期綁定

==============================================================

我想用比較通俗的方法告訴你：

假如有兩個程序員，兩個在兩個程序里都要用到一種功能，比如要取一個方法名。

甲自己做了一個方法叫getname，乙也作了一個方法叫qumingzi。如果兩個人要去看對方的程序，那么

這個方法要讀懂是不是要有一個過程？

如果在公司里，有個抽象類，里面有個抽象方法getName,公司規定，凡遇到這樣的問題就實現這個方法。

那么這兩個人要讀對方的代碼是不是就容易了？？

==============================================================

假如很多人要買水果吃，吃的動作只有一個，但是有的人要用現金買，有的人用信用卡，有的人賒帳。要為每個人定義一個類，就要定義多個相同的吃的方法。如果定義一個抽象類，在里面實現吃的方法，再做一個買的抽象方法。那每個人的類都從這個抽象類派生下來，只要實現買的方法即可，吃的方法就可以直接用父類的方法了。如果要改吃的方法就不用改多個，只要改這個抽象類里的就行了。

==============================================================

抽象類將事物的共性的東西提取出來，抽象成一個高層的類。子類由其繼承時，也擁有了這個超類的屬性和方法。---也就實現了代碼的復用了。

子類中也可加上自己所特有的屬性和方法。----也就實現了多態

==============================================================

以學生為列，博士和碩士都是學生，那么學生就成為了一個父類了，他們都具有學生的特征，那些共同的特點就可以繼承，實現代碼重用

但是如果還有一種類型的學生，它既具有博士，又具有碩士的特點，那我豈不是要繼承兩個類，但是這兩個類里又有很多相同的特征啊，那就現的代碼冗余了，是嗎？

那么我現在的目的就是要使它簡潔，但是要達到那個效果，我就會用到接口，所謂的接口有兩個含義

1。方法的集合

2。概念

第二中就是我們JAVA中用的，它把類中某些獨有的方法用接口的形式表現出來，然后你就直接implement接口就是拉，再繼承學生那個類，就可以拉

==============================================================

接口的好處之一：

就是可以多重繼承，?而類不可以~

子類，可以同是繼承至一個接口和一個抽象基類

==============================================================

例子：

有以下類：

類（動物）　類（狗）　類（大象）

類（狗）和類（大象）是類(動物)的子類。

如果我希望別人只能創建類（狗）和類（大象）的對象，絕不希望別人能直接創建類(動物)的對象（直接創建類（動物）是無意義的，因為每一種動物都有它的真正類），于是我就可以把類（動物）做成抽象類

==============================================================

就象建立房子的框架

里面的房間可以分別設計，但是框架不變

==============================================================

面向對象的經典是面向抽象編程

抽象的意思，就是你不必為每個插銷定義一個插座。

你不用為每個CPU定義一個主板

抽象類和接口的意思，就是規范，大家都遵守。這樣符合規范的東西，大家都不用了解各自的細節。插座不會了解插銷怎么做的。插銷也不必了解插座怎么做的。

抽象類和接口的意思，就是規范，大家都遵守。這樣符合規范的東西，大家都不用了解各自的細節。插座不會了解插銷怎么做的。插銷也不必了解插座怎么做的。

==============================================================

JAVA是基于C/C++開發出來的，也可以稱作是二者綜合體的簡化版，去處其中的一些過于復雜的控制功能或改由計算機自動處理。其中就包括去除了C++中的多重繼承功能，而改由不計數量的接口來實現。

舉個簡單的例子:古希臘神話中的飛馬。它既能奔跑（馬的方法），又可以飛（鳥的方法）。在C++中可以通過多重繼承來實現，但在JAVA中則必須通過接口來實現。或者繼承馬的方法，并實現一個鳥飛的接口。或者同時實現一個跑的接口和飛的接口。

接口具有良好可擴展性。有了跑和飛的兩個借口，你可以輕松的做出飛豬，飛驢等具有類似功能的對象。

接口中不得實現任何方法。一個類一旦要實現一個接口，則必須實現改接口的所有方法，即使在該方法中不執行任何操作（即方法體內為空）。

接口與抽象類具有類似的功能。在使用上，一般接口用于定義比較普遍的方法，而抽象類主要用于比較具體的方法。

面向對象的本質:萬物皆對象！

封裝：封裝就是指利用抽象數據類型將數據和基于數據的操作封裝在一起，數據被保護在抽象類型的內部，系統的其他部分只有通過包裹在數據外面的被授權的操作，才能夠與這個抽象數據類型交流與交互！

繼承：繼承實際上是存在于面向對象程序中的兩個類之間的關系。當一個類擁有另一個類的所有數據和操作時，就稱這兩個類之間具有繼承關系！

多態：多態是指一個程序中同名的不同方法共存的情況。面向對象的程序中多態的情況有多種，可以通過子類對父類方法的覆蓋實現多態，也可以利用重載在同一個類中定義多個同名的不同方法！

OO=Objects+Classes+Inheritance ? + ? Communication ? With? messages

那還是教科書上說的，

多態,解釋就是一個方法被多次構造,,經常出現在,繼承關系類(抽象類，接口)

回憶一下接口使用

interface ? I_Test{

public ? void ? Print ? (){}

}

class ? C_A ? implment ? I_Test{

public ? void ? Print(){ ?System.out.println("C_A")}

}

class ? C_B ? implment ? I_Test{

public ? void ?Print(){System.out.println("C_B")}

}

再來看看class? Test{

public ? void ? main(){

I_Test ? i= ? new ? C_A();

i.Print(); ? //打印出C_A

i= ? new ? C_B();

i.Print();//打印出C_B

}

//，"多態性是站在類的角度完成了接口與實現的分離",多態調用Print()方法，不知道能不能解釋這句話，個人是這樣一來理解的。

我個人認為“多態”不單是對父子類，接口，抽象類的理解。。關鍵還是要對? protect,private正確使用中去體味。

這樣才能更好隔離，綜合使用多態才會清晰。

接口（Interface）是用來定義行為的！

抽象類（Abstract? Class）是用來實現行為的！

具體類（）是用來執行行為的！

支持多重繼承，? 支持抽象函數，? 允許實現? ? ，允許創建實體，允許部分實現

interface ? ? ? ? ? 支持 ? ? ? ? ?? ? ? ? ? ? ? 支持? ? ? ? ? ? ? ? ? 不允許 ? ? ? ? ?? ? 不允許? ? ? ? ? ? ? ? ? 不允許

abstract ? class不支持? ? ? ? ? ? ? ? ? ? ? 支持 ? ? ? ? ?? ? ? ? 允許? ? ? ? ? ? ? ? 不允許 ? ? ? ? ?? ? ? ? ? 允許

class ? ? ? ? ? ? ? ? ? 不支持 ? ? ? ? ?? ? ? 不支持? ? ? ? ? ? ? ? ? ? 允許 ? ? ? ? ? ?? ? ? 允許? ? ? ? ? ? ? ? ? ? 不允許

所以打算多繼承，又并不想馬上實現它的時候，就用接口。需要實現它的類需要。比如我上述例子中的Print()，，通常對應多個實現類的。（記得所有的方法都必須是public的，也可以用有static ? final）

如果只需要實現部分的部分方法，又不需要全部實現，那就可以用抽象類。對于抽象方法，需要overrider? 就是要重寫一個方法來實現? 所定義好的abstract? 方法。（這個和接口一樣）

如果全部實現，又全部要執行的。。那么就用直接類吧，父子關系一帶被調用它的時候，比如子類繼承了父類的方法時候，一調用就執行了。

其實，要從宏觀上講，那就牽涉到軟件工程理論了。

個人看法：

事物的出現，總是有它出現的理由（需求）！

但是，事物的生存，需要有適應性（靈活）！

比如：長頸鹿，脖子長，這是個抽象的概念；

能吃草（是非肉食性動物的特征，接口）。

所以，當需要描述長頸鹿的時候，我們就可以用接口（非肉食性動物）和抽象（脖子長）的方法來定義它，

然后，具體是什么種類/或者顏色的長頸鹿，怎么個吃草法，這就是具體類了。

=============================================================

經典解釋是：使用了對象就叫基于對象，基于對象的基礎上增加了繼承從而變成了面向對象。

基于對象的最大特點就是封裝，至于private,protected,public，并不是基于對象語言的必須要求。同時應該注意到的是，封裝對于應用本身并沒有提供太大的幫助；換句話說封裝僅僅改變了方法的表達形式，除了析構函數能夠提供一些資源安全上的保證，當然java沒有析構函數。比如某些網絡應用，包裝了socket，然而必須的accept,listen,connect,read,write還是需要你自己去調用，只不過調用方式有所變化而已；更麻煩的是處理錯誤，可能的錯誤你必須完全接管，那就需要對問題本身有很深入的了解。基于對象讓你不容易犯錯誤，但是不能改變對問題本身的理解。

于是出現了面向對象。繼承，多態只是它的特點而已，一種表象。而關鍵優越性在于它可以改變對問題的認識。比如處處可見的畫圖的例子，p.Draw()，就能畫出一個形狀，都是Draw()方法，但是可以根據p的不同，動態選擇。無可否認，這個是多態性的優越性的例子。然而繼承又如何呢，可以這樣說，如果不使用多態，繼承就沒有意義了。因為沒有多態，繼承事實上導致了較高層次的包裝而已，與基于對象相同，它不能改變對問題本身的理解。很多時候繼承被包裹所代替，COM的對象重用，就是典型的包裹，不過它叫聚集而已。類層次越深管理越困難。

面向對象提供了極大的靈活性，然而作為一個概念，外延太豐富，反而不容易把握。看看JFC的文檔，實在太靈活了，感覺上這樣那樣幾個東西拼合起來，窗口就可以做成了。事實卻不是如此，你必須去了解layer，了解listener，了解很多東西，然后按照固定的規則進行拼裝才能達到效果。簡單說，看看javadoc的JFC文檔，很難學會如何去實現一個可用的窗口應用。這一點明顯比不上VB，其實這就和使用面向對象方法是為了接口易用性這一個基本原則背離了。外延被擴大化到難以接受的規模，這是使用面向對象方法很容易犯的毛病。而設計模式提供了一些方法緩和這些矛盾，比如用靜態函數創建對象，私有構造，使得對象不能被任意創建，這就大大壓縮了這些對象的外延。簡單看看MessageDigest，可能在內部有md2,md4,md5,sha1的類供我創建對象，但是這些我都不讓你看到，你只要知道一個MessageDigest就足夠了，免得產生誤會。

先說那么多了。

回復人：? Leemaasn(我給大家拜早年啦！新春快樂！！！)? ( ? ) ? 信譽：101? ? 2004-1-12 ? 18:47:34 ?? 得分:0

zengpan_panpan()

牛，，，很徹底地分析了“何謂對象”！！！

回復人：? Leemaasn(我給大家拜早年啦！新春快樂！！！)? ( ? ) ? 信譽：101? ? 2004-1-12 ? 20:40:23 ?? 得分:0

對于? zengpan_panpan()所說的“而關鍵優越性在于它可以改變對問題的認識。”！

個人看法如下：

通常,我們要使用一個對象的paint方法時,如果我們很具體的考慮這個Paint問題時,我們也許會從想要畫什么開始。然后，考慮從該畫什么東西，又考慮對于這個東西我們應該怎么畫。。。。

一層層深入時，，，就會陷入到Windows底層API函數（我以Windows平臺為例。），樓主是搞Delphi的。這點應該會明白。。。

如果只是簡單幾個類，那也無所謂，當大規模生產時，還是這么做，后果可想而知的（比如：Windows的MFC、或者VCL）。

如果我們以對象和接口的角度來考慮這個Paint問題。

那么，我們可以先定義好一些接口，比如paint這個接口。

然后再來設計對象，如果某個對象，需要paint這個方法，那么，我們可以讓它實現paint這個接口。

具體怎么實現，這就是抽象類或者具體類的事情了。

然后，我們在其他地方調用這個對象的paint方法時，

我們就只需要按照這個paint這個接口的規定來調用就行了。

在這里，“改變對問題的認識”改變在什么地方呢？我們從對象的認識從一個具體到抽象、封裝的方向變了。

就像人，又分為黃色人種、白色人種、黑色人種（抽象類）等。。。

中國人、印度人。。。（接口）等。。。

如果再抽象，可以看作：脊椎動物。。。。

哈，扯遠了。。。

其實，真正的解答，應該請zengpan_panpan()來說明！！！

有請我們真正的主角。。。zengpan_panpan()隆重登場。。

回復人：? iamwls(-----魔高一尺，道高一丈-----)? ( ? ) ? 信譽：96? ? 2004-1-12 ? 20:43:27 ?? 得分:0

to: ? zengpan_panpan()

你所說的：使用了對象就叫基于對象，基于對象的基礎上增加了繼承從而變成了面向對象。

好象并不太準確

記得（好象是，呵呵）有人問JAVA的創始人：如果你想重來一次JAVA，你改變的是什么？

答：去掉繼承

也許應該是增加了抽象多態，? 從而變成了面向對象可能更準確點

回復人：? Leemaasn(我給大家拜早年啦！新春快樂！！！)? ( ? ) ? 信譽：101? ? 2004-1-12 ? 21:06:27 ?? 得分:0

哈,好象這句話,我也有看過。。。

記得（好象是，呵呵）有人問JAVA的創始人：如果你想重來一次JAVA，你改變的是什么？

答：去掉繼承

但沒有繼承，總覺得。。。似乎世界不太完美。。。。

回復人：? zengpan_panpan() ? ( ? ) ? 信譽：100? ? 2004-1-12 ? 21:45:13 ?? 得分:0

基于對象和面向對象的定義也不是我說的，以前是這么定義的。

至于JAVA要去掉繼承，從方法角度講是可行，不過至少還得保留接口，否則多態無從談起。不過這需要推翻整個jdk，肯定就不現實了。另外，看看Object類的實現可以發現，里面的notify, ? wait系列方法，有多少時候用到了，要知道任何一個對象都有這樣的方法，而這兩個方法明顯是線程相關的；然而線程類僅僅是它的一個子孫而已。這會讓人覺得別扭。其實這個問題的關鍵在于java不僅僅是一門語言，還是一個運行環境(jvm)，它們是緊緊捆綁在一起的，Object如此定義是一個妥協的結果。

呵呵，扯遠了，回到面向對象問題上來：

其實，面向對象也好，面向過程也好，現在喊得火熱的GP也好，爭來爭去，沒有太大意義。不管什么應用，都是面向需求的，這樣那樣的方法都是手段而已，目的才是最重要的。理論說多了乏味得很。

關于面向對象方法，有一個比較經典的例子。我回了最后一篇，不過后來沉下去了。

http://expert.csdn.net/Expert/topic/2625/2625842.xml?temp=.9095117

歡迎提出不同意見。

另外，我來出個題目：

需求很簡單：設計個線程池。

于是現在假設出兩種方案，互相對比一下。從需求入手：

1. ? 方案一：假設有一線程池對象? tpool;

Thread ? t ? = ? tpool.get();

t.start(myrunner);

tpool.put(t);

2. ? 方案二：假設有一線程池類? TPool;

TPool.start(myrunner);

你覺得哪個好，好在哪里，哪個不好，不好又在哪里？

zengpan_panpan() ? ( ? )? ? 太精彩了，你的解釋，我也隨便拜讀你的連接文章。：）? 果然精彩，請您繼續為我們講解啊。

我覺得是第二種好。

雖然兩個都是基于對象的。

但是，線程中，反復的創建銷毀對象是非常耗資源的。

我具體也不怎么會解釋，這些池化類方法是比較好的，，

讓我想到了數據庫的連接池。。。。

請您給我們答案吧。。。期待中。

燈光，，掌聲。。。。大家把手機關了：）

回復人：? zengpan_panpan() ? ( ? ) ? 信譽：100? ? 2004-1-15 ? 14:56:07 ?? 得分:0

其實第一種方法不好。

雖然符合一般池子的概念，比如，向池子申請資源，歸還資源。

但是就因為這樣將造成線程使用者和線程池之間的強耦合。

比如向線程池請求一個線程，就不得不考慮，它還有沒有線程可以提供給我用？如果沒有到底是返回錯誤，還是還是把我掛起？另外線程運行了我的runner，我什么時候知道知道它結束，如果它還沒有結束，我又怎么能把線程歸還給池子。考慮這些問題自然就很麻煩了，不但設計應用麻煩，設計線程池也麻煩。

而第二種就很簡單了。

把我的runner直接提供給池子，如果它暫時沒有線程可用，那么排隊就是了。如果不允許排隊可以考慮增加一個addTask，提供個參數說明我不排隊，要是沒有直接報錯。更多的通過這個參數甚至可以控制線程優先級一系列的問題，而不需要對池子有多大改動。

線程池本身，涉及到很多方面的問題，比如操作系統調度之類的問題，里面也會包含一些對象化的思考，這些思考并不在于用什么具體語言去實現。現在給出第二種的最簡單實現，可以去分析一下里面到底有多少對象化概念，有什么模式，也可能像這種模式，不過似是而非，但是這些都不重要，并不見得一定要符合什么模式才是對的。前面已經說過，不管面向什么，不管什么方法，最終都是面向需求的。最后應該把你的程序看成一塊膠泥，想捏成圓的就圓的，想捏成方的就方的。

// ? TPool.java

import ? java.lang.*;

import ? java.util.*;

import ? java.io.*;

class ? MyRunner ? implements ? Runnable

{

String ?name;

public ? MyRunner(String? x)

{

name ? = ? x;

}

public ?void ? run()

{

System.out.println("My ?name ? is ? " ? + ? name);

try ? { ? Thread.sleep(50);? } ? catch ? (Exception ? e) ? {}

}

}

public ? class ? TPool ? implements ? Runnable

{

private ?int ? id;

private ?static ? LinkedList ? pool ? = ? new ? LinkedList();

private ?TPool ? (int ? i) ? { ? id ? = ? i; ? }

public ?void ? run()

{

for ? (;;)

{

Runnable ? r;

synchronized(pool)

{

System.out.println("[Thread ? " ? + ? id ? +? "] ? Enter ? Sleep");

while ? (pool.size() ? == ? 0)

{

try

{

pool.wait();

} ?catch(InterruptedException ? e)

{

}

}

r? = ? (Runnable)pool.getFirst();

pool.removeFirst();

System.out.println("[Thread ? " ? + ? id ? +? "] ? Exec ? Runner");

}

r.run();

}

}

static ?void ? addTask(Runnable ? r)

{

synchronized(pool)

{

pool.add(r);

pool.notifyAll();

}

}

static ?void ? init ? (int ? size)

{

for ? (int ? i ? =? 0; ? i ? < ? size; ? i++)

(new ? Thread(new ? TPool(i))).start();

}

static ?void ? main(String ? args[])

{

TPool.addTask(new ?MyRunner("A"));

TPool.addTask(new ?MyRunner("B"));

TPool.addTask(new ?MyRunner("C"));

TPool.init(3);

for(;;)

try

{

Thread.sleep(1000);

int? n ? = ? (int)(Math.random() ? * ? 5);

System.out.println("\nGenerate ? " ? + ? n ? +? " ? Tasks\n");

for ? (int ? i ? = ? 0; ? i ? < ? n;? i++)

TPool.addTask(new? MyRunner( ? (new ? Double(Math.random())).toString() ?));

} ? catch(Exception ? e)

{

}

}

}

接口（Interface）是用來定義行為的！

抽象類（Abstract? Class）是用來實現行為的！

具體類（）是用來執行行為的！

這個不錯

抽象類用來實現公用行為更好一點

其實除了interface外，還有adapter模式可以參照

對于接口、抽象類，我的理解是：從類圖出發，根據實際情況定義接口或抽象類，接口是定義行為的，任何一個類都可以看作有一個接口，如果需要可以定義接口，否則不需要定義，而抽象類是可以定義和實現行為，但不能執行行為，因為它不能實例化，但可以定義對象，這個對象的行為是抽象類的實現類的實例的行為。

從設計上說抽象類的好處有二：

一、抽象類提供了部分實現，使子類可以重用部分抽象類的代碼

二、抽象類為其子類提供了共同的接口（注意：這里說我接口與? java ? 中的? interface ? 是不同的）

也就是別人可以將各個子類的對象當成抽象類的對象使用。

我覺得“為了方便擴展”的說法是荒謬的，如果可以實現，為什么要代碼寫到別的類中去呢？

抽象類的關鍵是抽象方法，而設計抽象方法的原因是在于抽象類自己沒有辦法實現這個方法，

或者說在抽象類這一層，我們不知道如何實現這個方法，只有到了具體類才有辦法知道實現。

如“動物”這個抽象類，有一個抽象方法“吃”，但是動物這個類是不能實現“吃這個方法的，

只有到了“人”這個類，才能有“用手將東西放進嘴里然后吞下去”這樣的實現。

“動物”這個類的“吃”方法也不可能有默認的實現，因為現實中沒有一個純“動物”的實例，

它要么是“人”類的實例，要么是其它“動物”類子類的實例！

但我們一旦碰到一個“動物”對象，就可以調用“吃”這個方法，

當然我們也要預期不同對象的實現不是一樣的

interface表述“has ? a”關系，用于描述功能

是用來說明它的是實現類是“做什么？”的

至于“怎么作？”，interface并不進行約束

而abstract? class表述“is? a”關系，它在描述功能的同時

也通過具體實現部分功能的方式，來約束“怎么作？”

只有接受了這個約束，才應該去繼承它

從而可以將“其中被具體實現的部分功能”，在它的子類中得到重用

實際使用當中，interface與而abstract ? class各有優勢，

需要權衡。

不過，有時候，兩者也可以兼用

《effective? java》中提出，

可以聲明一個interface描述功能，

再提供一個該接口的骨架（skeleton）實現（實現該接口的abstract ? class）

固化對功能實現方式的約束，從而盡可能地實現重用

于是就有了另一個問題：

在使用當中，可能發現這個skeleton實現不能滿足現有需求

這時可以在原有的interface基礎上，派生出另一個skeleton實現

抽象類作為超類，可以將子類的公用邏輯用方法實現，而接口只是定義了實現類的規范（其實就是定義了實現類該做什么）

因此子類有公用的邏輯部分就在抽象類里實現該方法的細節，子類中有共性但實現細節不同則定義為抽象方法。抽象類只能被一個子類繼承，而接口可以被多個實現類實現，所以同意樓上的接口的多態性更好

接口：? 只定義方法名稱，沒有方法的具體實現。

抽象類：? 只定義方法名稱，沒有方法的具體實現。? ? (與 ? 接口 ? 相同)

定義方法名稱，并實現這些方法。 ? ?? ? ? ? ? ? (與? 類 ? ?? 相同)

以上兩者都有。(真正的抽象類大多是這種方式.? 可參看API源代碼)

類：定義的方法必須都有實現。

抽象類與接口在設計時各有什么好處？2007-04-13 13:37接口不能執行任何的方法，而抽象類可以。

類可以執行許多接口，但只有一個父類。 這個也有人說用接口可以實現多重繼承。

接口不是類分級結構的一部分。而沒有聯系的類可以執行相同的接口。

具體說說：

接口是對象屬性和方法的描述（但不包括他們具體實現），比如Int32類型實現了IConvertible接口，就說明Int32具有 IConvertible接口所描述的ToDouble()方法。但IConvertible并沒有給出實現ToDouble()的內容，需要由 Int32類型自己實現。

接口用于實現多態。比如Int32,Int64和Single類型都實現了IConvertible借口，那么就說明他們一定都具有ToDouble()方法。所以，定義一個變量是IConvertible類型：

IConvertible c;

然后，無論是給c賦任何實現IConvertible類型的變量，我都能夠保證，c至少有一個ToDouble()方法可用，而不用關心c具體是什么類型的變量。如

int i = 3; //Int32

long j = 6L; //Int64

float k = 4F; //Single

則

c = i;

c.ToDouble();

c = j;

c.ToDouble();

c = k;

c.ToDouble();

都不會發生錯誤。

實現接口的類可以顯式實現該接口的成員。當顯式實現某成員時，不能通過類實例訪問該成員，而只能通過該接口的實例訪問該成員。

接口的應用大多數是在DesignPattern時才用到。

抽象類，從多個對象中抽出來的“共性”，而他的后代，既有共性、又有特性。例如：“圖形”是抽象的，沒有形狀，由點線組成；正方形、圓形是他的派生，可以是對象。

Java 面向對象編程

版權聲明：本文內容由網絡用戶投稿，版權歸原作者所有，本站不擁有其著作權，亦不承擔相應法律責任。如果您發現本站中有涉嫌抄襲或描述失實的內容，請聯系我們jiasou666@gmail.com 處理，核實后本網站將在24小時內刪除侵權內容。