認識類和物件

1.類、物件是什么？

類在Java中，也叫做自定義型別，
類就是一類物件的統稱，物件就是這一類具體化的一個個例
可以把類想象成一個模板，把物件想象成物體，比如：建房子，會有圖紙，然后根據圖紙去建房子，一張圖紙可建很多同樣的房子，而圖紙就是"類"，建的房子就是"物體"，通過一個類可以產生多個物件

2.什么是面向物件？

之前在初始Java篇簡單講述了Java的面向物件性，對比了面向物件和面向程序的不同
這里就不多說了 ：https://blog.csdn.net/m0_47988201/article/details/118996045?spm=1001.2014.3001.5501.
面向物件是思考問題的一種方式，是一種思想
總的來說，面向物件就是用代碼(類)，來描述客觀世界事物的一種方式，一個類主要包含一個事物的屬性和行為
面向物件的好處是：將復雜的事情簡單化，只要面對一個物件就行
之后，會從這三點進行深入學習：找物件—創物件—使用物件

3.一個物件的產生程序是？

①給物件分配記憶體；
②呼叫合適的構造方法

🔺OOP語言的三大特征？

OOP：面向物件編程
三大特性：繼承、封裝、多型

類和物件的實體化

類的定義：

在Java中定義類，需要 class 關鍵字

類中包含的內容稱為類的成員；屬性主要是用來描述類的，稱之為類的成員屬性或者類成員變數；方法主要說明類具有哪些功能，稱為類的成員方法
類的成員包括：欄位、方法、代碼塊、內部類和介面等，此處只介紹前三個

語法格式：

class ClassName {
field ； …// 欄位(成員屬性) / 成員變數
method；// 行為 / 成員方法
}

舉例：

class Person{
    //欄位
	String name;
	int age;
    //行為
    public void eat(){
        System.out.println("eat()!");
    }
    public void sleep(){
        System.out.println("sleep()!");
    }
}

注意：

• 類名使用大駝峰命名法
• 欄位 / 成員變數定義在方法外面、類的里面
• 實體成員變數存放在物件里
• Java中訪問修飾限定符：
  private：私有的；public：共有的；protected：受保護的；什么都不寫：默認權限 / 包訪問權限
• 一般一個檔案當中只定義一個類
• main方法所在的類必須要使用public修飾
• public修飾的類必須要和檔案名相同

實體化物件：

在Java中，通過關鍵字new，配合類名可以實體化一個物件
用型別別創建物件的程序，稱為類的實體化

//實體化物件
Person person1 = new Person();
Person person2 = new Person();
Person person3 = new Person();
Person person4 = new Person();

①如何訪問物件中的實體成員變數？

通過物件的參考即可訪問： 物件的參考 . 成員變數

public static void main(String[] args) {
	//實體化一個物件
	Person person = new Person();
	//訪問物件中的實體成員變數
	//通過物件的參考
	System.out.println(person.age);
	System.out.println(person.name);
}

②如何訪問靜態的資料成員？

類名 . 靜態成員變數

public static void main(String[] args) {
	Person per = new Person();
	System.out.println(Person.size);
}

注意：

• 同一個類可以創建多個實體
• new 關鍵字用于創建一個物件的實體
• 實體成員變數，沒有初始化，默認值為對應的 0 值
  參考型別默認為null，簡單型別默認為 0
  特殊：char型別—"\u0000"；boolean型別—false
• 使用 . 來訪問物件中的屬性和方法
• 靜態成員變數不屬于物件，屬于類，且只有一份

方法：

實體成員方法：

public void eat(){
    System.out.println("eat()!");
}
public void sleep(){
    System.out.println("sleep()!");
}

靜態成員方法

靜態成員方法
public static func(){
	System.out.println("static::func()!");
}

🔺構造方法

構造方法的方法名和類名相同，且沒有回傳值
構造方法作用： 實體化一個物件

class Person{
    private String name;
    private int age;

    public  Person(){
        System.out.println("Person!");
    }
	public Person(String name,int age){
        this.name = name;
        this.age = age;
        System.out.println("Person<String,int>");
    }
public class Test {
    public static void main(String[] args) {
        //寫這行代碼的時候，就會呼叫構造方法
        Person person1 = new Person();
        Person person2 = new Person("Huahua",18);
	 }
}

注意：

• 當沒有提供構造方法的時候，編譯器會自動提供一個沒有引數的構造方法
• 若類中定義了構造方法，則默認的無參構造不再產生
• 什么時候呼叫構造方法取決于new物件時是否給引數
• 構造方法支持多載，規則和普通方法一致

①訪問實體成員方法

通過物件的參考進行訪問：物件的參考 . 實體成員方法

public static void main(String[] args) {
	Person per = new Person();
	per.eat();
	per.sleep();
}

②訪問靜態成員方法

類名 . 靜態成員方法

public static void main(String[] args) {
	Person.func();
}

static 關鍵字

1.修飾屬性：

Java靜態屬性和類相似，和具體的實體無關
即：同一個類的不同實體共用同一個靜態屬性

class Test{
    public int a = 0;
    public static int count;
}

靜態成員變數只有一份：

public static void main(String[] args) {
    Test T = new Test();
    T.a++;
    Test.count++;
    System.out.println(T.a+" "+Test.count);
}

輸出結果：

分析原因：

2.修飾方法：

在方法前應用 ststic 關鍵字，就把該方法稱為靜態方法

靜態成員方法
public static func(){
	System.out.println("static::func()!");
}

注意：

1. 靜態方法內部不能訪問非靜態成員
2. 靜態方法屬于類，不屬于類的物件
3. 可以直接呼叫靜態方法，而無需創建類的實體
4. 靜態方法可以更改靜態資料成員的值
5. 靜態方法中不能呼叫任何非靜態方法

this 關鍵字

this 表示當前物件的參考

this 使用方法：

1. this . 屬性名稱 訪問屬性，指的是訪問類中的成員變數，用來區分成員變數和區域變數
2. this . 方法名稱 用來訪問本類的成員方法
3. this()；訪問本類的構造方法，()中可以有引數的 如果有引數 就是呼叫指定的有參構造

舉例1

訪問屬性 和 訪問方法

class  Person{
    private String name;
    private int age;
    //呼叫屬性
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    //呼叫方法
    public void eat{
    	System.out.println(this.getName());
    }
    public String getName{
    	return name;
    }
}

舉例2

訪問構造方法

class Person{
    private String name;
    private int age;

    public  Person(){
    	// 訪問構造方法
        this("Huahua",3);
        System.out.println("Person!");
    }

    public Person(String name,int age){
        this.name = name;
        this.age = age;
        System.out.println("Person<String,int>");
    }
}

注意事項：

• this() 不能使用在普通方法中 只能寫在構造方法中
• this() 必須是構造方法中的第一條陳述句

getter 和 setter方法

當我們使用 private 來修飾欄位的時候，就無法直接使用這個欄位了，這就需要使用 getter 和 setter 方法

class Person{
    private String name;
    //setter方法給設施變數的值
    public String getName{
       	return name;
    }
    public void setName(String name){
        this.name = name;
    }
}

注意事項：

• getName 即為 getter 方法，表示獲取這個成員的值
• setName 即為 setter 方法，表示設定這個成員的值
• 不是所有的欄位都一定要提供 setter / getter 方法，而是要根據實際情況決定提供哪種方法
• 當 setter 方法的形參名字和類中的成員屬性的名字一樣時，如果不適用 this，相當于自賦值，this表示當前實體的參考
• 在IDEA中，可以使用Alt+F12，快速生成 setter / getter 方法

封裝

封裝：用 private 來修飾屬性 / 方法
類和物件階段，主要研究的就是封裝特性

class Student{
    private String name;
    public int age;
    public void func1(){
        System.out.println("func1()");
    }
}

如果一個屬性 / 方法被 private 修飾之后，限定只能在類當中來使用

封裝的實作步驟：

1. 修改屬性的可見性——設為private
2. 創建getter / setter方法——用于屬性的讀寫
3. 在getter / setter方法中加入屬性控制陳述句——對屬性值的合法性進行判斷

舉例：

class Student{
    //成員變數私有化
    private int age;
    //setter方法給設施變數的值
    public void setAge(int age){
        if(age < 0){
            System.out.println("年齡無效！");
        }
        else{
            this.age = age;
        }
    }
    //提供一個公開的介面
    //使用getter方法獲取賦值
    public int getAge(){
        return age;
    }
}
public class Test {
    public static void main(String[] args) {
        Student student = new Student();
        //檢驗
        student.setAge(-10);
        System.out.println(student.getAge());
    }
}

輸出結果：

Java中的訪問修飾符：

封裝的作用：

• 物件的資料封裝特性，提高了程式的可復用性和可維護性，降低了程式員保持資料與操作內容的負擔
• 物件的資料封裝特性還可以把物件的私有資料和公共資料分離開，保護了私有資料，減少了可能的模塊間干擾，達到降低程式復雜性、提高可控性的目的

建議：以后在設計類的時候，無特殊要求，所有的屬性雖好都設定為私有的private ，一定要體現封裝

代碼塊

使用 { } 定義的一段代碼稱為代碼塊
重點掌握代碼塊執行的先后順序

分為四種：

普通代碼塊：在方法或陳述句中出現的{ }就稱為普通代碼塊
實體代碼塊 (構造代碼塊)
靜態代碼塊
同步代碼塊

實體代碼塊：

定義在類中且沒有加static關鍵字的代碼塊
如果存在多個構造代碼塊，執行順序由他們在代碼中出現的次序決定，先出現先執行
特性：

{
 System.out.println("實體代碼塊......");
}

注意事項：

• 實體代碼塊優先于構造方法執行，因為編譯完成后，編譯器會將實體代碼塊中的代碼拷貝到每個構造方法第一條陳述句前
• 實體代碼塊只有在創建物件時才會執行

靜態代碼塊：

static {
 System.out.println("靜態代碼塊......");
}

注意事項：

• 靜態代碼塊不能存在于任何方法體內
• 靜態代碼塊不能直接訪問實體變數和實體方法，需要通過類的實體物件來訪問
• 靜態代碼塊不管生成多少個物件，其只會執行一次
• 靜態成員變數是類的屬性，因此是在JVM加載類時開辟空間并初始化的
• 如果一個類中包含多個靜態代碼塊，在編譯代碼時，編譯器會按照定義的先后次序依次合并，最終放在生成的<>方法中，該方法在類加載時呼叫，并且只呼叫一次

靜態 / 實體代碼塊異同點

相同點： 都是JVM加載類后且在建構式執行之前執行，在類中可定義多個，一般在代碼塊中對一些static變數進行賦值
不同點： 靜態代碼塊在非靜態代碼塊之前執行，靜態代碼塊只在第一次 new 時執行一次，之后不在執行，而非靜態代碼塊每new一次就執行一次

本篇內容有些多，哪里有什么問題歡迎大家指正~