本篇開始會從基礎開始把每一個知識點講明白講透徹，旨在讓每個知識點都能在工作中和面試中用的上。如果有講的不明白的地方歡迎公眾號私信討論，第一時間有問必答。

java的設計就是將java世界比作真實世界，一切事物都可以被某些類型定義，每一個具體的事物都是類型下面的實體對象，類型可以更抽象，比如“鳥類”，也可以更具體，比如“麻雀”，而一只活蹦亂跳的麻雀對象屬于麻雀這個類型，也屬于鳥類這個類型，而鳥類是麻雀類的抽象。

真實的世界中每種類型的特點以及類與類的關系是生來就有的，就像是我們看到天上飛的我們就知道它是鳥類，而java世界畢竟不是真實世界，他需要通過定義規則來約束這些關系。

面向對象中有四個特性，封裝，繼承，多肽，抽象，java利用這些特性來描述類和類與類的關系。

一、類

雖然java是模擬真實世界，但是java對類的定義是開放，程序員可以按照自己想象任意定義類，但是類的定義和現實世界又是一樣的，我們在描述一個鳥類的時候，一般是說鳥有羽毛，五顏六色，會飛等等，但是歸根結底是在闡述鳥的外觀和技能，而在java中外觀描述和技能對應的是類中的成員屬性和成員方法。

二、對象

java中通過new關鍵字創建的就是一個具體的對象，它具備所屬類的所有屬性和方法，它可以在適當的地方被操作。

三、面向對象的特性

1.封裝

封裝也叫作信息隱藏或者數據訪問保護，我們用一個非常通俗的現實例子來說明下:

public class bank {
    private String id;
    private long createTime;
    private BigDecimal balance;
    private long balanceLastModifiedTime;
}

這是一個銀行存款的例子，在存款的時候有存款時間，存款后的余額，余額更改時間，如果這幾個屬性是public修飾，那么其他類都可以訪問這幾個屬性，并且對其任意修改，這是不安全的，封裝的目的把屬性的修改權限私有化，比如時間只有內部可以改動，不需要對外開放，對于余額的改動銀行依賴于存款人存多少錢，所以可以提供一個帶入參的函數入口，類似于存款人把錢給到銀行，由銀行人員進行余額的變動，這是把權限最小化，盡可能增強安全性，通過有限的方法暴露必要的操作，我們代碼中的get set方法就是封裝的最簡體現。

2.繼承

繼承是指子類繼承父類，語法機制：extends

public class A extends D

一旦達成繼承關系，子類就會擁有父類非private修飾的屬性和方法。 并且子類可以擁有自己獨有的屬性和方法，同時子類還可以用自己的方式實現父類的方法，即重寫。

一個父類可以被多個子類繼承，但是一個子類不能繼承多個父類。

繼承讓代碼可以復用，把子類共有的方法抽離到父類中實現，由子類來繼承父類，從而達到代碼精簡。

關于繼承還有兩種特殊的繼承：實現接口和繼承抽象類。

我們先來了解下接口和抽象類。

(1) 抽象類

public abstract class A

一個普通的類如果被abstract修飾，就是一個抽象類，抽象類相對于普通類的特點如下：

• 可以存在abstract修飾的方法，即抽象方法，被abstract修飾的方法不能用private、static、synchronized、native等訪問修飾符修飾，并且沒有實現體。
• 不能實例化，只能被子類繼承
• 如果子類繼承了抽象類，并且實現了抽象類的所有抽象方法，那么子類是一個具體的類，如果沒有全部實現其抽象方法，則子類也是一個抽象類
• 抽象類可以有構造方法，目的是讓子類來調用構造方法初始化

(2) 接口

接口是一種特殊的抽象類，語法機制：interface

public interface B

接口其實就是一種特殊的抽象類，相對于抽象類不同的地方是：

• 只能被實現，其實現也是一種特殊的繼承，卻別是繼承只能單繼承，而實現可以多實現。
• 接口中默認所有的方法都是抽象方法。
• 接口中定義的成員變量默認是public static final，即只能夠有靜態的不能被修改的數據成員，而且必須賦初值。
• 一個類可以實現多個接口，一定程度上彌補了不能多繼承的問題。
• java中類可以繼承類，也可以實現接口，接口也可以繼承接口，而且接口繼承接口可以多繼承，即一個接口可以用關鍵字extends繼承多個接口。

對于接口和抽象類的應用如何理解：

結合面向對象思想來理解，抽象類是類的溯源產物，比如：幼年貓-貓-貓科-動物，是一個類群里不斷向上溯源就是抽象；而接口是對行為的分組，比如吃飯，睡覺，玩游戲。

那么在日常應用中，應該怎么應用呢？

從設計的角度講，接口往往被用來定義一組行為，舉個例子：

public class 鳥

cry();

public class 鴨 extends 鳥
cry(){
  嘎嘎嘎
}

public class 雞 extends 鳥
cry(){
  吱吱吱
}

public class 烏鴉 extends 鳥
cry(){
  喳喳喳
}

如上代碼，每種鳥都有自己獨特的叫聲，每種鳥都要重寫cry方法，沒有辦法將叫這個行為抽象到父類中，也就無法利用父類實現代碼復用，增加了代碼的復雜性和開發工作量。

如果每種鳥都有自己獨特的叫聲，那每個鳥類都要重寫cry方法也是沒有辦法但是必須這么做的事情。但事實上，鳥類的數量遠遠大于叫的方式的數量，也就是說，可能一百種鳥的叫聲都是吱吱吱，一百種鳥的叫聲都是咕咕咕，這種情況下，就可以通過接口來設計了。

就是用接口定義行為，由具體的行為類實現接口，每個鳥類再將叫的行為委托給行為類實現。

public interface cry

public class Zhizhizhi implements cry
cry(){
吱吱吱
}

public class Gagaga implements cry
cry(){
嘎嘎嘎
}

public class 鴨 extends 鳥
Gagaga gagaga;
cry(){
  gagaga.cry();
}

public class 雞 extends 鳥
Zhizhizhi zhizhizhi;
cry(){
  zhizhizhi.cry();
}

如上代碼，將行為從具體的類中分離出來單獨定義為行為類，具體類和行為類以組合在一起，這樣就可以復用代碼。

所有的行為都需要這樣設計嗎？并不是，只有當前類獨有的行為可以在當前類中單獨實現。而那些變化多端的行為就要以這樣方式設計。

從開發的角度講，接口往往用于隔離接口和實現達到解耦的效果

日常開發中我們設計一個功能，往往是以接口的形式對外暴露，不暴露實現，這樣的設計為了隔離接口和具體的實現，提高代碼的擴展性。

3.多態

多態是指子類可以替換父類，父類的引用可以指向子類，我們直接用代碼來說明：

public class DynamicArray {
  
  private static final int DEFAULT_CAPACITY = 10;
  protected int size = 0;
  protected Integer[] elements = new Integer[DEFAULT_CAPACITY];

  public int size() {
   return this.size;
  }

  public Integer get(int index) {
   return elements[index];
  }

  public void add(Integer e) {
   elements[size++] = e;
  }

 }

 public class SortedDynamicArray extends DynamicArray {
  @Override
  public void add (Integer e) {
   int i;
   for (i = size - 1; i >= 0; --i) {
    if (elements[i] > e) {
     elements[i + 1] = elements[i];
    } else {
     break;
    }
   }
   elements[i + 1] = e;
   ++size;
  }
 }

 public class Example {
  public static void test(DynamicArray dynamicArray) {
   dynamicArray.add(5);
   dynamicArray.add(1);
   dynamicArray.add(3);
   for (int i = 0; i < dynamicArray.size(); ++i) {
    System.out.println(dynamicArray.get(i));
   }
  }

  public static void main(String args[]) {
   DynamicArray dynamicArray = new SortedDynamicArray();
   test(dynamicArray);
  }
 }

public interface Iterator {

  String hasNext();

  String next();

  String remove();

 }

 public class Array implements Iterator {
  
  private String[] data;

  public String hasNext() { ...}

  public String next() { ...}

  public String remove() { ...}

 }

 public class LinkedList implements Iterator {

  private LinkedListNode head;

  public String hasNext() { ...}

  public String next() { ...}

  public String remove() { ...}

 }

 public class Demo {
  private static void print(Iterator iterator) {
   while (iterator.hasNext()) {
    System.out.println(iterator.next());
   }
  }

  public static void main(String[] args) {
   Iterator arrayIterator = new Array();
   print(arrayIterator);
   Iterator linkedListIterator = new LinkedList();
   print(linkedListIterator);
  }
 }

上面兩個案例中最關鍵的代碼：

DynamicArray dynamicArray = new SortedDynamicArray();

Iterator arrayIterator = new Array();

這兩行代碼都是用父類來接收子類，其實這就是多肽，但是要達到這樣的目的是要依賴于“繼承”或者“實現”，正如上面的代碼一樣。

多態特性能提高代碼的可擴展性和復用性。

在那個例子中，我們利用多態的特性，僅用一個print()函數就可以實現遍歷打印不同類型（Array、LinkedList）集合的數據。當再增加一種要遍歷打印的類型的時候，比如HashMap，我們只需讓HashMap實現Iterator接口，重新實現自己的hasNext()、next()等方法就可以了，完全不需要改動print()函數的代碼。所以說，多態提高了代碼的可擴展性。

總結

Java的基礎就是面向對象思想，支撐面向對象思想是：封裝，繼承，多肽，抽象，接口，后續的設計模式都是建立在這些基礎特性上面，要想開發出高質量代碼必須先掌握基礎。