業內經常說的一句話是不要重複造輪子，但是有時候，只有自己造一個輪子了，才會深刻明白什麼樣的輪子適合山路，什麼樣的輪子適合平地！

我將會持續更新java基礎知識，歡迎關注。

往期章節：

JAVA基礎第一章-初識java

JAVA基礎第二章-java三大特性：封裝、繼承、多型

類與物件

什麼是類？

類是抽象的概念集合，表示的是一個共性的產物，類之中定義的是屬性和行為（方法）。

什麼是物件？

物件是一種個性的表示，表示一個獨立的個體，每個物件擁有自己獨立的屬性，依靠屬性來區分不同物件。

所以總結來說的話，類是物件的模板，物件是類的例項

舉個例子：

人類就是一個類（class），你，我，他就是每一個人類的例項。我們每一個個體的最基本的屬性有姓名、性別、體重、身高等。

具體的程式碼表現如下：

 1 public class Human 
 2 {
 3     private String name;
 4     private String sex;
 5     private int weight;
 6     private int heiht;
 7     
 8     
 9     public static void main(String[] args)
10     {
11         Human me = new
 
 Human();
12         me.setName("JJ");
13         me.setSex("man");
14         me.setHeiht(198);  //我的理想身高~0.0
15         me.setWeight(180);
16         
17         Human he = new Human();
18         he.setName("name");
19         he.setSex("man");
20         he.setHeiht(180);  
21         he.setWeight(150);
 
22     }
23     
24     
25     public String getName() {
26         return name;
27     }
28 
29     public void setName(String name) {
30         this.name = name;
31     }
32 
33     public String getSex() {
34         return sex;
35     }
36 
37     public void setSex(String sex) {
38         this.sex = sex;
39     }
40 
41     public int getWeight() {
42         return weight;
43     }
44 
45     public void setWeight(int weight) {
46         this.weight = weight;
47     }
48 
49     public int getHeiht() {
50         return heiht;
51     }
52 
53     public void setHeiht(int heiht) {
54         this.heiht = heiht;
55     }
56 }

從上面的程式碼我們可以看到，在main函式中，我們通過 new 關鍵字新建了2個物件。一個是me，一個是he，我們都來自Human類，但是我們具有不同的屬性，我們除了性別相同，其他的屬性完全不同。

這裡特別再提到一點就是我們在 new 一個物件的時候後面的 Human() 函式，我們稱之為建構函式（方法）。

在建立一個物件的時候，至少要呼叫一個構造方法。構造方法的名稱必須與類同名，一個類可以有多個構造方法。

每個類都有建構函式。如果沒有顯式地為類定義構造方法，Java編譯器將會為該類提供一個預設構造方法。所以從上面程式碼可以看到，我們並沒有指定建構函式，而是採用了預設的。

多個建構函式的寫法，程式碼表現如下：

 1 //每次新建的時候直接先設定性別，那麼當前新建的物件就不用再設定性別屬性
 2     public Human(String sex)
 3     {
 4         this.sex = sex;
 5     }
 6     
 7     //這個建構函式和預設建構函式相同，不傳任何引數
 8     public Human()
 9     {
10         
11     }

如果我們沒有宣告建構函式，那麼編譯器會為我們提供一個預設無參的建構函式；如果我們聲明瞭建構函式，不管幾個，那麼編譯器就不再為我們提供預設的建構函式。 

抽象類

使用了關鍵詞 abstract 宣告的類叫作“抽象類”。如果一個類裡包含了一個或多個抽象方法，類就必須指定成abstract（抽象）。“抽象方法”,屬於一種不完整的方法，只含有一個宣告，沒有方法主體。

具體程式碼表現如下：

 1 public abstract class Human 
 2 {
 3     private String name;
 4     private String sex;
 5     private int weight;
 6     private int heiht;
 7     
 8     public abstract String sayHello();
 9     
10     public String getName() {
11         return name;
12     }
13 
14     public void setName(String name) {
15         this.name = name;
16     }
17 
18     public String getSex() {
19         return sex;
20     }
21 
22     public void setSex(String sex) {
23         this.sex = sex;
24     }
25 
26     public int getWeight() {
27         return weight;
28     }
29 
30     public void setWeight(int weight) {
31         this.weight = weight;
32     }
33 
34     public int getHeiht() {
35         return heiht;
36     }
37 
38     public void setHeiht(int heiht) {
39         this.heiht = heiht;
40     }
41 }

從上面的程式碼中我們可以看到類名稱前面添加了abstract  關鍵字，抽象方法sayHello 前面也添加了關鍵字abstract，  同時這個方法不能寫方法體。

包含抽象方法的類稱為抽象類，但並不意味著抽象類中只能有抽象方法，它和普通類一樣，同樣可以擁有成員變數和普通的成員方法。

抽象類和普通類的主要一些區別：

抽象方法許可權必須為public或者protected，因為如果為private，則不能被子類繼承，子類便無法實現該方法，預設情況下預設為public。

抽象類不能建立物件，也就是不能通過new例項化；

如果一個類繼承於一個抽象類，則子類必須實現父類的抽象方法。

如果子類沒有實現父類的抽象方法，則必須將子類也定義為為abstract類。

在其他方面，抽象類和普通的類並沒有區別。

介面

說起介面，那麼很多時候我們就會和抽象類相比較，而且這個問題也是很多初級javaer，經常會被問到的面試問題。

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

具體的程式碼表現如下：

 1 /**
 2  *  動物介面
 3  * @author JJJ
 4  *
 5  */
 6 public interface Animals 
 7 {
 8     //介面內的靜態成員常量
 9      static String eyes = "1";
10      static final String leg = "2";
11      //吃東西
12      public void eatFood();
13 }

在上面我們已經制定了一個 Animals 介面，而人類作為高階動物，必然也是需要吃東西，下面我們就讓人類實現 Animals 介面，具體程式碼如下：

 1 public  class Human implements Animals
 2 {
 3     private String name;
 4     private String sex;
 5     private int weight;
 6     private int heiht;
 7     public String getName() {
 8         return name;
 9     }
10 
11     public void setName(String name) {
12         this.name = name;
13     }
14 
15     public String getSex() {
16         return sex;
17     }
18 
19     public void setSex(String sex) {
20         this.sex = sex;
21     }
22 
23     public int getWeight() {
24         return weight;
25     }
26 
27     public void setWeight(int weight) {
28         this.weight = weight;
29     }
30 
31     public int getHeiht() {
32         return heiht;
33     }
34 
35     public void setHeiht(int heiht) {
36         this.heiht = heiht;
37     }
38 
39     public String eatFood() 
40     {
41         return "今天我吃了米飯！";
42     }
43 }

看上面的程式碼第39行~我們重新實現了介面中的 eatFood 方法，並且寫上了方法體。

另外在這裡要說明一下，在 Animals 介面中我們聲明瞭2個靜態的成員變數eyes和 leg，後者被 final 修飾，在上一章節中我們說過凡是被 final 修飾的一旦初始化，就不可以更改。

那麼 eyes 是不是就可以修改呢？

從上圖可以看出，答案是不行~即使你在宣告的時候沒有顯示的寫 final ，在介面中依然會把這個變數歸為常量，所以介面中的屬性必然是常量，只能讀不能改，這樣才能為實現介面的物件提供一個統一的屬性。

抽象類與介面的區別：

介面是公開的，裡面不能有私有的方法或變數，是用於讓別人使用的，而抽象類是可以有私有方法或私有變數的，另外，實現介面的一定要實現接口裡定義的所有方法，而實現抽象類可以有選擇地重寫需要用到的方法；

一般的應用程式中，最頂級的是介面，然後是抽象類實現介面，最後才到具體類實現；

一個類只能繼承一個父類，但可以通過繼承（實現）多個介面實現多重繼承，介面還有標識（裡面沒有任何方法，如序列化 java.io.Serializable介面）和資料共享（裡面的變數全是常量）的作用；

抽象類和介面相同點：

都不能被例項化；

都可以定義靜態常量；

文中若有不正之處，歡迎批評指正！