Java——類和物件超詳細總結-有解無憂

文章目錄

- 類和物件
- - 1.類與物件的初步認識
  - 2.類和類的實體化
  - 3.類的成員
  - - 3.1欄位/屬性/成員變數
    - 3.2方法
    - 3.3 static關鍵字
  - 4.封裝
  - - 4.1 private實作封裝
    - 4.2 getter和setter方法
  - 5.構造方法
  - - 5.1基本語法
    - 5.2 this關鍵字
  - 6.認識代碼塊
  - - 6.1什么是代碼塊
    - 6.2普通代碼塊
    - 6.3構造代碼塊
    - 6.4靜態代碼塊

類和物件

1.類與物件的初步認識

c語言是面向程序的，關注的是程序，分析出求解問題的步驟，通過函式呼叫逐步解決問題，

Java是基于面向物件的，關注的是物件，將一件事情拆分成不同的物件，靠物件之間的互動完成，

面向程序注重的是程序，就像我們用手洗衣服，我們需要先用盆接水，然后放入衣服，然后放入洗衣粉，然后用手搓，然后擰干曬起來，

面向物件注重的是物件，就像我們用洗衣機洗衣服，只要把衣服和洗衣服放入洗衣機，然后曬干就可以了，不用去管洗衣機是如何去洗衣服的，

2.類和類的實體化

類就是一類物件的統稱，物件就是這一類具體化的一個實體，

類相當于一個模板，物件是由模板產生的樣本，一個類，可以產生無數的物件，

宣告一個類就是創建一個新的資料型別，而類在Java中屬于參考型別，Java使用關鍵字class來宣告類，我們來看以下簡單的宣告一個類，

基本語法

//創建類
class <class_name>{
    field;    //  成員屬性
    method;    //  成員方法
}

//實體化物件
<class_name> <物件名> = new <class_name>();

class為定義類的關鍵字，ClassName為類的名字，{}中為類的主體，

類中的元素稱為：成員屬性，類中的函式稱為：成員方法，

示例：

class Person{
    public int age;    //  成員屬性  實體變數
    public String name;
    public String sex;
    public void eat(){    //成員方法
        System.out.println("吃飯！");
    }
    public void sleep(){
        System.out.println("睡覺！");
    }
}

注意事項

和之前寫的方法不同，此處寫的方法不帶static關鍵字，我們我們會詳細解釋static是干什么的，

類的實體化

用型別別創建物件的程序，稱為類的實體化

類只是一個模型一樣的東西，限定了類有哪些成員，
一個類可以實體化出多個物件，實體化出的物件，占用實際的物理空間，存盤類成員變數，

class Person{
    public int age;    //  成員屬性  實體變數
    public String name;
    public String sex;
    public void eat(){    //成員方法
        System.out.println("吃飯！");
    }
    public void sleep(){
        System.out.println("睡覺！");
    }
}

public class DemoTest {
    public static void main(String[] args) {
        Person person = new Person();    //  通過new實體化物件
        Person.eat();    //  成員方法呼叫需要通過物件的參考呼叫
        Person.sleep();
        //  產生物件  實體化物件
        Person person2 = new Person();
        Person person3 = new Person();
    }
}

輸出結果為：

吃飯！
睡覺！

注意事項

new關鍵字用于創建一個物件的實體，
使用.來訪問物件中的屬性和方法，
同一個類可以創建多個實體，

3.類的成員

類的成員包含以下：欄位、方法、代碼塊、內部類和介面等，

此處我們重點介紹前三個，

3.1欄位/屬性/成員變數

在類中，但是方法外部定義的變數，這樣的變數我們稱為"欄位"或"屬性"或"成員變數"(三種稱呼都可以，一般不會嚴格區分)，用于描述一個類中包含哪些資料，

class Person{
    public String name;    //  欄位
    public int age;
}

public class TestDemo {
    public static void main(String[] args) {
        Person person=new Person();
        System.out.println(person.name);
        System.out.println(person.age);
    }
}

//執行結果
null
0

注意事項

使用.訪問物件的欄位，
"訪問"既包含讀，也包含寫，
對于一個物件的欄位如果沒有顯式設定初始值，那么會被設定一個默認的初值，

默認值規則

對于各種數字型別，默認值為0，

對于boolean型別，默認值為false，

對于參考型別(String,Array,以及自定制類)，默認值為null.

Person person = null;
//這個參考不指向任何的物件

Person person = new Person();
Person person2=person;
//person2這個參考指向person這個參考所指向的物件

Person person = new Person();
person = new Person();
person = new Person();
person = new Person();
//一個參考不可以同時指向多個物件 實際指向的是最后一個物件

欄位就地初始化

很多時候我們不希望欄位使用默認值，而是需要我們顯式設定初值，可以這樣寫：

class Person{
    public String name = "ljj";    
    public int age = 18;
}

public class TestDemo {
    public static void main(String[] args) {
        Person person=new Person();
        System.out.println(person.name);
        System.out.println(person.age);
    }
}

//執行結果
ljj
18

3.2方法

用于描述一個物件的行為，

class Person{
    public String name = "ljj";    
    public int age = 18;
    
    public void show(){
       System.out.println("我叫"+name+",今年"+age+"歲")； 
    }
}

public class TestDemo {
    public static void main(String[] args) {
        Person person = new Person();
        person.show();
    }
}

//執行結果
我叫ljj,今年18歲

此處的show方法，表示Person這個物件具有一個"展示自我"的行為，

這樣的show方法是和person實體相關聯的，如果創建了其他實體，那么show的行為就會發生變化，

Person person2 = new Person();
person2.name = "李四";
person2.age = 20;
person.show();

//執行結果
我叫李四，今年20歲

3.3 static關鍵字

修飾屬性
修飾方法
代碼塊
修飾類

a）修飾屬性，Java靜態屬性和類相關，和具體的實體無關，換句話說，同一個類的不同實體共用一個靜態屬性，

class TestDemo1{
    public int a;
    public static int count;
}

public class TestDemo {
    public static void main(String[] args) {
        TestDemo1 t1 = new TestDemo1();
        t1.a++;
        TestDemo1.count++;
        System.out.println(t1.a);
        System.out.println(TestDemo1.count);
        System.out.println("===============");
        TestDemo1 t2 = new TestDemo1();
        t2.a++;
        TestDemo1.count++;
        System.out.println(t2.a);
        System.out.println(TestDemo1.count);
    }
}

輸出結果為：

1
1
===============
1
2

b)修飾方法

如果在任何方法上應用static關鍵字，此方法稱為靜態方法，

靜態方法屬于類，而不屬于類的物件，
可以直接呼叫靜態方法，而無需創建類的實體，
靜態方法可以訪問靜態資料成員，并可以更改靜態資料成員的值，

class TestDemo1{
    public int a;
    public static int count;
    
    public static void change(){
        count = 100;
        //a = 10;  error  不可以訪問非靜態資料成員
    }
}

public class TestDemo {
    public static void main(String[] args) {
        TestDemo1.change();    //  無需創建實體物件就可以呼叫
        System.out.println(TestDemo1.count);
    }
}

輸出結果：

注意事項1：靜態方法和實體無關，而是和類相關，因此導致了兩個情況：

靜態方法不能直接使用非靜態資料成員或呼叫非靜態方法(非靜態資料成員和方法都是和實體相關的)，
this和super兩個關鍵字不能在靜態背景關系中使用(this是當前實體的參考，super是當前實體父類實體的參考，也是和當前實體相關)，

注意事項2：

我們曾經寫的方法為了簡單，都統一加上了static，但實際上一個方法具體要不要帶static，都需要視情形而定，
main方法為static方法，

4.封裝

軟體開發的本質就是對程式復雜程度的管理，如果一個軟體代碼復雜程度太高，那么就無法繼續維護，如何管理復雜程度？封裝就是最基本的方法，

在我們寫代碼的時候經常會涉及兩種角色：類的實作者和類的呼叫者，

封裝的本質就是讓類的呼叫者不必了解類的實作者是如何實作類的，只要知道如何使用就行了，

這樣就降低了類使用者的學習和使用成本，從而降低了復雜程度，

4.1 private實作封裝

private/public這兩個關鍵字表示"訪問權限控制"，

被public修飾的成員變數或者成員方法，可以直接被類的呼叫者使用，

被private修飾的成員變數或者成員方法，不能被類的呼叫者使用，

直接使用public

class Person{
    public String name = "ljj";    
    public int age = 18;
    
public class TestDemo {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println("我叫"+person.name+",今年"+person.age+"歲");
    }
}
    
//執行結果
我叫ljj，今年18歲

這樣的代碼導致類的使用者(main方法的代碼)必須要了解Person類內部的實作，才能夠使用這個類，學習成本較高，

一旦類的實作者修改了代碼(例如把name改成myName)，那么類的使用者就需要大規模的修改自己的代碼，維護成本較高，

范例：使用private封裝屬性，并提供public方法供類的呼叫者使用，

class Person{
    private String name = "ljj";    
    private int age = 18;
    
    public void show(){
        System.out.println("我叫"+person.name+",今年"+person.age+"歲");
    }
}

public class TestDemo {
    public static void main(String[] args) {
        Person person = new Person();
        person.show();
    }
}

//執行結果
我叫ljj，今年18歲

此時欄位已經使用private來修飾，類的呼叫者(main方法中)不能直接使用，而需要借助show方法，此時類的使用者就不必了解Person類的實作細節，

同時如果類的實作者修改了欄位的名字，類的呼叫者不需要做出任何修改(類的呼叫者根本訪問不到name,age這樣的欄位)，

注意事項

private不光能修飾欄位，也能修飾方法，
通常情況下我們會把欄位設為private屬性，但是方法是否需要設為public，就需要視具體情形而定，一般我們希望一個類只提供"必要的"public方法，而不應該把所有的方法都無腦設為public，

4.2 getter和setter方法

當我們使用private來修飾欄位的時候，就無法直接使用這個欄位了，

代碼示例

class Person{
    private String name = "ljj";    
    private int age = 18;
    
    public void show(){
        System.out.println("我叫"+person.name+",今年"+person.age+"歲");
    }
}

public class TestDemo {
    public static void main(String[] args) {
        Person person = new Person();
        person.age=20
        person.show();
    }
}

//編譯出錯
java: age可以在Person中訪問private

此時如果需要獲取或者修改這個private屬性，就需要使用getter/setter方法，

代碼示例

class Person{
    private String name;    //  實體成員變數    
    private int age;
    
    public void setName(String name){
        //name = name;    //  不能這樣寫
        this.name = name;    //this參考，表示呼叫該方法的物件
    }
    public String getName(){
        return name;
    }
    
    public void show(){
        System.out.println("name:"+name+" age:"+age);
    }
}
    
public class TestDemo {
    public static void main(String[] args) {
        Person person = new Person();
        person.setName("ljj");
       String name = person.getName();
        System.out.println(name);
        person.show();
    }
}

//運行結果
ljj
name:ljj age:0

注意事項

getName即為getter方法，表示獲取這個成員的值，

setName即為setter方法，表示設定這個成員的值，

當set方法的形參名字和類中的成員屬性名字一樣的時候，如果不使用this，相當于賦值，this表示當前實體的參考，

不是所有的欄位都一定要提供setter/getter方法，而是要根據實際情況決定提供哪種方法，

在IDEA中可以使用alt+insert(或者alt+F12)快速生成setter/getter方法，在VSCode中可以使用滑鼠右鍵選單->源代碼操作中自動生成setter/getter方法，

5.構造方法

5.1基本語法

構造方法是一種特殊方法，使用關鍵字new實體化新物件時會被自動呼叫，用于完成初始化操作，

new執行程序

為物件分配記憶體空間
呼叫物件的構造方法

語法規則

方法名稱必須與類名稱相同
構造方法沒有回傳值型別宣告
每一個類中一定至少存在一個構造方法(沒有明確定義，則系統自動生成一個無參構造)

注意事項

如果類中沒有提供任何建構式，那么編譯器會默認生成一個不帶引數的建構式，
若類中定義了構造方法，則默認的無參構造將不再生成，
構造方法支持多載，規則和普通方法的多載一致，

代碼示例

class Person{
    private String name;    //  實體成員變數    
    private int age;
    private String sex;
    //  默認建構式  構造物件
    public Person(){
        this.name = "ljj";
        this.age = 10;
        this.sex = "男";
    }
    //  帶有3個引數的建構式
    public person(String name,int age,String sex){
        this.name = name;
        this.age = age;
        this.sex = sex;
    }
    
    public void show(){
        System.out.println("name:"+name+" age:"+age+"sex:"+sex);
    }
}

public class TestDemo {
    public static void main(String[] args) {
        Person person1 = new Person();    //呼叫不帶引數的建構式  如果程式沒有提供會呼叫不帶引數的建構式
        p1.show();
        Person person2 = new Person("李四",80,"男”);    //呼叫不帶引數的建構式  
        p2.show();
    }
}

//執行結果
name:ljj age:10 sex:男
name:李四 age:80 sex:男

5.2 this關鍵字

this表示當前物件參考(注意不是當前物件)，可以借助this來訪問物件的欄位和方法，

class Person{
    private String name;    //  實體成員變數    
    private int age;
   //  默認建構式  構造物件
    public Person(){
        //  this呼叫建構式
        this("bit",12,"man");    //  必須放在第一行進行顯式
    }
    //  這兩個建構式之間的關系為多載
    public person(String name,int age,String sex){
        this.name = name;
        this.age = age;
        this.sex = sex;
    }
    public void show(){
        System.out.println("name:"+name+" age:"+age+"sex:"+sex);
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Person person = new Person();    //  呼叫不帶引數的建構式
        person.show();
    }
}

//執行結果
name:bit age:12 sex:man

6.認識代碼塊

欄位的初始化方式有：

就地初始化
使用構造方法初始化
使用代碼塊初始化

前兩種方式前面已經學習過了，接下來我們介紹第三種方式，使用代碼塊初始化，

6.1什么是代碼塊

使用{}定義的一段代碼，

根據代碼塊定義的位置以及關鍵字，又可分為以下四種：

普通代碼塊
構造塊
靜態塊
同步代碼塊

6.2普通代碼塊

普通代碼塊：定義在方法中的代碼塊

public class TestDemo {
    public static void main(String[] args) {
        {
            //  直接使用{}定義普通方法塊
            int x = 10;
            System.out.println("x1 = "+x);
        }
        int x = 100;
        System.out.println("x2 = "+x);
    }
}

//執行結果
x1 = 10
x2 = 100

6.3構造代碼塊

構造塊：定義在類中的代碼塊(不加修飾符)，也叫：實體代碼塊，構造代碼塊一般用于初始化實體成員變數，

class Person{
    private String name;    //  實體成員變數    
    private int age;
    private String sex;
    
    public Person(){
        System.out.println("I am Person init()!");
    }
    
    //實體代碼塊
    {
        this.name = "ljj";
        this.age = 18;
        this.sex = "man";
        System.out.println("I am instance init()!");
    }
    
     public void show(){
        System.out.println("name:"+name+" age:"+age+"sex:"+sex);
    }
}

public class TestDemo {
    public static void main(String[] args) {
        Person p1 = new Person();   
        p1.show();
    }
}

//運行結果
I am instance init()!
I am Person init()!
name:ljj age:18 sex:man

注意事項：實體代碼塊優先于建構式執行，

6.4靜態代碼塊

使用static定義的代碼塊，一般用于初始化靜態成員屬性，

class Person{
    private String name;    //  實體成員變數    
    private int age;
    private String sex;
    private static int count = 0;    //  靜態成員變數  由類共享資料  方法區
    
    public Person(){
        System.out.println("I am Person init()!");
    }
    
    //實體代碼塊
    {
        this.name = "ljj";
        this.age = 18;
        this.sex = "man";
        System.out.println("I am instance init()!");
    }
    
    //靜態代碼塊
    static{
        count = 10;    //  只能訪問靜態資料成員
        System.out.println("I am instance init()!");
    }
    
    public void show(){
        System.out.println("name:"+name+" age:"+age+"sex:"+sex);
    }
}

public class TestDemo {
    public static void main(String[] args) {
        Person p1 = new Person();   
        Person p2 = new Person();    //  靜態代碼塊是否還會被執行？
    }
}

注意事項

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

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

標籤：其他

上一篇：2021卓見杯第三屆CCPC河南省省賽所有題超詳細題解附加榜單真題決議，簡單代碼+詳細注釋+思想，要看的,補題的速速點進來 2021 10.30

下一篇：江西開放資料創新應用大賽VTE賽道單特征0.5+分享