Java - 類和對象

認識類和對象

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	√
public	√	√	√	√
protected	√	√	√
預設	√	√

封裝的作用：

• 對象的資料封裝特性，提高了程式的可複用性和可維護性，降低了程式員保持資料與操作内容的負擔
• 對象的資料封裝特性還可以把對象的私有資料和公共資料分離開，保護了私有資料，減少了可能的子產品間幹擾，達到降低程式複雜性、提高可控性的目的

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

代碼塊

使用 { } 定義的一段代碼稱為代碼塊

重點掌握代碼塊執行的先後順序

分為四種：

普通代碼塊：在方法或語句中出現的{ }就稱為普通代碼塊

執行個體代碼塊 (構造代碼塊)

靜态代碼塊

同步代碼塊

執行個體代碼塊：

定義在類中且沒有加static關鍵字的代碼塊

如果存在多個構造代碼塊，執行順序由他們在代碼中出現的次序決定，先出現先執行

特性：

{
 System.out.println("執行個體代碼塊......");
}
           

注意事項：

• 執行個體代碼塊優先于構造方法執行，因為編譯完成後，編譯器會将執行個體代碼塊中的代碼拷貝到每個構造方法第一條語句前
• 執行個體代碼塊隻有在建立對象時才會執行

靜态代碼塊：

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

注意事項：

• 靜态代碼塊不能存在于任何方法體内
• 靜态代碼塊不能直接通路執行個體變量和執行個體方法，需要通過類的執行個體對象來通路
• 靜态代碼塊不管生成多少個對象，其隻會執行一次
• 靜态成員變量是類的屬性，是以是在JVM加載類時開辟空間并初始化的
• 如果一個類中包含多個靜态代碼塊，在編譯代碼時，編譯器會按照定義的先後次序依次合并，最終放在生成的<>方法中，該方法在類加載時調用，并且隻調用一次

靜态 / 執行個體代碼塊異同點

相同點： 都是JVM加載類後且在構造函數執行之前執行，在類中可定義多個，一般在代碼塊中對一些static變量進行指派

不同點： 靜态代碼塊在非靜态代碼塊之前執行，靜态代碼塊隻在第一次 new 時執行一次，之後不在執行。而非靜态代碼塊每new一次就執行一次

本篇内容有些多，哪裡有什麼問題歡迎大家指正~