認識類和對象

1.類、對象是什么？

類在Java中，也叫做自定義類型。

類就是一類對象的統(tǒng)稱，對象就是這一類具體化的一個個例

可以把類想象成一個模板，把對象想象成實體，比如：建房子，會有圖紙，然后根據(jù)圖紙去建房子，一張圖紙可建很多同樣的房子。而圖紙就是"類"，建的房子就是"實體"，通過一個類可以產(chǎn)生多個對象

2.什么是面向?qū)ο螅?/h3>

之前在初始Java篇簡單講述了Java的面向?qū)ο笮?，對比了面向?qū)ο蠛兔嫦蜻^程的不同

這里就不多說了 ：https://blog.csdn.net/m0_47988201/article/details/118996045?spm=1001.2014.3001.5501.

面向?qū)ο笫撬伎紗栴}的一種方式，是一種思想

總的來說，面向?qū)ο缶褪怯么a(類)，來描述客觀世界事物的一種方式，一個類主要包含一個事物的屬性和行為

面向?qū)ο蟮暮锰幨牵簩碗s的事情簡單化，只要面對一個對象就行

之后，會從這三點進行深入學習：找對象—創(chuàng)對象—使用對象

3.一個對象的產(chǎn)生過程是？

①給對象分配內(nèi)存；

②調(diào)用合適的構(gòu)造方法

🔺OOP語言的三大特征？

OOP：面向?qū)ο缶幊?br />

三大特性：繼承、封裝、多態(tài)

類和對象的實例化

類的定義：

在Java中定義類，需要 class 關(guān)鍵字

類中包含的內(nèi)容稱為類的成員；屬性主要是用來描述類的，稱之為類的成員屬性或者類成員變量；方法主要說明類具有哪些功能，稱為類的成員方法

類的成員包括：字段、方法、代碼塊、內(nèi)部類和接口等，此處只介紹前三個

語法格式：

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：受保護的；什么都不寫：默認權(quán)限 / 包訪問權(quán)限
• 一般一個文件當中只定義一個類
• main方法所在的類必須要使用public修飾p
• ublic修飾的類必須要和文件名相同

實例化對象：

在Java中，通過關(guān)鍵字new，配合類名可以實例化一個對象

用類類型創(chuàng)建對象的過程，稱為類的實例化

//實例化對象
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);
}

②如何訪問靜態(tài)的數(shù)據(jù)成員？

類名 . 靜態(tài)成員變量

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

注意：

• 同一個類可以創(chuàng)建多個實例
• new關(guān)鍵字用于創(chuàng)建一個對象的實例實例
• 成員變量，沒有初始化，默認值為對應的 0 值
  
• 引用類型默認為null，簡單類型默認為 0
• 特殊：char類型—"\u0000"；boolean類型—false
• 使用 . 來訪問對象中的屬性和方法
• 靜態(tài)成員變量不屬于對象，屬于類，且只有一份

方法：

實例成員方法：

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

靜態(tài)成員方法

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

🔺構(gòu)造方法

構(gòu)造方法的方法名和類名相同，且沒有返回值

構(gòu)造方法作用： 實例化一個對象

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) {
        //寫這行代碼的時候，就會調(diào)用構(gòu)造方法
        Person person1 = new Person();
        Person person2 = new Person("Huahua",18);
	 }
}

注意：

• 當沒有提供構(gòu)造方法的時候，編譯器會自動提供一個沒有參數(shù)的構(gòu)造方法
• 若類中定義了構(gòu)造方法，則默認的無參構(gòu)造不再產(chǎn)生
• 什么時候調(diào)用構(gòu)造方法取決于new對象時是否給參數(shù)
• 構(gòu)造方法支持重載，規(guī)則和普通方法一致

①訪問實例成員方法

通過對象的引用進行訪問：對象的引用 . 實例成員方法

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

②訪問靜態(tài)成員方法

類名 . 靜態(tài)成員方法

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

static 關(guān)鍵字

1.修飾屬性：

Java靜態(tài)屬性和類相似，和具體的實例無關(guān)

即：同一個類的不同實例共用同一個靜態(tài)屬性

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

靜態(tài)成員變量只有一份：

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

輸出結(jié)果：

分析原因：

2.修飾方法：

在方法前應用 ststic 關(guān)鍵字，就把該方法稱為靜態(tài)方法

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

注意：

• 靜態(tài)方法內(nèi)部不能訪問非靜態(tài)成員
• 靜態(tài)方法屬于類，不屬于類的對象
• 可以直接調(diào)用靜態(tài)方法，而無需創(chuàng)建類的實例
• 靜態(tài)方法可以更改靜態(tài)數(shù)據(jù)成員的值
• 靜態(tài)方法中不能調(diào)用任何非靜態(tài)方法

this 關(guān)鍵字

this 表示當前對象的引用

this 使用方法：

1、this . 屬性名稱 訪問屬性，指的是訪問類中的成員變量，用來區(qū)分成員變量和局部變量

2、this . 方法名稱 用來訪問本類的成員方法

3、this()；訪問本類的構(gòu)造方法，()中可以有參數(shù)的 如果有參數(shù) 就是調(diào)用指定的有參構(gòu)造

舉例1

訪問屬性 和 訪問方法

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

舉例2

訪問構(gòu)造方法

class Person{
    private String name;
    private int age;
    public  Person(){
    	// 訪問構(gòu)造方法
        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() 不能使用在普通方法中 只能寫在構(gòu)造方法中
• this() 必須是構(gòu)造方法中的第一條語句

getter 和 setter方法

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

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

注意事項：

• getName 即為 getter 方法，表示獲取這個成員的值
• setName 即為 setter 方法，表示設(shè)置這個成員的值
• 不是所有的字段都一定要提供 setter / getter 方法，而是要根據(jù)實際情況決定提供哪種方法
• 當 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 修飾之后，限定只能在類當中來使用

封裝的實現(xiàn)步驟：

1、修改屬性的可見性——設(shè)為private

2、創(chuàng)建getter / setter方法——用于屬性的讀寫

3、在getter / setter方法中加入屬性控制語句——對屬性值的合法性進行判斷

舉例：

class Student{
    //成員變量私有化
    private int age;
    //setter方法給設(shè)施變量的值
    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());
    }
}

輸出結(jié)果：

Java中的訪問修飾符：

封裝的作用：

• 對象的數(shù)據(jù)封裝特性，提高了程序的可復用性和可維護性，降低了程序員保持數(shù)據(jù)與操作內(nèi)容的負擔
• 對象的數(shù)據(jù)封裝特性還可以把對象的私有數(shù)據(jù)和公共數(shù)據(jù)分離開，保護了私有數(shù)據(jù)，減少了可能的模塊間干擾，達到降低程序復雜性、提高可控性的目的

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

代碼塊

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

重點掌握代碼塊執(zhí)行的先后順序

分為四種：

普通代碼塊：在方法或語句中出現(xiàn)的{ }就稱為普通代碼塊
實例代碼塊 (構(gòu)造代碼塊)
靜態(tài)代碼塊
同步代碼塊

實例代碼塊：

定義在類中且沒有加static關(guān)鍵字的代碼塊

如果存在多個構(gòu)造代碼塊，執(zhí)行順序由他們在代碼中出現(xiàn)的次序決定，先出現(xiàn)先執(zhí)行

特性：

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

注意事項：

• 實例代碼塊優(yōu)先于構(gòu)造方法執(zhí)行，因為編譯完成后，編譯器會將實例代碼塊中的代碼拷貝到每個構(gòu)造方法第一條語句前
• 實例代碼塊只有在創(chuàng)建對象時才會執(zhí)行

靜態(tài)代碼塊：

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

注意事項：

• 靜態(tài)代碼塊不能存在于任何方法體內(nèi)
• 靜態(tài)代碼塊不能直接訪問實例變量和實例方法，需要通過類的實例對象來訪問
• 靜態(tài)代碼塊不管生成多少個對象，其只會執(zhí)行一次
• 靜態(tài)成員變量是類的屬性，因此是在JVM加載類時開辟空間并初始化的
• 如果一個類中包含多個靜態(tài)代碼塊，在編譯代碼時，編譯器會按照定義的先后次序依次合并，最終放在生成的<>方法中，該方法在類加載時調(diào)用，并且只調(diào)用一次

靜態(tài) / 實例代碼塊異同點

相同點： 都是JVM加載類后且在構(gòu)造函數(shù)執(zhí)行之前執(zhí)行，在類中可定義多個，一般在代碼塊中對一些static變量進行賦值

不同點： 靜態(tài)代碼塊在非靜態(tài)代碼塊之前執(zhí)行，靜態(tài)代碼塊只在第一次 new 時執(zhí)行一次，之后不在執(zhí)行。而非靜態(tài)代碼塊每new一次就執(zhí)行一次

總結(jié)

本篇文章就到這里了，希望能給你帶來幫助，也希望您能給多多關(guān)注腳本之家的更多內(nèi)容！

最新評論