導語

各位小伙伴們大家好呀，今天我們給大家分享一個我們java語言當中非常重要的一個模塊——面向物件，

一、面向物件

1.1面向物件概述

當我們接觸編程語言時，總會有人提到面向物件編程（object-orientend programming，OOP），那么什么是面向物件呢 ？相信大家剛開始寫出來的第一個程式就是helloworld，那么helloworld程式很簡單哈，就是一個輸出陳述句，那么在我們了解了面向物件編程之后，我們就要學會將我們所要做的東西把他封裝成一個物件去實作我們想要的功能，

很早很早以前的編程是面向程序的，比如實作一個算術運算1+1 = 2，通過這個簡單的演算法就可以解決問題，但是隨著時代的進步，人們不滿足現有的演算法了，因為問題越來越復雜，不是1+1那么單純了，比如一個班級的學生的資料分析，這樣就有了物件這個概念，一切事物皆物件，將現實的事物抽象出來，注意抽象這個詞是重點啊，把現實生活的事物以及關系，抽象成類，通過繼承，實作，組合的方式把萬事萬物都給容納了，實作了對現實世界的抽象和數學建模，這是一次飛躍性的進步，

那么面向物件和面向程序又有什么區別呢？這兩個概念十分的抽象，我們就舉兩個例子去理解，比如吃飯這個問題

1.你某天回家自己做飯，你的買菜，洗菜，點火，加料，炒熟，裝盤，吃飯，

2.去飯店，老板，青椒牛肉絲一份兒！你：好嘞！

看到了嗎？你去飯店，直接就能得到你想要的菜，方便！你不需要知道這個菜是怎么做的，你會吃就行，降低了我們“吃飯”的耦合性，而且如果你自己做菜，你突然不想吃這個 菜了，你想換個口味，恐怕第一種方式要麻煩許多，而第二種你只需要再喊一句：“老板，青椒牛肉絲不要了，來分魚香肉絲兒”相信百分百可以，降低了我們程式的維護性，

了解完面向物件與面向程序，面向物件的三大特征，六大原則也是我們必須去掌握的，

1.2面向物件三大特征——封裝、繼承、多型

1.2.1、封裝

關于類和物件我們之前也有分享過，不知道的小伙伴可以往前翻一翻，這里我們就簡單回顧一下類：

類（class）是構造物件的模板或藍圖，我們可以將類想象成制作菜品的秘方，將物件想象為菜品，由類構造物件的程序 稱為創建類的實體，

封裝的定義及原則：將類的某些資訊隱藏在類內部，（所以封裝也被稱為資料隱藏）不允許外部程式直接訪問，而是通過該類提供的方法來實作對隱藏資訊的操作和訪問，

封裝的好處：通過方法來控制成員變數的操作，提高了代碼的安全性
把代碼用方法進行封裝，提高了代碼的復用性，

封裝就像我們吧做菜的步驟交給了做菜師傅，我們需要什么，就直接點什么，不需要我們去做任何東西，

關于封裝的一些細節性問題，我們前面也有分享過，各位小伙伴也可以往前翻一翻哦！

1.2.2、繼承

在分享繼承之前，我們還分享兩個常見的類之間的關系：依賴和聚合

依賴即（uses-a）的關系，是一種最明顯的、最常見的關系，如果一個類的方法使用或操縱另一個類的物件，我們就說一個類依賴于另一個類，例如我們的選單類，和我們師傅炒菜類，師傅要想炒菜，師傅類就需要選單類是因為師傅的物件他是需要查看選單物件來查看他要怎么炒菜，在我們的開發當中，應當盡可能的去減少依賴，減少類與類之間的耦合，這里的關鍵就是如果類A不知道類B的存在，那么他就不會去關心 類B的任何改變（也就是B的改變不會導致A產生任何bug）；

聚合即是（has a） 的關系，比如說我的A類中包含了一些B類的物件，這兩個類就存在這聚合關系，

到了我們的繼承，他就是一個（is-a）的關系，表示一個更特殊的類與一更一般的類之間的關系，比如我的選單類和炒菜類在我們的更特殊的類炒菜類中就包含了一些用于優先處理的特殊方法，例如點火，等等，而菜品量的多少，順序方法都是繼承自選單類的，

那么繼承就是可以使得子類具有父類的屬性和方法，還可以在子類中重新定義，以及追加屬性和方法，

那么在java當中，繼承如何去實作呢？

在java當中，繼承我們通過關鍵字extends去實作兩個類之間的繼承，extends表示正在構造的新類派生于一個已存在的類，他的格式是：

class子類extends父類{}； 例如：class Dog extends Animal{}；，

繼承給我們帶來的好處是：繼承可以讓類與類之間產生關系，子父類關系，產生子父類后，子類可以使用父類中非私有的成員；

例如我們這里的代碼：

public class Fu {
    public void show() {
        System.out.println("show方法被呼叫");
    }
}
public class Zi extends Fu {
    public void method() {
        System.out.println("method方法被呼叫");
    }
}
public class Demo {
    public static void main(String[] args) {
        //創建物件，呼叫方法
        Fu f = new Fu();
        f.show();

        Zi z = new Zi();
        z.method();
        z.show();
    }
}

輸出結果

show方法被呼叫
method方法被呼叫
show方法被呼叫

那么我們很明顯的發現，我們子類中沒有得show方法居然神奇的被呼叫了，這就是繼承，

繼承注意點：
1、子類不是父類的子集，子類一般比父類包含更多的資料域和方法，
2、 父類中的 private 資料域在子類中是不可見的，因此在子類中不能直接使用它們，
3、繼承是為"is-a"的關系建模的，父類和其子類間必須存在"is-a"的關系，否則不能用繼承，
4、但也并不是所有"is-a"的關系都應該用繼承，例如，正方形是一個矩形，但不能讓 Square 類來繼承 Rectangle 類，因為正方形不能從矩形擴展得到任何東西，正確的繼承關系是 Square 類繼承 Shape 類
5、Java 只允許單一繼承（即一個子類只能有一個直接父類，可以有多重繼承），C++ 可以多繼承（即一個子類有多個直接父類），

繼承中一個小問題：方法重寫

方法重寫
1.方法重寫概念
子類出現了和父類一模一樣的方法宣告（方法名一樣，引數串列也必須一樣）
2.方法重寫的應用場景
當子類需要父類的功能，而功能主體子類有自己特有內容時，可以重寫父類中的方法，這樣，既沿襲了父類的功能，又定義了子類特有的內容，
3.@override注解
用來檢測當前的方法，是否是重寫的方法，起到（校驗）的作用
方法重寫的注意事項
1.私有方法不能被重寫（父類私有成員子類是不能繼承的）
2.子類方法訪問權限不能更低（public >默認 >私有）
示例代碼

 public class Fu {
    private void show() {
        System.out.println("Fu中show()方法被呼叫");
    }

    void method() {
        System.out.println("Fu中method()方法被呼叫");
    }
}

public class Zi extends Fu {

    /* 編譯【出錯】，子類不能重寫父類私有的方法*/
    @Override
    private void show() {
        System.out.println("Zi中show()方法被呼叫");
    }
   
    /* 編譯【出錯】，子類重寫父類方法的時候，訪問權限需要大于等于父類 */
    @Override
    private void method() {
        System.out.println("Zi中method()方法被呼叫");
    }

    /* 編譯【通過】，子類重寫父類方法的時候，訪問權限需要大于等于父類 */
    @Override
    public void method() {
        System.out.println("Zi中method()方法被呼叫");
    }
}

1.2.3、多型

多型，是面向物件三大特征之一，
多型，即是同一個物件，在不同時刻表現出來的不同形態，多型就是同一個介面，使用不同的實體而執行不同操作，

在現實生活中，例如學生是人的一種，但是他的一個具體實作李四他既是學生，也是人，老師也是如此，老師的具體實作物件李明華他既是老師同時又是一個人，
多型的前提是要有繼承或實作關系、 要有方法的重寫、要有父類參考指向子類物件：Parent p = new Child();

多型中成員的特點
多型成員變數：編譯運行看左邊
Fu f=new Zi();

System.out.println(f.num);//f是Fu中的值，只能取到父中的值

多型成員方法：編譯看左邊，運行看右邊

Fu f1=new Zi();

System.out.println(f1.show());//f1的表面型別是Fu,但實際型別是Zi,所以呼叫的是重寫后的方法，為什么成員方法和成員變數不一樣呢？就是因為成員方法有重寫，

多型的好處和弊端
好處
提高程式的擴展性，定義方法的時候，使用父型別作為引數，再使用的時候，使用具體的子型別參與操作
弊端
不能使用子類的特有成員

多型中的轉型
1.向上轉型
從子到父：父類參考指向子類物件就是向上轉型
Animal a = new Cat();
2.向下轉型
從父到子：父類參考轉為子類物件
格式：子型別 物件名 = （子型別）父類參考;
Cat c = (Cat )a;
示例代碼

  public class Test {
    public static void main(String[] args) {
      show(new Cat());  // 以 Cat 物件呼叫 show 方法
      show(new Dog());  // 以 Dog 物件呼叫 show 方法
                
      Animal a = new Cat();  // 向上轉型  
      a.eat();               // 呼叫的是 Cat 的 eat
      Cat c = (Cat)a;        // 向下轉型  
      c.work();        // 呼叫的是 Cat 的 work
  }  
            
    public static void show(Animal a)  {
      a.eat();  
        // 型別判斷
        if (a instanceof Cat)  {  // 貓做的事情 
            Cat c = (Cat)a;  
            c.work();  
        } else if (a instanceof Dog) { // 狗做的事情 
            Dog c = (Dog)a;  
            c.work();  
        }  
    }  
}
 
abstract class Animal {  
    abstract void eat();  
}  
  
class Cat extends Animal {  
    public void eat() {  
        System.out.println("吃魚");  
    }  
    public void work() {  
        System.out.println("抓老鼠");  
    }  
}  
  
class Dog extends Animal {  
    public void eat() {  
        System.out.println("吃骨頭");  
    }  
    public void work() {  
        System.out.println("看家");  
    }  
}
        輸出結果
            吃魚
抓老鼠
吃骨頭
看家
吃魚
抓老鼠

這邊給大家看一個貓狗案例幫助大家更深刻的理解多型

???????

動物類：

public class Animal {
    private String name;
    private int age;

    public Animal() {
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void eat() {
        System.out.println("動物吃東西");
    }
}

貓類：

public class Cat extends Animal {

    public Cat() {
    }

    public Cat(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("貓吃魚");
    }
}

測驗類：

public class AnimalDemo {
    public static void main(String[] args) {
        //創建貓類物件進行測驗
        Animal a = new Cat();
        a.setName("加菲");
        a.setAge(5);
        System.out.println(a.getName() + "," + a.getAge());
        a.eat();

        a = new Cat("加菲", 5);
        System.out.println(a.getName() + "," + a.getAge());
        a.eat();
    }
}

總結：

面向物件的三大特征封裝，繼承，多型我們就先分享的這里，后續會分享更多的綜合案例以及細節內容，歡迎大家的持續關注，
???????