??前面的話??

本篇文章帶大家認識Java類與物件，我相信大家都聽說過面向物件編程，Java正是一種面向物件編程的語言，與C語言不同，C語言是一門面向程序的編程語言，對面向物件與面向程序的區別，我們可以這樣理解，面向物件，物件指的是一個事物，是名詞性的，面向程序，程序指的是做事情，是動詞性的，比如你要把一物品放進冰箱，面向程序是打開冰箱門->放入冰箱->關閉冰箱；面向物件是物品->冰箱，類與物件本身就是非常抽象的概念，需要多認識多實踐，下面就開始正文，帶你了解Java中的類與物件，

📒博客主頁：未見花聞的博客主頁
🎉歡迎關注🔎點贊👍收藏??留言📝
📌本文由未見花聞原創，CSDN首發！
📆首發時間：🌴2021年11月3日🌴
??堅持和努力一定能換來詩與遠方！
💭參考書籍：📚《Java核心技術卷1》，📚《Java核心技術卷2》，📚《Java編程思想》
💬參考在線編程網站：🌐牛客網🌐力扣
🙏作者水平很有限，如果發現錯誤，一定要及時告知作者哦！感謝感謝！
博主的碼云gitee，平常博主寫的程式代碼都在里面，

📌導航小助手📌

🔮1.初見類與物件
🔮2.類與類的實體化
- 🎃2.1類的創建
- 🎃2.2類的實體化
🔮3.類的成員
- 🎃3.1成員變數
- 🎃3.2方法
- 🎃3.3靜態變數與靜態方法
🔮4.類的封裝
- 🎃4.1privite實作封裝
- 🎃4.2getter和setter方法
🔮5.構造方法
- 🎃5.1new執行程序
- - 👻5.1.1new實體化物件程序
  - 👻5.1.2構造方法
- 🎃5.2this關鍵字
🔮6.代碼塊
- 🎃6.1普通代碼塊
- 🎃6.2構造代碼塊
- 🎃6.3靜態代碼塊
🔮7.物件
- 🎃7.1輸出物件資料
- 🎃7.2匿名物件

🔮1.初見類與物件

類（ class) 是構造物件的模板或藍圖，我們可以將類想象成制作小甜餅的切割機，將對
象想象為小甜餅，由類構造（construct) 物件的程序稱為創建類的實體（instance ).

對類進行實體化，這個實體化的類就是物件，

C語言是面向程序的，關注的是程序，分析出求解問題的步驟，通過函式呼叫逐步解決問題，JAVA是基于面向物件的，關注的是物件，將一件事情拆分成不同的物件，靠物件之間的互動完成，面向程序注重的是程序，在整個程序中所涉及的行為，就是功能，面向物件注重的是物件，也就是參與程序所涉及到的主體，是通過邏輯將一個個功能實作連接起來，面向程序： 1.把冰箱打開 2. 把大象放入 3. 冰箱關起來面向物件：打開冰箱，儲存，關閉都是對冰箱的操作，是冰箱的行為，冰箱就是一個物件，所以只要操作冰箱所具備的功能，都要定義在冰箱中，

類與物件的概念非常地抽象，下面通過介紹類與物件的應用來理解類與物件，

🔮2.類與類的實體化

🎃2.1類的創建

🎁自定義一個類的格式：

class ClassName {
    //成員：1.變數（欄位/屬性） 2.方法
}

（1）類名采用大駝峰形式命名
（2）一個.java檔案中只能有一個public修飾的類
（3）類中的成員可以是變數（欄位/屬性），方法，靜態變數與靜態方法，

比如：

class Student {
    public String name;
    public String sex;
    public int age;
    public String id;
        
    public void setName(String str){
        name = str;
    }
}

🎃2.2類的實體化

我們所定義出來的類，可以將其理解為一張建筑圖紙（藍圖），按照這張圖紙的內容建造處一棟房子的程序稱為類的實體化，這棟實體化出來的“房子”即物件，

當然，一張設計圖紙是可以實體化多個建筑的，這些建筑的屬性都是相同的，換言而知，類可以實體化出多個物件，

在Java對類進行實體化的關鍵字為new，這個關鍵字我相信大家肯定不陌生，因為在之前的輸入和定義陣列時都使用這個關鍵字new，

類名變量名 = n e w 類名 ( 構造函數參數 ) ; 類名\ 變數名\ =\ new\ 類名(建構式引數); 類名變量名 = new 類名(構造函數參數);

其中這個建構式引數我們先不管他，這個引數可以沒有，

比如我們定義了這樣的一個類：

class Student {
    public String name;
    public String sex;
    public int age;
    public String id;
    public String major;
    
    public void getName() {
        System.out.println(name);
    }
    public void getMajor() {
        System.out.println(major);
    }
}

那么對這個類的實體化程序為：

public class ClassCreat {
    public static void main(String[] args) {
        Student stu = new Student();//實體化物件
        stu.name = "weijianhuawen";//使用.對這個實體化的物件stu進行訪問
        stu.sex = "man";
        stu.major = "computer";
        stu.getMajor();//同理該物件的方法進行訪問
        stu.getName();
    }
}

使用Student類定義出來的變數stu為參考變數，它的值為實體化物件的地址，

🔮3.類的成員

🎃3.1成員變數

在類中方法外定義的變數稱為為一個類的成員變數，成員變數又稱欄位或屬性，

class Variable {
    public int a
    public double pi;
    public String str;
}

像上面這樣在類中方法之外定義的變數，為成員變數，如果我們需要使用這個類，則需要先用new實體化出一個物件，然后才能對里面的成員進行訪問，通過對類實體化出的多個物件，每個物件是獨立的，修改一個物件的值，另一個物件的值是不會改變的，最后，類中的成員變數可以自己初始化值也可以不初始化，這和方法中定義的區域變數有了區別，但是一般情況下不自己初始化值，不初始化成員變數值的情況下，會有一個默認值，

public class ClassCreat {
    public static void main(String[] args) {
        Variable var = new Variable();
        System.out.println(var.a);
        System.out.println(var.pi);
        System.out.println(var.str);
        var.pi = 3.14;
        var.a = 12;
        System.out.println(var.a);
        System.out.println(var.pi);
        System.out.println("---------------------");
        Variable var2 = new Variable();
        System.out.println(var2.a);
        System.out.println(var2.pi);
    }
}

🎃3.2方法

類中可以定義成員變數以外還可以定義方法，比如main方法就是定義在一個類里面的，

class Menthod {
    public double a;
    public double b;

    public double add(double x, double y) {
        return x + y;
    }
    public double sub(double x, double y) {
        return x - y;
    }
}

我們定義了一個類，里面有兩個成員變數和成員方法，如果需要使用這個類，需先實體化成物件，然后才能訪問物件中的變數或方法，

public class ClassCreat {
    public static void main(String[] args) {
        Menthod men = new Menthod();
        men.a = 3.14;
        men.b = 2.88;

        double sum = men.add(men.a, men.b);
        double sub = men.sub(men.a, men.b);

        System.out.printf("和為%.2f\n差為%.2f\n", sum, sub);
    }
}

🎃3.3靜態變數與靜態方法

上面我們在類中方法之外定義的成員變數和成員方法是屬于物件的，存盤在堆區之中，而靜態的變數或者靜態的方法是存盤在方法區，類也是儲存在方法區，所以靜態的變數或者方法也稱為類變數與類方法，靜態變數與靜態方法是屬于類的，所以不需要對類進行實體化就能使用，當然，由于它是屬于類的，你在一個物件中改變靜態變數的值，那么在其他物件中訪問這個靜態變數時，該靜態的值會是被修改的值，

class StaticMember {
    public static int x;

    public static int add(int a, int b) {
        return a + b;
    }
}

上面所定義的這個類中a是成員變數，b是靜態成員變數，還有一個靜態方法add，上面說過使用靜態的變數或者方法是不需要使用類實體化物件的（當然你也可以實體化出一個物件，然后根據物件訪問它，這個是沒問題的），a必須實體化出物件才能使用，

public class ClassCreat {
    public static void main(String[] args) {
        int a = 12;
        int sum = StaticMember.add(a, StaticMember.x);
        System.out.println(sum);
        System.out.println("------------");
        StaticMember sm1 = new StaticMember();
        sm1.x = 14;
        sum = sm1.add(a, sm1.x);
        System.out.println(sum);
        System.out.println("------------");
        StaticMember sm2 = new StaticMember();
        sum = sm2.add(a, sm2.x);
        System.out.println(sum);
    }
}

🔮4.類的封裝

🎃4.1privite實作封裝

上面我們定義類中的變數或方法時，都是使用了public關鍵字修飾，使用該關鍵字修飾的變數或方法，表示該變數或方法是公共的，在其他和當前類當中都可以使用，但是如果使用privite關鍵字修飾變數或方法，表示該變數或方法是私有的，只有它所屬類才能訪問使用，在其他類無法對該變數或方法進行訪問或呼叫，這也體現了Java的安全性，
看下面一段代碼：

class PriviteMember {
    private int add(int a, int b) {
        return  a + b;
    }
}

public class ClassCreat {
    public static void main(String[] args) {
        PriviteMember pm = new PriviteMember();
        int x = 10;
        int y = 12;
        System.out.println(pm.add(x, y));
    }
}

由于我們將PriviteMember類中的add方法私有，然后在另一個類中實體物件并使用add，我們發現編譯器報錯了！

如果呼叫add的方法（示例程式中是mian方法）與add在同一個類，再次執行程式：

public class ClassCreat {
    private int add(int a, int b) {
        return  a + b;
    }
    public static void main(String[] args) {
        ClassCreat pm = new ClassCreat();
        int x = 10;
        int y = 12;
        System.out.println(pm.add(x, y));
    }
}

我們發現這個方法能夠正常運行：

🎃4.2getter和setter方法

關鍵字privite所修飾的變數或方法只能在同一個類之中使用，那如果我們想在另一個類中對那個被privite變數或方法進行修改或呼叫，能不能實作呢？其實是可以的，但是是間接性的，就是我們在privite修飾的變數或方法所在類中定義一個public修飾的方法來進行對privite修飾的成員進行訪問與修改，

我們可以寫出這樣的一個類：

class PriviteMember {
    private int m;
    private double n;
    private int add(int a, int b) {
        return  a + b;
    }
    
    public int getterInt() {
        return m;   //獲取m
    }
    public double getterDouble() {
        return  n;//獲取n
    }
    public void setterInt(int x) {
        m = x;//設定m
    }
    public void setterDouble(double y) {
        n = y;//設定n
    }
    public int getAdd(int x, int y) {
        return add(x, y);//呼叫私有方法add
    }
}

我們在其他類中來呼叫該類其他公共的變數或方法，能夠間接地對私有的成員進行訪問與修改，

public class ClassCreat {
    public static void main(String[] args) {
        PriviteMember pm = new PriviteMember();
        pm.setterInt(12);//對m賦值
        System.out.println(pm.getterInt());//獲取m的值
        
        pm.setterDouble(3.14);//對n賦值
        System.out.println(pm.getterDouble());//獲取n的值

        int a = 14;
        int b = 12;
        System.out.println(pm.getAdd(a, b));//間接呼叫私有方法add
    }
}

其實在編譯器idea中，可以自動生成getter與setter方法，用來設定和獲取一個類中私有變數的值或私有方法的回傳值，
在idea編譯器中，在代碼區右鍵，找到Generate，點進去然后選擇Getter或者Setter就能自動幫助你生成設定和獲取私有成員變數的值，

根據需要選擇Getter或Setter，然后選擇需要訪問的變數，按住ctrl能夠多選，

this關鍵字修飾，表示的是當前物件中的參考，能夠用來訪問當前物件的成員變數與方法，

🔮5.構造方法

🎃5.1new執行程序

👻5.1.1new實體化物件程序

使用關鍵字new實體化物件程序中，其實分為兩步：

為物件分配記憶體空間
呼叫構造方法（如果沒有類中任何構造方法，會自動生成一個不帶引數的構造方法）

👻5.1.2構造方法

構造方法是一種特殊方法, 使用關鍵字new實體化新物件時會被自動呼叫，所以建構式是定義在類中的，他有以下特點：

方法名稱必須與類名相同，
沒有回傳值，
每個類中至少有一個建構式，如果類中沒有定義，則會自動生成一個不帶引數的構造方法，
構造方法支持多載，規則和普通方法的多載一致，
若類中定義了含引數的構造方法，則默認的無參構造方法將不再生成，

🎃5.2this關鍵字

關鍵字this在前面使用Setter生成函式時，發現自動生成的函式中有變數被this修飾，被this關鍵字修飾，表示的是當前物件中的參考，能夠用來訪問當前物件的成員變數與方法，

??注意！this表示當前物件的參考，而不是當前物件，在建構式中我們是可以使用this，但是呼叫構造方法時，該物件還沒實體化完成，只是分配了記憶體，說明物件還沒有定義好，但是參考已經生成了，因為記憶體分配完成了，那么地址也就出來了，參考也自然而然也出來了，所以this表示的是當前物件的參考，而不是當前物件，

關鍵字this的三種使用方式：

方式	解釋
this.成員變數名	訪問當前物件的屬性（成員變數）
this.方法名(對應引數串列)	呼叫當前物件的方法
this()	在構造方法中呼叫當前物件的其他構造方法，必須位于構造方法的第一行

如下代碼可以證明this是可以在構造方法中使用的：

class ConstructionMethod {
    public int a;
    private int b;

    public ConstructionMethod() {
        System.out.println("這是一個不帶引數的構造方法！");
    }
    public ConstructionMethod(int x) {
        this.b = x;
        System.out.println("這是一個帶有引數的構造方法！可以給成員變數b賦值！賦值后b = " + this.b);
    }
    public ConstructionMethod(int x, int y) {
        this.a = this.add(x, y);
        System.out.println("這是一個帶有兩個引數的構造方法！可以計算兩個整數的和！這兩個數的和為：" + a);
    }
    private int add(int m, int n) {
        return m + n;
    }
}

public class ClassCreat {
    public static void main(String[] args) {
        ConstructionMethod cm1 = new ConstructionMethod();
        System.out.println("------------");
        ConstructionMethod cm2 = new ConstructionMethod(12);
        System.out.println("------------");
        ConstructionMethod cm3 = new ConstructionMethod(18, 2);
    }
}

🔮6.代碼塊

🎃6.1普通代碼塊

普通代碼塊就是在方法中使用花括號定義的代碼塊，例如：

public class ClassCreat {
    public static void main(String[] args) {
        {
            int a = 12;
            int b = 48;
            String name = "weijianhuawen";
        }
    }
}

🎃6.2構造代碼塊

構造代碼塊為類中方法外定義的代碼塊，也叫實體代碼塊，一般用來初始化成員變數（我覺得多此一舉），例如：

class CodeBlock {
    private int c;
    private int d;
    public int sum;

    //構造代碼塊 or 實體代碼塊
    {
        this.c = 10;
        this.d = 12;
        sum = this.add(c, d);
    }
    
    public int add(int x, int y) {
        return x + y;
    }
}

??注意：構造（實體）代碼塊優先于建構式執行，

🎃6.3靜態代碼塊

使用static修飾的構造代碼塊稱為靜態代碼塊，它一般用來初始化靜態成員變數的屬性，它和類儲存在一起，存盤在方法區，

class CodeBlock {
    public static int a;
    public static String name;
    
    //靜態代碼塊
    static {
        a = 18;
        name = "未見花聞";
    }
}

??注意：

靜態代碼塊不管生成多少個物件，其只會執行一次，且是最先執行的，
靜態代碼塊執行完畢后, 實體代碼塊（構造代碼塊）執行，再然后是建構式執行，

🔮7.物件

🎃7.1輸出物件資料

當我們對類的參考進行列印時會輸出什么呢？我們來試一試：

class Student {
    public String name;
    public String sex;
    public int age;
    public String id;
    public String major;

    public void getName() {
        System.out.println(name);
    }
    public void getMajor() {
        System.out.println(major);
    }
}
public class ClassCreat {
    public static void main(String[] args) {
        Student sc = new Student();
        sc.name = "weijianhuawen";
        sc.sex = "man";
        sc.age = 1;
        sc.id = "5201314";
        sc.major = "computer";

        System.out.println(sc);
    }
}

為什么輸出的不是地址呢？因為Java是具有很強的安全性，它把地址進行了處理，使用 toString方法回傳一個字串，這個列印的資料正是這個字串，至于為什么是toString方法，我們來溯源一下println方法的真面目：
按住ctrl點擊進入println方法：

通過溯源，我們就知道了對參考進行列印會輸出類名@該參考的哈希值這樣一個字串，
我們試一試自己寫上這樣一個方法，方法名回傳值均與toString方法相同，
假如我寫成這樣，然后放在Student類當中：

public String toString() {
    return "未見花聞";
}

我們再來運行一下這個程式：

class Student {
    public String name;
    public String sex;
    public int age;
    public String id;
    public String major;

    public String toString() {
        return "未見花聞";
    }
    public void getName() {
        System.out.println(name);
    }
    public void getMajor() {
        System.out.println(major);
    }
}
public class ClassCreat {

    public static void main(String[] args) {
        Student sc = new Student();
        sc.name = "weijianhuawen";
        sc.sex = "man";
        sc.age = 1;
        sc.id = "5201314";
        sc.major = "computer";

        System.out.println(sc);
    }
}

得到了我自己所寫toString所回傳的字串，這其實是對方法進行了重寫，如果子類中的方法與父類中的方法名回傳值引數及其引數個數相同，就構成了方法的重寫，會優先執行子類的方法（該內容在后續博客關于繼承中詳細介紹，這里先了解），我所寫的這個類Student是子類，原來toString方法是在Object類中的，這個Object類就是父類，所以會優先執行我所寫的toString方法，

在idea編譯器中，能夠自動生成toString方法，可以選擇性的輸出一個類中成員變數的資料，
與自動生成Getter與Setter方法類似：

自動生成的代碼：

再來運行一下程式：

class Student {
    public String name;
    public String sex;
    public int age;
    public String id;
    public String major;

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                ", age=" + age +
                ", id='" + id + '\'' +
                ", major='" + major + '\'' +
                '}';
    }

    public void getName() {
        System.out.println(name);
    }
    public void getMajor() {
        System.out.println(major);
    }
}
public class ClassCreat {

    public static void main(String[] args) {
        Student sc = new Student();
        sc.name = "weijianhuawen";
        sc.sex = "man";
        sc.age = 1;
        sc.id = "5201314";
        sc.major = "computer";

        System.out.println(sc);
    }
}

🎃7.2匿名物件

所謂的匿名物件，就是不使用一個類的參考變數，而是直接呼叫，那么生成的這個物件是一次性的，只能進行一次訪問，因為訪問一次之后你就找不到它了，

沒有參考的物件稱為匿名物件.
匿名物件只能在創建物件時使用.
如果一個物件只用一次, 后面不需要用了, 可以考慮使用匿名物件.

class AnonymousObject {
    public int a;

    public AnonymousObject() {
        this.a = 188;
    }
}
public class ClassCreat {
    public static void main(String[] args) {
        System.out.println(new AnonymousObject().a);
    }
}

覺得文章寫得不錯的老鐵們，點贊評論關注走一波！謝謝啦！

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/347112.html

標籤：java

上一篇：5千字長文，深度總結HashMap底層實作&面試題【收藏】

下一篇：Java崗大廠面試百日沖刺【Day47】— 并發編程4（榷訓月累，每日三題）

【JavaSE系列】Java類與物件，萬物皆物件