面向物件

一、基礎概念

1、什么是面向物件

萬事萬物皆可是物件，而了解物件的詳細資訊，并關注它，這個程序就叫面向物件，面向一個具體的事物進行操作，便面向物件編程，

??????????????
????????????
??????????????????????

??????????????????因為你不會Java啊，來Java中new一個呀，不就有了？

2、Java中的物件

用來描述一個物體，通常由一組屬性和對這組屬性進行的操作組成，
物件的產生：通過對類的實體化，
物件的”一生“：生成、使用、消除，
當不存在對一個物件的參考時，該物件成為一個無用物件，Java的垃圾收集器自動掃描物件的動態記憶體區，把沒有參考的物件作為垃圾收集起來并釋放，當系統記憶體用盡或呼叫System.gc( )要求垃圾回收時，垃圾回收執行緒與系統同步運行，

3、類

類是具有相同屬性和方法的一組物件的集合，它為屬于該類的所有物件提供了統一的抽象描述，其內部包括屬性和方法兩個主要部分，在面向物件的編程語言中，類是一個獨立的程式單位，它應該有一個類名并包括屬性和方法兩個主要部分，
Java中的類實作包括兩個部分：類宣告和類體

4、基本特征

① 封裝

封裝性就是盡可能的隱藏物件內部細節，對外形成一道邊界，只保留有限的介面和方法與外界進行互動，封裝的原則是使物件以外的部分不能隨意的訪問和操作物件的內部屬性，從而避免了外界對物件內部屬性的破壞，
可以通過對類的成員設定一定的訪問權限，實作類中成員的資訊隱藏，

幾個關鍵字

private：類中限定為private的成員，只能被這個類本身訪問，如果一個類的構造方法宣告為private,則其它類不能生成該類的一個實體，
default：類中不加任何訪問權限限定的成員屬于預設的（default）訪問狀態，可以被這個類本身和同一個包中的類所訪問，
protected：類中限定為protected的成員，可以被這個類本身、它的子類（包括同一個包中以及不同包中的子類）和同一個包中的所有其他的類訪問，
public：類中限定為public的成員，可以被所有的類訪問，

② 繼承

子類的物件擁有父類的全部屬性與方法，稱作子類對父類的繼承，

Java中父類可以擁有多個子類，但是子類只能繼承一個父類，稱為單繼承， 繼承實作了代碼的復用，
Java中所有的類都是通過直接或間接地繼承java.lang.Object類得到的，
子類不能繼承父類中訪問權限為private的成員變數和方法， 子類可以重寫父類的方法，即命名與父類同名的成員變數，
Java中通過super來實作對父類成員的訪問，super用來參考當前物件的父類，super 的使用有三種情況：
訪問父類被隱藏的成員變數，如：super.variable;
呼叫父類中被重寫的方法，如：super.Method([paramlist]),super()呼叫父類構造方法;
呼叫父類的建構式，如：super([paramlist]);

③ 多型

物件的多型性是指在父類中定義的屬性或方法被子類繼承之后，可以具有不同的資料型別或表現出不同的行為，這使得同一個屬性或方法在父類及其各個子類中具有不同的語意，

Java的多型性體現在兩個方面：由方法多載實作的靜態多型性（編譯時多型）和方法重寫實作的動態多型性（運行時多型），
編譯時多型：在編譯階段，具體呼叫哪個被多載的方法，編譯器會根據引數的不同來靜態確定呼叫相應的方法，
運行時多型：由于子類繼承了父類所有的屬性（私有的除外），所以子類物件可以作為父類物件使用，程式中凡是使用父類物件的地方，都可以用子類物件來代替，一個物件可以通過參考子類的實體來呼叫子類的方法，

多型的前提條件
??①要有繼承/實作關系
??②要有方法重寫
??③要有父類參考指向子類物件

5、擴展

① 多載（Overloading）

方法多載是讓類以統一的方式處理不同資料型別的手段，
一個類中可以創建多個方法，它們具有相同的名字，但具有不同的引數和不同的定義，呼叫方法時通過>傳遞給它們的不同引數個數和引數型別來決定具體使用哪個方法，
回傳值型別可以相同也可以不相同，無法以回傳型別作為多載函式的區分標準，

② 重寫（Overriding）

子類對父類的方法進行重新撰寫，如果在子類中的方法與其父類有相同的的方法名、回傳型別和引數表，我們說該方法被重寫 (Overriding)，
如需父類中原有的方法，可使用super關鍵字，該關鍵字參考了當前類的父類， 子類函式的訪問修飾權限不能低于父類的，

注：Java中的多載與重寫的區別：
??1、多載發生在本類，重寫發生在父類與子類之間；
??2、多載的方法名必須相同，重寫的方法名相同且回傳值型別必須相同；
??3、多載的引數串列不同，重寫的引數串列必須相同，

二、升級一下思緒

1、深入探討一下三大特性

在你已經閱讀完上述的基礎概念過后,相信你已經有所了解，接下來我們就去深入探討一下這個久聞大名的三大特性吧!

????????????

① 封裝

??一、封裝的定義方法

首先我們可以看到封裝的特性可以得到封裝的一個特性——>安全性，那么我們哪些”不為人知“的引數怎么去見人呢？就和我們看電視的洗錢一樣呀，得用點手段呀；當然，這肯定不是犯罪，所以手段也不是什么傳說中的黑客！！！就是在我們想要別人能讀取，遵循我們的規則就好了，就讓它可以用set()/get()方法來對我們封裝好的類進行使用呀，

例：下面這個就是一個典型的封裝‘人’類，將人的姓名、性別等封裝起來，需要時直接呼叫就可了，
看完上面的圖片后，我相信你應該有以下幾個疑問：

圖片中的this是什么意思？

??在Java的繼承中，我們使用某些方法設定時，為了方便對比，我們就會定義與類同樣的變數名，而this關鍵字就可以區別出來我們指的是那個變數，比如圖中的this.id就是指的Person類中定義的私有id，后面的id則是setId(int id)方法中傳入的這個id，

封裝類里面只能由set/get方法組成？

??不，封裝類可以不只是由set/get方法，我們也可以定義其他方法，比如說我下面要定義一個show方法來顯示這個人的某些資訊，在這里也可以發現，我并沒有使用this關鍵字，也可以呼叫到我類中的變數，可以知道，當變數名不重復時，我們的變數訪問遵循了就近原則，

假如我定義這么多變數要一個一個寫get/set方法，還有無參由有參的函式豈不是很難寫？

??倘若你要一個一個的去敲的話，這個確實很多，但是我們發現這些函式其實也差不多，多以肯定由快捷方式呀下面分享一下：

兩種方法：一、按下ALT+Insert或者滑鼠右擊空白處
下面的截圖時滑鼠點擊出現的兩個截圖，用快捷鍵可以直接到右邊那一步，直接生成建構式和set/get方法即可，在我們學習程序中為了方便我們對封裝函式的呼叫，我們建構式的時候，最好將有參和無參函式都構造好，
????????

??二、封裝函式的呼叫

1、無參訪問
無參訪問時我們需要將引數實體化后，直接呼叫set方法進行設定我們需要的值就可以了，比如我下面這一串代碼

		person p2 = new person();
        p2.setName("pier");
        p2.setId(18);
        p2.show();

運行結果

身份證:18性別null出生日期null姓名pier

有參訪問幾句簡單很多了，直接將我們的引數傳入進去就可以了沒有的可以直接

person p =new person(18,"男","pipi",Date.from(Instant.now()));
p.show();

運行結果(這里由于沒有專門去設定時間格式，就直接呼叫當前時間，格式就不太對，但無傷大雅)

身份證:18性別男出生日期Thu Aug 12 10:50:28 CST 2021姓名pipi

② 繼承

在世界的大多數國家中，都有一項繼承法，其中的第一繼承者就是配偶和子女；是的，這個繼承也那個意思一樣不過不是繼承部分，而是全部都可以繼承，簡單來說就是，你父類中有的只要不是只能自己用的，我都可以有并且可以使用，你父類中沒有的，我也可以有，就算你有多個子類，但這并不影響我繼承呀，這一特性就可以讓我們的代碼有一個什么樣的特性呢——>復用性，

??看看繼承在現實中的含義叭
????????????
??上圖中我們可以看到無論是兔子、小羊羔這類食草動物，還是獅子和獵豹這類食肉動物都是動物，我們就可以將動物定義成一個父類，而其他的兔子、獅子等動物都可以繼承動物這個類，那么為什么我們要將動物當作我們的父類呢？因為呀他們有一個共同的特性，比如吃東西（吃草，吃肉）等特性，我們就可以將他們共同的特性定義在我們的父類中，而在子類中在將我們各種動物不同的地方定義出來，比如兔子吃草，有兩個大耳朵，獅子吃肉，有鋒利的牙齒，吃東西可以繼承動物，而不同的特性就可以另外定義以下，下面我們看看動物的例子叭：
動物類(父類)

public class Animal {
    private String name;

    public Animal(){

    }
    public Animal(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    public void eat(String s){
        System.out.println("我是"+getName()+",我可以吃"+s+"呢");
    }
}

獅子類(子類一)

public class Lion extends Animal{
    public Lion() {
    }

    public Lion(String name) {
        super(name);
    }
}

兔子類(子類二)

public class rabbit extends Animal{
    public rabbit(){

    }
    public rabbit(String name){
        super();
    }
    public void jumpping(){
        System.out.println("我還會跳");
    }
}

測驗類

public class Demo {
    public static void main(String[] args) {
        rabbit rb = new rabbit();
        rb.setName("兔子");//呼叫的就是繼承的方法
        rb.eat("草");
        rb.jumpping();//這里呼叫的就是兔兔的特有方法
        LionLo = new Lion();
        Lo.setName("獅子");
        Lo.eat("肉肉");
    }
}

運行結果

我是兔子,我可以吃草呢
我還會跳
我是獅子,我可以吃肉肉呢

總結以下幾點

繼承的關鍵字extends
子類擁有父類非 private 的屬性、方法，
子類可以擁有自己的屬性和方法，即子類可以對父類進行擴展，
子類可以用自己的方式實作父類的方法（支持重寫），
Java 的繼承是單繼承，但是可以多重繼承，單繼承就是一個子類只能繼承一個父類，多重繼承就是，例如 B 類繼承 A 類，C 類繼承 B 類，所以按照關系就是 B 類是 C 類的父類，A 類是 B 類的父類，這是 Java 繼承區別于 C++ 繼承的一個特性，
代碼的復用性升高，也就提高了類之間的耦合性（繼承的缺點，耦合度高就會造成代碼之間的聯系越緊密，代碼獨立性越差），

③多型

為什么需要多型

我們在上面的收可以看到的是繼承的缺點就是耦合性太高導致獨立性太差，那出現多型就是為了解決這個耦合性過高的問題的呀，多型可以做到多物件使用不混亂，可以讓我們的程式具有通用性，

在基礎的時候上面我們可以看到到的多型的前提條件有繼承，那我們將上面的Lion函式和Demo函式改變一下，看看最后的結果：
改變后的Lion

public class Lion extends Animal{
    public Lion() {
    }
    public Lion(String name) {
        super(name);
    }

    @Override
    //重寫父類中的eat方法
    public void eat(String s) {
    	//在呼叫父類中的方法時需要使用super關鍵字
    	super.eat(s);
        System.out.println("勇敢牛牛，不怕困難");
    }
}

Demo(測驗類)

public class Demo {
    public static void main(String[] args) {
        Animal Lo = new Lion();
        Lo.setName("獅子");
        Lo.eat("肉肉");
    }
}

運行結果

我是獅子,我可以吃肉肉呢
勇敢牛牛，不怕困難

行程已結束,退出代碼0

**注：當使用多型方式呼叫方法時，首先檢查父類中是否有該方法，如果沒有，則編譯錯誤；如果有，再去呼叫子類的同名方法，
多型的好處：可以使程式有良好的擴展，并可以對所有類的物件進行通用處理，
**

2、 類→抽象類、介面

??我們先一起看看什么是抽象類和介面

抽象類往往用來表征對問題領域進行分析、設計中得出的抽象概念，是對一系列看上去不同，但是本質上相同的具體概念的抽象，
注：一個類中如果有抽象方法(抽象方法指的是沒有具體實作的方法實作)，那么這個類必須是一個抽象類，注意，抽象類里面是不能創建物件的，

介面：Java介面是一系列方法的宣告，是一些方法特征的集合，一個介面只有方法的特征沒有方法的實作，因此這些方法可以在不同的地方被不同的類實作，而這些實作可以具有不同的行為（功能），注意：介面中也是不能創建物件，

有的小伙伴看到了上面的描述，可能會有一個疑惑，既然要一個不知道怎樣的方法，那么直接創建一個空方法體不就行了嗎？其實在使用抽象類，類的使用者創建物件的時候，就知道他必須要使用某個具體子類，而不可能誤用不完整的父類，就可以知曉使用時必須實作該方法，這就是抽象類的作用，
介面的作用就是在專案中，有一些功能，不僅僅是一個類去實作，即有很多地方有用到，大家需要統一標準，所以需要用介面，這樣大家同時實作一個介面，就能夠統一規范，在介面中只是定義了基本的方法名，具體的實作交給實作類，

抽象類和介面的區別
成員區別
??抽象類:常量；構造方法；抽象方法；非抽象方法
??介面: 常量；抽象方法
關系區別
??類與類: 單繼承
??類與介面: 實作，可多實作
??介面和介面: 繼承，可多繼承
設計理念區別
??抽象類：對類抽象，包括屬性、行為,完成的是一些共性功能的抽取
??介面：對行為抽象，主要是行為，完成的是一些特性功能的提取

3、例外

① 什么是例外

一般的例外分為運行時例外和非運行時例外，這里就將它再細分以下幾種：

例外是程式中的一些錯誤，但并不是所有的錯誤都是例外，并且錯誤有時候是可以避免的，
檢查性例外：最具代表的檢查性例外是用戶錯誤或問題引起的例外，這是程式員無法預見的，例如要打開一個不存在檔案時，一個例外就發生了，這些例外在編譯時不能被簡單地忽略，
運行時例外： 運行時例外是可能被程式員避免的例外，與檢查性例外相反，運行時例外可以在編譯時被忽略，
錯誤： 錯誤不是例外，而是脫離程式員控制的問題，錯誤在代碼中通常被忽略，例如，當堆疊溢位時，一個錯誤就發生了，它們在編譯也檢查不到的，

你能區分以下是那種例外嗎?

你的代碼少了一個分號，那么運行出來結果是提示是錯誤 java.lang.Error；如果你用System.out.println(11/0)，那么你是因為你用0做了除數，會拋出 java.lang.ArithmeticException 的例外，
例外發生的原因有很多，通常包含以下幾大類：
用戶輸入了非法資料，
要打開的檔案不存在，
網路通信時連接中斷，或者JVM記憶體溢位，
這些例外有的是因為用戶錯誤引起，有的是程式錯誤引起的，還有其它一些是因為物理錯誤引起的，-

② 怎么處理例外

在程式中的例外一般由兩種處理方式
①往外拋：不管程式報錯，直接往外拋，這種一般是Java自帶的處理例外的方式，就是不管例外，知道程式自己報錯
②捕獲例外：一般這個就是用try(){}catch(){}來捕獲例外值并拋出，我們這里主要是了解這一種處理例外的方式
下面我就用一個最常見的陣列超出長度的例外來演示一下：

正常輸出

    public static void main(String[] args) {
        int[] arr = {1,2,3};
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+"\t");
        }
    }

輸出結果

1 2 3
行程已結束,退出代碼0

例外：字串長度超過例外

方法一：往外拋

public static void main(String[] args) {
        int[] arr = {1,2,3};
        for (int i = 0; i < arr.length+1; i++) {
            System.out.print(arr[i]+"\t");
        }
        System.out.println("輸出完畢！");
    }

運行結果

1 2 3 Exception in thread “main” java.lang.ArrayIndexOutOfBoundsException: Index 3 out of bounds for length 3
行程已結束,退出代碼1

這里就可以看到例外為Index 3 out of bounds for length 3，即陣列長度超過最大長度，并且并沒有執行我們后面的輸出陳述句，直接在例外點姐結束了運行，

方法二:try/catch

public static void main(String[] args) {
        int[] arr = {1,2,3};
        try {
            for (int i = 0; i < arr.length + 1; i++) {
                System.out.print(arr[i] + "\t");
            }
        }catch (Exception e){
            System.out.println("你的陣列長度不符合要求\n例外為:"+e);
        }
        System.out.println("輸出完畢！");
    }

運行結果

1 2 3 你的陣列長度不符合要求
例外為:java.lang.ArrayIndexOutOfBoundsException: Index 3 out of bounds for length 3
輸出完畢！

行程已結束,退出代碼0

這里的就可以看到我們雖然也出現了例外，但是并不影響我們程式后面的運行，依舊將我們后面的代碼給執行下去了，

總計

在出現我們不確定是否會有出現不確定因素時，我們可以加一個捕捉例外的方法，這樣不會影響我們的代碼最終運行，比如我們陣列的長度不確定時，需要傳入字符時等一些情況，都可以加上，

三、 淺出總結

??做一個專案時，將類中的某些東西私有化，想讓人呼叫的就設定一下get/set方法，不想的就直接private私有化，在我的類中有很多和另一個類相似的，定義一個父類，將相似的地方包起來，在繼承，能夠減少代碼的冗余，當我要用的和父類不一樣時我們就重寫一下父類的方法，一樣的直接使用super呼叫就可，要是不知道怎么形容父類，就用一個抽象類去定義，當一個專案由多個人完成時，我們的每個人都不一樣，就需要定義一個標準，就是定義一個介面，為大家做一個模板，程式中總會有一些不可控硬塑，在我們可能出錯的地方就將例外加上去，把例外給拋出來，不影響整個專案的運行，這樣一整個普通的專案就做好了，
????????
附：感謝您的閱讀，這么長的一篇文章，希望對您能有所識訓呀！