目錄

1.類和物件

1.1 概念

1.2 類的定義

1.3 物件的使用

2. 封裝

2.1 封裝思想

2.2 private 和 this

3. 繼承

3.1 繼承思想

3.2 方法重寫

3.3 Java繼承的注意事項：

4. 多型

4.1 多型思想

4.2 多型中的轉型

如何理解面向物件？

簡單的說就是把事物和操作事物的方法匯集到一起，形成一個相互依賴的整體，

下面我們來了解面向物件的基礎知識

1.類和物件

1.1 概念

物件：客觀存在的事物都是物件，比如一只貓，一只狗

類：對事物的一種描述，比如貓睡覺，貓抓老鼠

類的組成：

屬性：指事物的特征，例如：電腦（品牌、價格）

行為：指事物能執行的操作，例如，電腦使用（看電影、打游戲）

1.2 類的定義

類的定義步驟：

①定義類

②撰寫類的成員變數

③撰寫類的成員方法

示例代碼：

public class Phone {
    //成員變數
    String brand;
    int price;

    //成員方法
    public void call() {
        System.out.println("打電話");
    }

    public void sendMessage() {
        System.out.println("發短信");
    }
}

1.3 物件的使用

創建物件的格式：

類名 物件名 = new 類名();
呼叫成員的格式：

物件名.成員變數

物件名.成員方法();

示例代碼：

public class PhoneDemo {
    public static void main(String[] args) {
        //創建物件
        Phone p = new Phone();

        //使用成員變數
        p.brand = "小米";
        p.price = 2999;

        System.out.println(p.brand);
        System.out.println(p.price);

        //使用成員方法
        p.call();
        p.sendMessage();
    }
}

2. 封裝

2.1 封裝思想

概述：封裝是面向物件三大特征之一，是面向物件編程語言對客觀世界的模擬，客觀世界里成員變數都是隱藏在物件內部的，外界是無法直接操作的

原則：將類的某些資訊隱藏在類內部，不允許外部程式直接訪問，而是通過該類提供的方法來實作對隱藏資訊的操作和訪問成員變數private，提供對應的getXxx()/setXxx()方法

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

使用封裝前，需要先了解一些修飾符

2.2 private 和 this

private，意思為私有的，它是用來修飾成員變數和成員方法的

this，修飾的變數用于指代成員變數，其主要作用是（區磁區域變數和成員變數的重名問題）

方法的形參如果與成員變數同名，不帶this修飾的變數指的是形參，而不是成員變數

方法的形參沒有與成員變數同名，不帶this修飾的變數指的是成員變數

從單詞意思上就知道被private修飾的成員，只能在本類進行訪問

那么針對private修飾的成員變數，如果需要被其他類使用，則提供相應的操作：

1）提供“get變數名()”方法，用于獲取成員變數的值，方法用public修飾

2）提供“set變數名(引數)”方法，用于設定成員變數的值，方法用public修飾

示例代碼：

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

    提供get/set方法
    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 show() {
        System.out.println(name+","+age);
    }

public class Test {
    public static void main(String[] args) {
        //創建物件
        Animal a = new Animal();
        //給成員變數賦值
        a.setName("喵喵");
        a.setAge(20);
        //呼叫show方法
        a.show();
    }
}

運行結果：

3. 繼承

3.1 繼承思想

繼承是什么？

一個類（子類）擁有另一個類（父類）的所有功能，不需要撰寫原來的類，還可以對功能拓展

繼承的利與弊：

好處：提高了代碼的復用性，提高了代碼的維護性

弊端：削弱了子類的獨立性，父類變化子類也跟著變化

子類默認訪問父類的無參構造方法，但也可以通過super關鍵字呼叫有參的構造方法

下面我們通過代碼了解子類繼承的構造方法：

1.創建一個Animal類，有屬性name和age，提供有參和無參的構造方法

public class Animal {
    String name;
    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;
    }
}

2.創建一個Cat類，并繼承Animal類，宣告方法catMouse

public class Cat extends Animal{
    public Cat(){
    }
    public Cat(String name, int age) {
        super(name, age);
    }
    public void catMouse(){
        System.out.println("貓抓老鼠");
    }
}

3.創建一個測驗類Test

public class Test {
    public static void main(String[] args) {
        Cat c1 = new Cat();  //創建物件c1，使用無參構造方法
        c1.setName("喵喵");
        c1.setAge(20);
        System.out.println(c1.getName()+" "+c1.getAge());

        Cat c2 = new Cat("咪咪",15);   //創建新的物件c2,使用有參構造方法
        System.out.println(c2.getName()+" "+c2.getAge());

        c1.catMouse();  //呼叫方法
    }
}

4.運行結果

3.2 方法重寫

繼承還有一個重要內容，就是方法重寫

方法重寫就是子類和父類的方法名一樣，引數串列也一樣

為什么要進行方法重寫：

當子類需要父類的功能，而功能主體子類有自己特有內容時，可以重寫父類中的方法，這樣，即沿襲了父類的功能，又定義了子類特有的內容

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()方法被呼叫");
    }
}

public class Test {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.method();
    }
}

運行結果：

3.3 Java繼承的注意事項：

1） Java中類只支持單繼承，不支持多繼承
錯誤范例：class A extends B, C { }
2）Java中類支持多層繼承

4. 多型

4.1 多型思想

多型就是同一個物件，在不同時刻表現出來的不同形態

多型的前提：

1.要有繼承或實作關系

2.要有方法的重寫

3.要有父類參考指向子類物件

多型的利弊：

好處：提高了程式的擴展性

弊端：不能使用子類的特有成員

4.2 多型中的轉型

向上轉型：父類 物件名 = new 子類

向下轉型：子型別 物件名 = (子型別)父類參考

舉例說明：

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

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

    public void playGame() {
        System.out.println("貓捉迷藏");
    }
}

public class Test {
    public static void main(String[] args) {
        //多型
        //向上轉型
        Animal a = new Cat();
        a.eat();
        
        //向下轉型
        Cat c = (Cat)a;
        c.eat();
        c.playGame();
    }
}

運行結果：

總結：面向物件的三大基本特征介紹就完畢了，但面向物件不止這些特征，后續我會發布新的內容，請持續關注！！！