面向->找；物件->東西

面向物件程式設計就是找東西來程式設計

面向物件的三大基本特徵：封裝、繼承、多型

• 面向物件(Object Oriented)：強調解決問題的主體，強調誰來解決這個問題，強調的是資料，強調的是物件，強調的是誰擁有資料和操作資料的權力。
• 在java中，必須先設計類，才能獲得物件
• 類（設計圖）:是物件共同特徵的描述;
• 物件:真實存在的具體例項，事物的具體體現

1.定義類

//定義類
public class 類名{
    1、成員變數（代表屬性，一般是名詞）
    2、成員方法（代表行為，一般是動詞）
    3、構造器
    4、程式碼塊
    5、內部類
}
//得到類的物件
類名 物件名 = new 類名();
//物件的使用
物件名.成員變數
物件名.成員方法
 

成員變數的完美定義格式是 修飾符 資料型別 變數名稱 = 初始化值 一般無需指定初始化值，存在預設值

public class Car {
    //屬性（成員變數）
    String name;
    double price;

    //行為
    public void start() {
        System.out.println(name + "車啟動了");
    }

    public void run() {
        System.out.println(name + "車開得很快");
    }

    public void message(){
        System.out.println(name + "車價格為" + price);
    }
}
 

public class Test {
    public static void main(String[] args) {
        //自己設計物件並使用
        //類名 物件名 = new 類名();
        Car c = new Car();
        c.message();
        c.name = "賓士";
        c.price = 100;
        c.start();
        c.run();
    }
}

執行結果

注意事項

• 類名不能用關鍵字
• 一個程式碼檔案中可以定義多個類，但是隻能一個類是public修飾的，public修飾的類名必須是Java程式碼的檔名稱
• 類中可以定義的五大成分:成員變數Field，成員方法Method，構造器Constructor，內部類，程式碼塊

2.物件記憶體圖

public class Test {
    public static void main(String[] args) {
        //自己設計物件並使用
        //類名 物件名 = new 類名();
        Car c = new Car();
        c.name = "賓士";
        c.price = 100;
        c.message();

        Car c0 = new Car();
        c0.name = "寶馬";
        c0.price = 200;
        c0.message();
    }
}

物件放在堆記憶體中
c變數名中儲存的是物件再堆記憶體中的地址
成員變數的資料存放在堆記憶體中

3.垃圾回收

• 當堆記憶體中的類物件或者陣列物件，沒有被任何變數引用(指向)時，就會被判定為記憶體中的垃圾。
• Java存在自動垃圾回收器，會定期進行清理。

4.構造器

構造器的作用

• 用於初始化一個類的物件，返回物件的地址。

分類

• 無參構造器(預設存在的):初始化物件時，成員變數的資料均採用預設值
• 有參構造器:在初始化物件的時候，同時可以為物件進行賦值

定義格式

修飾符 類名(形參列表){
  ...
}

注意事項

• 任何類定義出來，預設就帶了無參構造器
• 一旦定義了有參構造器，無參構造器就沒有了，此時需要自己寫一個無參構造器

5.this關鍵字

出現在成員方法、構造器中代表當前物件的地址，用於訪問當前物件的成員變數、成員方法

public class Student {
    String name;
    int age;

    //構造器中使用this關鍵字
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    //成員方法中使用this關鍵字
    public void study(String name) {
        System.out.println(this.name + "和" + name + "在學習");
    }
}

6.封裝

隱藏實現細節，暴露出合適的訪問方式（合理隱藏，合理暴露）
封裝的實現步驟

• 一般對成員變數使用private(私有)關鍵字修飾進行隱藏，private修飾後該成員變數就只能在當前類中訪問。
• 通過getter和setter方法暴露訪問
  好處：
• 加強了程式程式碼的安全性
• 適當的封裝可以提升開發效率，同時讓程式更容易理解與維護

7.static關鍵字

static是靜態的意思，可以修飾成員變數，表示該成員變數只在記憶體中儲存一份，可以被共享訪問、修改
static修飾成員變數，成員變數可以分為兩類

• 靜態成員變數（有static修飾，屬於類，記憶體中載入一次）
• 訪問方式：類名.靜態成員變數、物件名.靜態成員變數(不推薦使用)
• 例項成員變數（無static修飾，存在於每個物件中）
• 訪問方式：物件名.變數名
  

static修飾成員方法，成員方法分為兩類

• 靜態成員方法（有static修飾，屬於類，修飾通用功能）
• 訪問方式：類名.靜態成員方法、物件名.靜態成員方法(不推薦使用)
• 例項成員方法（無static修飾，屬於物件，表示物件自己的行為）
• 訪問方式：物件名.方法名
  

注意事項：

• 靜態方法只能訪問靜態成員，不可以直接訪問例項成員。
• 例項方法可以訪問靜態成員，也可以訪問例項成員。
• 靜態方法中不能出現this關鍵字

7.1工具類

對於一些應用程式中多次需要用到的功能，可以將這些功能封裝成靜態方法，放在一個類中，這就是工具類。
工具類的作用：

• 方便呼叫
• 提高了程式碼複用

工具類原理和延申

• 一次編寫，處處可用
• 建議將工具類的構造器私有，不讓工具類在外構造物件

//驗證碼工具類
public class VerifyCode {
    public static String createCode(int n){
        String code = "0123456789qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM";
        String codeResult = "";
        Random r = new Random();
        for (int i = 0; i < n; i++) {
            int index = r.nextInt(code.length());
            codeResult += code.charAt(index);
        }
        return codeResult;
    }
}

8.程式碼塊

程式碼塊是類的5大成分之一，定義在類中方法外
在Java類下，使用{}括起來的程式碼被稱為程式碼塊

靜態程式碼塊

• 格式：static{}
• 特點：需要通過static關鍵字修飾，隨著類的載入而載入，並且自動觸發，只執行一次
• 使用場景：在類載入的時候做一些靜態資料初始化操作，以便後續使用

構造程式碼塊

• 格式：{}
• 特點：每次建立物件，呼叫構造器執行時，都會執行該程式碼塊中的程式碼，並且在構造器執行前執行。
• 使用場景：初始化例項資源。

//靜態程式碼塊例項
public class Demo {

    public static String name;
    //與類一起載入，自動觸發一次，優先執行
    static{
        System.out.println("==靜態程式碼塊觸發執行==");
        name = "張三";
    }

    public static void main(String[] args) {
        //可以在程式載入時進行靜態資料的初始化操作
        System.out.println("===main方法執行輸出===");
        System.out.println(name);
    }
}

輸出結果

public class Demo {

    /*
        構造程式碼塊，屬於物件，與物件一起載入，自動觸發執行
     */
    {
        System.out.println("==構造程式碼塊觸發執行一次==");
    }

    public Demo(){
        System.out.println("==構造器被觸發執行==");
    }
    public static void main(String[] args) {
        new Demo();
    }
}

輸出結果

9.單例設計模式

設計模式是一套被前人反覆使用，多數人知曉、經過分類編目的程式碼設計經驗的總結，後者可以直接拿來解決問題
單例模式

• 可以保證系統中，應用該模式的這個類永遠只有一個例項，即一個類永遠只能建立一個物件。

單例的場景和作用

• 例如工作管理員物件我們只需要一個就可以解決問題了，這樣可以節省記憶體空間。

餓漢單例設計模式

• 在用類獲取物件的時候，物件已經提前為你建立好了。

設計步驟：

• 定義一個類，把構造器私有。
• 定義一個靜態變數儲存一個物件。

//餓漢單例模式例項
public class SingleInstance {
    /*
    定義靜態變數儲存一個物件
     */
    public static SingleInstance si = new SingleInstance();

    /*
    將構造器私有化
     */
    private SingleInstance(){}
}

懶漢單例設計模式

• 在真正需要該物件的時候，才去建立一個物件（延遲載入物件）

設計步驟

• 定義一個類，把構造器私有。
• 定義一個靜態變數儲存一個物件。
• 提供一個返回單例物件的方法。

//懶漢單例例項
public class SingleInstance {
    /*
    定義靜態變數儲存一個物件
     */
    private static SingleInstance si;

    /*
    將構造器私有化
     */
    private SingleInstance(){}

    /*
    提供一個方法返回一個單例物件
     */
    public static SingleInstance getInstance(){
        if (si == null){
            si = new SingleInstance();
        }
        return si;
    }
}

10.繼承

• 繼承是子類與父類之間的一種關係
• 多個類繼承單獨的某個類，多個類就使用單獨的這個類的屬性和行為了
• 多個類稱為子類（派生類），單獨的這個類稱為父類（基類或超類）
• 使用繼承的好處：提高程式碼的複用，減少程式碼冗餘，增強類的功能擴充套件性

繼承的格式

• 繼承的關鍵字extends
• public class 子類名稱 extends 父類名稱 {}

繼承設計規範

• 子類們相同的特徵(共性屬性，共性方法)放在父類中定義，子類獨有的屬性和行為應定義在子類裡面
• 如果子類的獨有屬性，行為定義在父類中，會導致其它子類也會得到這些屬性和行為，這不符合面向物件的邏輯

繼承的特點

• 子類可以繼承父類的屬性和行為，但是子類不能繼承父類的構造器
• java是單繼承模式：一個類只能繼承一個直接父類
• java不支援多繼承，但是支援多層繼承
• java中所有的類都是Object的子類

在子類方法中訪問成員（成員變數、成員方法）滿足：就近原則

• 先子類區域性範圍找
• 然後子類成員範圍找
• 然後父類成員範圍找，如果父類範圍還沒找到就報錯

方法重寫

• 在繼承體系中，子類出現了和父類一摸一樣的方法宣告，我們就稱子類這個方法是重寫的方法。

方法重寫的應用場景

• 當子類需要父類的功能，但父類的該功能不完全滿足自己的需求時

@Override重寫註釋

• @Override放在重寫後的方法上，作為重寫是否正確的校驗註解
• 加上該註解後如果重寫錯誤，編譯階段會出現錯誤提示
• 建議重寫方法都加@Override註解，程式碼安全，優雅

方法重寫注意事項和要求

• 重寫方法名稱，形參列表必須與被重寫方法的名稱和引數列表一致
• 私有方法不能被重寫
• 子類重寫父類方法時，訪問許可權必須大於或者等於父類
• 子類不能重寫父類的靜態方法(因為子類不能繼承父類的靜態方法)
• 子類構造器的第一行語句預設都是super()，不寫也存在

繼承後子類構造器的特點

• 子類中所有的構造器預設都會先訪問父類中無參的構造器，再執行自己
• 子類在初始化的時候，有可能會使用到父類中的資料，如果父類沒有完成初始化，子類將無法使用父類的資料
• 子類初始化之前，一定要呼叫父類構造器先完成父類資料空間的初始化

子類構造器訪問父類有參構造器

• super呼叫父類有參構造器能初始化繼承自父類的資料
• 父類中如果只有有參構造器，子類中會報錯，因為子類預設是呼叫父類無參構造器，可以通過在子類構造器中書寫super(...)手動呼叫父類的有參構造器

this和super關鍵字

• this代表本類物件的引用;super代表父類儲存空間的標識。
• this/super.成員變數(訪問本類/父類成員變數)
• this/super.成員方法(...)(訪問本類/父類成員方法)
• this/super(...)(訪問本類/父類構造器)
• 子類通過this(...)去呼叫本類的其他構造器，本類其他構造器會通過super去手動呼叫父類的構造器，最終還是會呼叫父類構造器的
• this(...)和super(...)都只能放在構造器的第一行，所以二者不能存在一個構造器中