本系列文章將整理到我在GitHub上的《Java面試指南》倉庫，更多精彩內容請到我的倉庫裡檢視
> https://github.com/h2pl/Java-Tutorial

喜歡的話麻煩點下Star哈

文章首發於我的個人部落格：
> www.how2playlife.com

本文是微信公眾號【Java技術江湖】的《夯實Java基礎系列博文》其中一篇，本文部分內容來源於網路，為了把本文主題講得清晰透徹，也整合了很多我認為不錯的技術部落格內容，引用其中了一些比較好的部落格文章，如有侵權，請聯絡作者。

該系列博文會告訴你如何從入門到進階，一步步地學習Java基礎知識，並上手進行實戰，接著瞭解每個Java知識點背後的實現原理，更完整地瞭解整個Java技術體系，形成自己的知識框架。為了更好地總結和檢驗你的學習成果，本系列文章也會提供部分知識點對應的面試題以及參考答案。

如果對本系列文章有什麼建議，或者是有什麼疑問的話，也可以關注公眾號【Java技術江湖】聯絡作者，歡迎你參與本系列博文的創作和修訂。

## 抽象類介紹
什麼是抽象？

百度給出的解釋是：從具體事物抽出、概括出它們共同的方面、本質屬性與關係等，而將個別的、非本質的方面、屬性與關係捨棄，這種思維過程，稱為抽象。

這句話概括了抽象的概念，而在Java中，你可以只給出方法的定義不去實現方法的具體事物，由子類去根據具體需求來具體實現。

這種只給出方法定義而不具體實現的方法被稱為抽象方法，抽象方法是沒有方法體的，在程式碼的表達上就是沒有“{}”。

包含一個或多個抽象方法的類也必須被宣告為抽象類。

使用abstract修飾符來表示抽象方法以及抽象類。

//有抽象方法的類也必須被宣告為abstract
    public abstract class Test1 {
     
    	//抽象方法，不能有“{}”
    	public abstract void f();
    	
    }
抽象類除了包含抽象方法外，還可以包含具體的變數和具體的方法。類即使不包含抽象方法，也可以被宣告為抽象類，防止被例項化。

抽象類不能被例項化，也就是不能使用new關鍵字來得到一個抽象類的例項，抽象方法必須在子類中被實現。

//有抽象方法的類也必須被宣告為abstract
    public class Test1 {
     
    	public static void main(String[] args) {
    		Teacher teacher=new Teacher("教師");
    		teacher.work();
    		
    		Driver driver=new Driver("駕駛員");
    		driver.work();
    	}
    	
    }
    //一個抽象類
    abstract class People{
    	//抽象方法
    	public abstract void work();
    }
    class Teacher extends People{
    	private String work;
    	public Teacher(String work) {
    		this.work=work;
    	}
    	@Override
    	public void work() {
    		System.out.println("我的職業是"+this.work);
    	}
    	
    }
    class Driver extends People{
    	private String work;
    	public Driver(String work) {
    		this.work=work;
    	}
    	@Override
    	public void work() {
    		System.out.println("我的職業是"+this.work);
    	}
    	
    }
> 執行結果：
> 我的職業是教師
> 我的職業是駕駛員
> 幾點說明:

抽象類不能直接使用，需要子類去實現抽象類，然後使用其子類的例項。然而可以建立一個變數，其型別也是一個抽象類，並讓他指向具體子類的一個例項，也就是可以使用抽象類來充當形參，實際實現類為實參，也就是多型的應用。

People people=new Teacher("教師");
    people.work();
    
不能有抽象構造方法或抽象靜態方法。

如果非要使用new關鍵在來建立一個抽象類的例項的話，可以這樣：
   
    People people=new People() {
    	@Override
    	public void work() {
    	    //實現這個方法的具體功能
    	}
    		};
    		
個人不推薦這種方法，程式碼讀起來有點累。

在下列情況下，一個類將成為抽象類：

當一個類的一個或多個方法是抽象方法時。
    當類是一個抽象類的子類，並且不能實現父類的所有抽象方法時。
    當一個類實現一個介面，並且不能實現介面的所有抽象方法時。
    注意：
    上面說的是這些情況下一個類將稱為抽象類，沒有說抽象類就一定會是這些情況。
    抽象類可以不包含抽象方法，包含抽象方法的類就一定是抽象類。
    事實上，抽象類可以是一個完全正常實現的類。

## 為什麼要用抽象類
老是在想為什麼要引用抽象類，一般類不就夠用了嗎。一般類裡定義的方法，子類也可以覆蓋，沒必要定義成抽象的啊。

看了下面的文章，明白了一點。

其實不是說抽象類有什麼用，一般類確實也能滿足應用，但是現實中確實有些父類中的方法確實沒有必要寫，因為各個子類中的這個方法肯定會有不同，所以沒有必要再父類裡寫。當然你也可以把抽象類都寫成非抽象類，但是這樣沒有必要。

而寫成抽象類，這樣別人看到你的程式碼，或你看到別人的程式碼，你就會注意抽象方法，而知道這個方法是在子類中實現的，所以，有個提示作用。

下面看一個關於抽象類的小故事

<pre id="best-answer-content" name="code">問你個問題，你知道什麼是“東西”嗎？什麼是“物體”嗎？ 
“麻煩你，小王。幫我把那個東西拿過來好嗎” 
在生活中，你肯定用過這個詞－－東西。 
小王：“你要讓我幫你拿那個水杯嗎？” 
你要的是水杯類的物件。而東西是水杯的父類。通常東西類沒有例項物件，但我們有時需要東西的引用指向它的子類例項。

你看你的房間亂成什麼樣子了，以後不要把東西亂放了，知道麼？ 
又是東西，它是一個陣列。而陣列中的元素都是其子類的例項。 
--------- 
上面講的只是子類和父類。而沒有說明抽象類的作用。抽象類是據有一個或多個抽象方法的類，必須宣告為抽象類。抽象類的特點是，不能建立例項。

這些該死的抽象類，也不知道它有什麼屁用。我非要把它改一改不可。把抽象類中的抽象方法都改為空實現。也就是給抽象方法加上一個方法體，不過這個方法體是空的。這回抽象類就沒有抽象方法了。它就可以不在抽象了。

當你這麼嘗試之後，你發現，原來的程式碼沒有任何變化。大家都還是和原來一樣，工作的很好。你這回可能更加相信，抽象類根本就沒有什麼用。但總是不死心，它應該有點用吧，不然創造Java的這夥傳說中的天才不成了傻子了嗎？

接下來，我們來寫一個小遊戲。俄羅斯方塊！我們來分析一下它需要什麼類？
我知道它要在一個矩形的房子裡完成。這個房子的上面出現一個方塊，慢慢的下落，當它接觸到地面或是其它方塊的屍體時，它就停止下落了。然後房子的上面又會出現一個新的方塊，與前一個方塊一樣，也會慢慢的下落。在它還沒有死亡之前，我可以儘量的移動和翻轉它。這樣可以使它起到落地時起到一定的作用，如果好的話，還可以減下少幾行呢。這看起來好象人生一樣，它在為後來人努力著。
當然，我們不是真的要寫一個遊戲。所以我們簡化它。我抽象出兩個必須的類，一個是那個房間，或者就它地圖也行。另一個是方塊。我發現方塊有很多種，數一下，共6種。它們都是四個小矩形構成的。但是它們還有很多不同，例如：它們的翻轉方法不同。先把這個問題放到一邊去，我們回到房子這個類中。

房子上面總是有方塊落下來，房子應該有個屬性是方塊。當一個方塊死掉後，再建立一個方塊，讓它出現在房子的上面。當玩家要翻轉方法時，它翻轉的到底是哪個方塊呢？當然，房子中只有一個方塊可以被翻轉，就是當前方塊。它是房子的一個屬性。那這個屬性到底是什麼型別的呢？方塊有很多不同啊，一共有6種之多，我需要寫六個類。一個屬性不可能有六種型別吧。當然一個屬性只能有一種型別。

我們寫一個方塊類，用它來派生出6個子類。而房子類的當前方塊屬性的型別是方塊型別。它可以指向任何子類。但是，當我呼叫當前方塊的翻轉方法時，它的子類都有嗎？如果你把翻轉方法寫到方塊類中，它的子類自然也就有了。可以這六種子類的翻轉方法是不同的。我們知道'田'方塊，它只有一種狀態，無論你怎麼翻轉它。而長條的方塊有兩種狀態。一種是‘－’，另一種是‘｜’。這可怎麼辦呢？我們知道Java的多型性，你可以讓子類來重寫父類的方法。也就是說，在父類中定義這個方法，子類在重寫這個方法。

那麼在父類的這個翻轉方法中，我寫一些什麼程式碼呢？讓它有幾種狀態呢？因為我們不可能例項化一個方塊類的例項，所以它的翻轉方法中的程式碼並不重要。而子類必須去重寫它。那麼你可以在父類的翻轉方法中不寫任何程式碼，也就是空方法。

我們發現，方法類不可能有例項，它的翻轉方法的內容可以是任何的程式碼。而子類必須重寫父類的翻轉方法。這時，你可以把方塊類寫成抽象類，而它的抽象方法就是翻轉方法。當然，你也可以把方塊類寫為非抽象的，也可以在方塊類的翻轉方法中寫上幾千行的程式碼。但這樣好嗎？難道你是微軟派來的，非要說Java中的很多東西都是沒有用的嗎？

當我看到方塊類是抽象的，我會很關心它的抽象方法。我知道它的子類一定會重寫它，而且，我會去找到抽象類的引用。它一定會有多型性的體現。

但是，如果你沒有這樣做，我會認為可能會在某個地方，你會例項化一個方塊類的例項，但我找了所有的地方都沒有找到。最後我會大罵你一句，你是來欺騙我的嗎，你這個白痴。

把那些和“東西”差不多的類寫成抽象的。而水杯一樣的類就可以不是抽象的了。當然水杯也有幾千塊錢一個的和幾塊錢一個的。水杯也有子類，例如，我用的水杯都很高檔，大多都是一次性的紙水杯。

記住一點，物件導向不是來自於Java，物件導向就在你的生活中。而Java的物件導向是方便你解決複雜的問題。這不是說物件導向很簡單，雖然物件導向很複雜，但Java知道，你很瞭解物件導向，因為它就在你身邊。</pre>

## 介面介紹

介面（英文：Interface），在JAVA程式語言中是一個抽象型別，是抽象方法的集合，介面通常以interface來宣告。一個類透過繼承介面的方式，從而來繼承介面的抽象方法。

介面並不是類，編寫介面的方式和類很相似，但是它們屬於不同的概念。類描述物件的屬性和方法。介面則包含類要實現的方法。

除非實現介面的類是抽象類，否則該類要定義介面中的所有方法。

介面無法被例項化，但是可以被實現。一個實現介面的類，必須實現介面內所描述的所有方法，否則就必須宣告為抽象類。另外，在 Java 中，介面型別可用來宣告一個變數，他們可以成為一個空指標，或是被繫結在一個以此介面實現的物件。

### 介面與類相似點：

*   一個介面可以有多個方法。
*   介面檔案儲存在 .java 結尾的檔案中，檔名使用介面名。
*   介面的位元組碼檔案儲存在 .class 結尾的檔案中。
*   介面相應的位元組碼檔案必須在與包名稱相匹配的目錄結構中。

### 介面與類的區別：

*   介面不能用於例項化物件。
*   介面沒有構造方法。
*   介面中所有的方法必須是抽象方法。
*   介面不能包含成員變數，除了 static 和 final 變數。
*   介面不是被類繼承了，而是要被類實現。
*   介面支援多繼承。

### 介面特性

*   介面中每一個方法也是隱式抽象的,介面中的方法會被隱式的指定為 **public abstract**（只能是 public abstract，其他修飾符都會報錯）。
*   介面中可以含有變數，但是介面中的變數會被隱式的指定為 **public static final** 變數（並且只能是 public，用 private 修飾會報編譯錯誤）。
*   介面中的方法是不能在介面中實現的，只能由實現介面的類來實現介面中的方法。

### 抽象類和介面的區別

*   1\. 抽象類中的方法可以有方法體，就是能實現方法的具體功能，但是介面中的方法不行。
*   2\. 抽象類中的成員變數可以是各種型別的，而介面中的成員變數只能是 **public static final** 型別的。
*   3\. 介面中不能含有靜態程式碼塊以及靜態方法(用 static 修飾的方法)，而抽象類是可以有靜態程式碼塊和靜態方法。
*   4\. 一個類只能繼承一個抽象類，而一個類卻可以實現多個介面。

> **注**：JDK 1.8 以後，介面裡可以有靜態方法和方法體了。

### 介面的使用：
  我們來舉個例子，定義一個抽象類People，一個普通子類Student，兩個介面。子類Student繼承父類People,並實現介面Study，Write

程式碼演示：

package demo;
    //構建一個抽象類People
    abstract class People{
    	//父類屬性私有化
    	private String name;
    	private int age;
    	//提供父類的構造器
    	public People(String name,int age){
    		this.name = name;
    		this.age = age;
    	}
    	//提供獲取和設定屬性的getter()/setter()方法
    	public String getName() {
    		return name;
    	}
     
    	public int getAge() {
    		return age;
    	}
     
    	public void setName(String name) {
    		this.name = name;
    	}
     
    	public void setAge(int age) {
    		this.age = age;
    	}
    	
    	//提供一個抽象方法
    	public abstract void talk();	
    }
     
    //定義一個介面
    interface Study{
    	//設定課程數量為3
    	int COURSENUM = 3;
    	//構建一個預設方法
    	default void stu(){
    		System.out.println("學生需要學習"+COURSENUM+"門課程");
    	}
    }
     
    //再定義一個介面
    interface Write{
    	//定義一個抽象方法
    	void print();
    }
     
    //子類繼承People,實現介面Study,Write
    class Student extends People implements Study,Write{
    	//透過super關鍵字呼叫父類的構造器
    	public Student(String name, int age) {
    		super(name, age);
    	}
    	//實現父類的抽象方法
    	public void talk() {
    		System.out.println("我的名字叫"+this.getName()+",今年"+this.getAge()+"歲");
    	}
    	//實現Write介面的抽象方法
    	public void print() {
    		System.out.println("學生會寫作業");
    	}
    }
     
    public class InterfaceDemo{
    	public static void main(String[] args) {
    		//構建student物件
    		Student student = new Student("dodo", 22);
    		//呼叫父類的抽象方法
    		student.talk();
    		//呼叫介面Write中的抽象方法
    		student.print();
    		//呼叫介面Study中的預設方法
    		student.stu();
    	}
    }
    
程式碼講解：上述例子結合了抽象類和介面的知識，內容較多，同學們可以多看多敲一下，學習學習。

介面的實現：類名 implements 介面名，有多個介面名，用“，”隔開即可。

介面的作用——制定標準
   介面師表尊，所謂的標準，指的是各方共同遵守一個守則，只有操作標準統一了，所有的參與者才可以按照統一的規則操作。

如電腦可以和各個裝置連線，提供統一的USB介面，其他裝置只能透過USB介面和電腦相連

程式碼實現：
    
    package demo;
     
    interface USB 
    {
        public void work() ;    // 拿到USB裝置就表示要進行工作
    }
     
    class Print implements USB 		//實現類（介面類）	
    {   							// 印表機實現了USB介面標準（對介面的方法實現）
        public void work() 
       {
            System.out.println("印表機用USB介面，連線,開始工作。") ;
        }
    }
    class Flash implements USB 		//實現類（介面類）	 		 	
    {  								// 隨身碟實現了USB介面標準（對介面的方法實現）
        public void work() 
        {
            System.out.println("隨身碟使用USB介面，連線,開始工作。") ;
        }
    }
     
    class Computer 
    {
        public void plugin(USB usb) 			//plugin的意思是外掛，引數為接收介面類
        {
            usb.work() ;    // 按照固定的方式進行工作
        }
    }
    public class InterfaceStandards { public static void main(String args[]) { Computer computer = new Computer() ; computer.plugin(new Print()) ; //例項化介面類， 在電腦上使用印表機 computer.plugin(new Flash()) ; //例項化介面類， 在電腦上使用隨身碟 }}
    
程式碼講解：上述例子，就給我們展示了介面制定標準的作用，怎麼指定的呢？看下面程式碼
    
    class Computer 
    {
        public void plugin(USB usb) 			//plugin的意思是外掛，引數為接收介面類
        {
            usb.work() ;    // 按照固定的方式進行工作
        }
    }

我們可以看到，Computer類裡面定義了一個方法plugin()，它的引數內寫的是USB usb,即表示plugin()方法裡，接收的是一個usb物件，而印表機和隨身碟物件可以透過向上轉型當引數，傳入方法裡。我們來重新寫一個main方法幫助大家理解

程式碼演示：

public class InterfaceStandards 
    {
        public static void main(String args[]) 
        {   
            Computer computer = new Computer() ;
            
            USB usb = new Print();
            computer.plugin(usb) ;   //例項化介面類， 在電腦上使用印表機
            usb = new Flash();
            computer.plugin(usb) ;   //例項化介面類， 在電腦上使用隨身碟
        }
    }
程式碼講解：我們修改了主函式後，發現，使用了兩次的向上轉型給了USB，雖然使用的都是usb物件，但賦值的子類物件不一樣，實現的方法體也不同，這就很像現實生活，無論我使用的是印表機，還是隨身碟，我都是透過USB介面和電腦連線的，這就是介面的作用之一——制定標準

我們來個圖繼續幫助大家理解一下：

![image](https://img-blog.csdn.net/20180429143444890?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NzQxOTcx/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70)

上面的圖：我們學習前面的章節多型可以知道物件的多型可以透過動態繫結來實現，即使用向上轉型，我們知道類，陣列，介面都是引用型別變數，什麼是引用型別變數？

引用型別變數都會有一個地址的概念，即指向性的概念，當USB usb = new Print(),此時usb物件是指向new Print()的，當usb = new Flash()後，這時候usb變數就會指向new Flash()，我們會說這是子類物件賦值給了父類物件usb，而在記憶體中，我們應該說，usb指向了new Flash();

### 介面最佳實踐：設計模式中的工廠模式

首先我們來認識一下什麼是工廠模式？工廠模式是為了解耦：把物件的建立和使用的過程分開。就是Class A 想呼叫 Class B ，那麼A只是呼叫B的方法，而至於B的例項化，就交給工廠類。

其次，工廠模式可以降低程式碼重複。如果建立物件B的過程都很複雜，需要一定的程式碼量，而且很多地方都要用到，那麼就會有很多的重複程式碼。我們可以這些建立物件B的程式碼放到工廠裡統一管理。既減少了重複程式碼，也方便以後對B的建立過程的修改維護。

由於建立過程都由工廠統一管理，所以發生業務邏輯變化，不需要找到所有需要建立B的地方去逐個修正，只需要在工廠裡修改即可，降低維護成本。同理，想把所有呼叫B的地方改成B的子類C，只需要在對應生產B的工廠中或者工廠的方法中修改其生產的物件為C即可，而不需要找到所有的new B（）改為newC()。

程式碼演示：

package demo;
     
    import java.util.Scanner;
     
    interface Fruit						//定義一個水果標準
    {
    	public abstract void eat();
    }
     
    class Apple implements Fruit
    {
    	public void eat()
    	{
    		System.out.println("吃蘋果");
    	}
    }
    class Orange implements Fruit
    {
    	public void eat()
    	{
    		System.out.println("吃橘子");
    	}
    }
 
    class factory
    {
    	public static Fruit getInstance(String className)  //返回值是Fruit的子類
    	{
    		if("apple".equals(className))
    		{
    			return new Apple();
    		}
    		else if("orange".equals(className))
    		{
    			return new Orange();
    		}
    		else
    		{
    			return null;
    		}
    	}
    }
     
    public class ComplexFactory {
    	public static void main(String[] args)
    	{	
    		System.out.println("請輸入水果的英文名:");
    		Scanner sc = new Scanner(System.in);
    		String ans = sc.nextLine();
    		Fruit f = factory.getInstance(ans);   //初始化引數
    		f.eat();
    		sc.close();
    	}
    }
程式碼講解：上述程式碼部分我們講一下factory這個類，類中有一個getInstance方法，我們用了static關鍵字修飾，在使用的時候我們就在main中使用類名.方法名呼叫。

Fruit f = factory.getInstance(ans);   //初始化引數
在Factory的getInstance()方法中，我們就可以透過邏輯的實現，將物件的建立和使用的過程分開了。

總結點評：在介面的學習中，大家可以理解介面是特殊的抽象類，java中類可以實現多個介面，介面中成員屬性預設是public static final修飾，可以省略；成員方法預設是public abstract修飾，同樣可以省略，介面中還可定義帶方法體的預設方法，需要使用default修飾。利用介面我們還可以制定標準，還能夠使用工廠模式，將物件的建立和使用過程分開。

## 介面與抽象類的本質區別是什麼？

### 基本語法區別

在 Java 中，介面和抽象類的定義語法是不一樣的。這裡以動物類為例來說明，其中定義介面的示意程式碼如下：

<pre>public interface Animal
{
    //所有動物都會吃
    public void eat();

//所有動物都會飛
    public void fly();
}</pre>

定義抽象類的示意程式碼如下：

<pre>public abstract class Animal
{
    //所有動物都會吃
    public abstract void eat();

//所有動物都會飛
    public void fly(){};
}</pre>

可以看到，在介面內只能是功能的定義，而抽象類中則可以包括功能的定義和功能的實現。在介面中，所有的屬性肯定是 public、static 和 final，所有的方法都是 abstract，所以可以預設不寫上述識別符號；在抽象類中，既可以包含抽象的定義，也可以包含具體的實現方法。

在具體的實現類上，介面和抽象類的實 現類定義方式也是不一樣的，其中介面實現類的示意程式碼如下：

<pre>public class concreteAnimal implements Animal
{
    //所有動物都會吃
    public void eat(){}

//所有動物都會飛
    public void fly(){}
}</pre>

抽象類的實現類示意程式碼如下：

<pre>public class concreteAnimal extends Animal
{
    //所有動物都會吃
    public void eat(){}

//所有動物都會飛
    public void fly(){}
}</pre>

可以看到，在介面的實現類中使用 implements 關鍵字；而在抽象類的實現類中，則使用 extends 關鍵字。一個介面的實現類可以實現多個介面，而一個抽象類的實現類則只能實現一個抽象類。

### 設計思想區別

從前面抽象類的具體實現類的實現方式可以看出，其實在 Java 中，抽象類和具體實現類之間是一種繼承關係，也就是說如果釆用抽象類的方式，則父類和子類在概念上應該是相同的。介面卻不一樣，如果採用介面的方式，則父類和子類在概念上不要求相同。

介面只是抽取相互之間沒有關係的類的共同特徵，而不用關注類之間的關係，它可以使沒有層次關係的類具有相同的行為。因此，可以這樣說：抽象類是對一組具有相同屬性和方法的邏輯上有關係的事物的一種抽象，而介面則是對一組具有相同屬性和方法的邏輯上不相關的事物的一種抽象。

仍然以前面動物類的設計為例來說明介面和抽象類關於設計思想的區別，該動物類預設所有的動物都具有吃的功能，其中定義介面的示意程式碼如下：

<pre>public interface Animal
{
    //所有動物都會吃
    public void eat();
}</pre>

定義抽象類的示意程式碼如下：

<pre>public abstract class Animal
{
    //所有動物都會吃
    public abstract void eat();
}</pre>

不管是實現介面，還是繼承抽象類的具體動物，都具有吃的功能，具體的動物類的示意程式碼如下。

介面實現類的示意程式碼如下：

<pre>public class concreteAnimal implements Animal
{
    //所有動物都會吃
    public void eat(){}
}</pre>

抽象類的實現類示意程式碼如下：

<pre>public class concreteAnimal extends Animal
{
    //所有動物都會吃
    public void eat(){}
}</pre>

當然，具體的動物類不光具有吃的功能，比如有些動物還會飛，而有些動物卻會游泳，那麼該如何設計這個抽象的動物類呢？可以別在介面和抽象類中增加飛的功能，其中定義介面的示意程式碼如下：

<pre>public interface Animal
{
    //所有動物都會吃
    public void eat();

//所有動物都會飛
    public void fly();
}</pre>

定義抽象類的示意程式碼如下：

public abstract class Animal
    {
        //所有動物都會吃
        public abstract void eat();
    
        //所有動物都會飛
        public void fly(){};
    }

這樣一來，不管是介面還是抽象類的實現類，都具有飛的功能，這顯然不能滿足要求，因為只有一部分動物會飛，而會飛的卻不一定是動物，比如飛機也會飛。那該如何設計呢？有很多種方案，比如再設計一個動物的介面類，該介面具有飛的功能，示意程式碼如下：

<pre>public interface AnimaiFly
{
    //所有動物都會飛
    public void fly();
}</pre>

那些具體的動物類，如果有飛的功能的話，除了實現吃的介面外，再實現飛的介面，示意程式碼如下：

<pre>public class concreteAnimal implements Animal,AnimaiFly
{
    //所有動物都會吃
    public void eat(){}

//動物會飛
    public void fly();
}</pre>

那些不需要飛的功能的具體動物類只實現具體吃的功能的介面即可。另外一種解決方案是再設計一個動物的抽象類，該抽象類具有飛的功能，示意程式碼如下：

<pre>public abstract class AnimaiFly
{
    //動物會飛
    public void fly();
}</pre>

但此時沒有辦法實現那些既有吃的功能，又有飛的功能的具體動物類。因為在 Java 中具體的實現類只能實現一個抽象類。一個折中的解決辦法是，讓這個具有飛的功能的抽象類，繼承具有吃的功能的抽象類，示意程式碼如下：

<pre>public abstract class AnimaiFly extends Animal
{
    //動物會飛
    public void fly();
}</pre>

此時，對那些只需要吃的功能的具體動物類來說，繼承 Animal 抽象類即可。對那些既有吃的功能又有飛的功能的具體動物類來說，則需要繼承 AnimalFly 抽象類。

但此時對客戶端有一個問題，那就是不能針對所有的動物類都使用 Animal 抽象類來進行程式設計，因為 Animal 抽象類不具有飛的功能，這不符合物件導向的設計原則，因此這種解決方案其實是行不通的。

還有另外一種解決方案，即具有吃的功能的抽象動物類用抽象類來實現，而具有飛的功能的類用介面實現；或者具有吃的功能的抽象動物類用介面來實現，而具有飛的功能的類用抽象類實現。

具有吃的功能的抽象動物類用抽象類來實現，示意程式碼如下：

<pre>public abstract class Animal
{
    //所有動物都會吃
    public abstract void eat();
}</pre>

具有飛的功能的類用介面實現，示意程式碼如下：

<pre>public interface AnimaiFly
{
    //動物會飛
    public void fly();
}</pre>

既具有吃的功能又具有飛的功能的具體的動物類，則繼承 Animal 動物抽象類，實現 AnimalFly 介面，示意程式碼如下：

<pre>public class concreteAnimal extends Animal implements AnimaiFly
{
    //所有動物都會吃
    public void eat(){}

//動物會飛
    public void fly();
}</pre>

或者具有吃的功能的抽象動物類用介面來實現，示意程式碼如下：

<pre>public interface Animal
{
    //所有動物都會吃
    public abstract void eat();
}</pre>

具有飛的功能的類用抽象類實現，示意程式碼如下：

<pre>public abstract class AnimaiFly
{
    //動物會飛
    public void fly(){};
}</pre>

既具有吃的功能又具有飛的功能的具體的動物類，則實現 Animal 動物類介面，繼承 AnimaiFly 抽象類，示意程式碼如下：

<pre>public class concreteAnimal extends AnimaiFly implements Animal
{
    //所有動物都會吃
    public void eat(){}

//動物會飛
    public void fly();
}</pre>

這些解決方案有什麼不同呢？再回過頭來看介面和抽象類的區別：抽象類是對一組具有相同屬性和方法的邏輯上有關係的事物的一種抽象，而介面則是對一組具有相同屬性和方法的邏輯上不相關的事物的一種抽象，因此抽象類表示的是“is a”關係，介面表示的是“like a”關係。

假設現在要研究的系統只是動物系統，如果設計人員認為對既具有吃的功能又具有飛的功能的具體的動物類來說，它和只具有吃的功能的動物一樣，都是動物，是一組邏輯上有關係的事物，因此這裡應該使用抽象類來抽象具有吃的功能的動物類，即繼承 Animal 動物抽象類，實現 AnimalFly 介面。

如果設計人員認為對既具有吃的功能，又具有飛的功能的具體的動物類來說，它和只具有飛的功能的動物一樣，都是動物，是一組邏輯上有關係的事物，因此這裡應該使用抽象類來抽象具有飛的功能的動物類，即實現 Animal 動物類介面，繼承 AnimaiFly 抽象類。

假設現在要研究的系統不只是動物系統，如果設計人員認為不管是吃的功能，還是飛的功能和動物類沒有什麼關係，因為飛機也會飛，人也會吃，則這裡應該實現兩個介面來分別抽象吃的功能和飛的功能，即除實現吃的 Animal 介面外，再實現飛的 AnimalFly 介面。

從上面的分析可以看出，對於介面和抽象類的選擇，反映出設計人員看待問題的不同角度，即抽象類用於一組相關的事物，表示的是“is a”的關係，而介面用於一組不相關的事物，表示的是“like a”的關係。

### 如何回答面試題：介面和抽象類的區別?

介面(interface)和抽象類(abstract class)是支援抽象類定義的兩種機制。

介面是公開的，不能有私有的方法或變數，介面中的所有方法都沒有方法體，透過關鍵字interface實現。

抽象類是可以有私有方法或私有變數的，透過把類或者類中的方法宣告為abstract來表示一個類是抽象類，被宣告為抽象的方法不能包含方法體。子類實現方法必須含有相同的或者更低的訪問級別(public->protected->private)。抽象類的子類為父類中所有抽象方法的具體實現，否則也是抽象類。

介面可以被看作是抽象類的變體，介面中所有的方法都是抽象的，可以透過介面來間接的實現多重繼承。介面中的成員變數都是static final型別，由於抽象類可以包含部分方法的實現，所以，在一些場合下抽象類比介面更有優勢。

#### 相同點：

（1）都不能被例項化
（2）介面的實現類或抽象類的子類都只有實現了介面或抽象類中的方法後才能例項化。

#### 不同點：
（1）介面只有定義，不能有方法的實現，java 1.8中可以定義default方法體，而抽象類可以有定義與實現，方法可在抽象類中實現。

（2）實現介面的關鍵字為implements，繼承抽象類的關鍵字為extends。一個類可以實現多個介面，但一個類只能繼承一個抽象類。所以，使用介面可以間接地實現多重繼承。

（3）介面強調特定功能的實現，而抽象類強調所屬關係。

（4）介面成員變數預設為public static final，必須賦初值，不能被修改；其所有的成員方法都是public、abstract的。抽象類中成員變數預設default，可在子類中被重新定義，也可被重新賦值；抽象方法被abstract修飾，不能被private、static、synchronized和native等修飾，必須以分號結尾，不帶花括號。

（5）介面被用於常用的功能，便於日後維護和新增刪除，而抽象類更傾向於充當公共類的角色，不適用於日後重新對立面的程式碼修改。功能需要累積時用抽象類，不需要累積時用介面。

## 參考文章

> https://blog.csdn.net/likunkun__/article/details/83066062
> https://www.jianshu.com/p/6877aae403f7
> https://www.jianshu.com/p/49e45af288ea
> https://blog.csdn.net/du_du1/article/details/91383128
> http://c.biancheng.net/view/976.html
> https://blog.csdn.net/evilcry2012/article/details/79499786
> https://www.jb51.net/article/129990.htm

## 微信公眾號

### 個人公眾號：程式設計師黃小斜

黃小斜是 985 碩士，阿里巴巴Java工程師，在自學程式設計、技術求職、Java學習等方面有豐富經驗和獨到見解，希望幫助到更多想要從事網際網路行業的程式設計師們。

作者專注於 JAVA 後端技術棧，熱衷於分享程式設計師乾貨、學習經驗、求職心得，以及自學程式設計和Java技術棧的相關乾貨。

黃小斜是一個斜槓青年，堅持學習和寫作，相信終身學習的力量，希望和更多的程式設計師交朋友，一起進步和成長！

**原創電子書:**
關注微信公眾號【程式設計師黃小斜】後回覆【原創電子書】即可領取我原創的電子書《菜鳥程式設計師修煉手冊：從技術小白到阿里巴巴Java工程師》這份電子書總結了我2年的Java學習之路，包括學習方法、技術總結、求職經驗和麵試技巧等內容，已經幫助很多的程式設計師拿到了心儀的offer！

**程式設計師3T技術學習資源：** 一些程式設計師學習技術的資源大禮包，關注公眾號後，後臺回覆關鍵字 **“資料”** 即可免費無套路獲取，包括Java、python、C++、大資料、機器學習、前端、移動端等方向的技術資料。

![](https://img-blog.csdnimg.cn/20190829222750556.jpg)

### 技術公眾號：Java技術江湖

如果大家想要實時關注我更新的文章以及分享的乾貨的話，可以關注我的微信公眾號【Java技術江湖】

這是一位阿里 Java 工程師的技術小站。作者黃小斜，專注 Java 相關技術：SSM、SpringBoot、MySQL、分散式、中介軟體、叢集、Linux、網路、多執行緒，偶爾講點Docker、ELK，同時也分享技術乾貨和學習經驗，致力於Java全棧開發！

（關注公眾號後回覆”Java“即可領取 Java基礎、進階、專案和架構師等免費學習資料，更有資料庫、分散式、微服務等熱門技術學習影片，內容豐富，兼顧原理和實踐，另外也將贈送作者原創的Java學習指南、Java程式設計師面試指南等乾貨資源）

**Java工程師必備學習資源:** 一些Java工程師常用學習資源，關注公眾號後，後臺回覆關鍵字 **“Java”** 即可免費無套路獲取。

![我的公眾號](https://img-blog.csdnimg.cn/20190805090108984.jpg)

夯實Java基礎系列6：一文搞懂抽象類和介面，從基礎到面試題，揭秘其本質區別！

相關文章