Java 基礎(chǔ)語(yǔ)法

其實(shí)在學(xué)習(xí) C 語(yǔ)言時(shí)就一直聽(tīng)到 C 語(yǔ)言是面向過(guò)程的，而 Java 是面向?qū)ο蟮倪@句話。并且我們之前的學(xué)習(xí)中也遇到了類，但是對(duì)它好像沒(méi)有其他的認(rèn)知。
那么面向過(guò)程與面向?qū)ο蟮降资鞘裁茨?？它們有哪些不同的意義呢？

類與對(duì)象到底是什么呢？這章就來(lái)帶你揭曉！

一、類與對(duì)象的初步認(rèn)知

我們可以舉一個(gè)洗衣服的例子來(lái)認(rèn)識(shí)面向?qū)ο蠛兔嫦蜻^(guò)程

對(duì)于面向過(guò)程： 我們可以看成是手洗衣服的過(guò)程

對(duì)于面向?qū)ο螅?我們可以看作直接用洗衣機(jī)去洗

其中總共有四個(gè)對(duì)象：人、衣服、洗衣粉、洗衣機(jī)
而整個(gè)洗衣服的過(guò)程就是：人將衣服放進(jìn)洗衣機(jī)、人倒入洗衣粉、人啟動(dòng)洗衣

因此整個(gè)過(guò)程主要就是上述四個(gè)對(duì)象之間交互完成的，人不需要關(guān)心洗衣機(jī)具體是如何洗衣服并且甩干的

因此對(duì)于面向?qū)ο?，重點(diǎn)就是

找對(duì)象
創(chuàng)建對(duì)象
使用對(duì)象

那么對(duì)象從何而來(lái)呢？它其實(shí)是由類的實(shí)例化產(chǎn)生的

下面讓我們來(lái)了解類以及類的實(shí)例化吧！

二、類和類的實(shí)例化

類

就是一類對(duì)象的統(tǒng)稱

對(duì)象

就是這一類具體化的一個(gè)實(shí)例

舉個(gè)栗子講講

比如我們做月餅的模子就是一個(gè)類，而通過(guò)這個(gè)模子可以做出月餅。那么在這個(gè)例子中，做月餅的模子就是類，而那個(gè)月餅就是對(duì)象。并且一個(gè)月餅就是一個(gè)實(shí)體，而一個(gè)模子可以實(shí)例化無(wú)數(shù)個(gè)對(duì)象，也就是說(shuō)一個(gè)類可以產(chǎn)生無(wú)數(shù)的對(duì)象

那怎么聲明一個(gè)類呢？首先我們要知道

聲明一個(gè)類就是創(chuàng)建一個(gè)新的數(shù)據(jù)類型（感覺(jué)類似于 C 語(yǔ)言中的 struct）
類在 Java 中屬于引用類型
Java 使用關(guān)鍵字 class 來(lái)聲明類，并且類中可以定義一些屬性和行為

上個(gè)代碼看看

// 定義一個(gè)類
class Person{
    // 屬性（成員變量）
    public int age;
    public String name;
    // 行為（成員方法）
    public void eat(){
        System.out.println("吃飯");
        int a = 10; // 局部變量
    }
}

其中 Person 就是類名，{} 中的就是類的主體。類里面可以創(chuàng)建屬性和行為

注意：

此處寫的方法不帶關(guān)鍵字 static

類的實(shí)例化

用類類型創(chuàng)建對(duì)象的過(guò)程，稱為類的實(shí)例化

我們要理解

• 類只是一個(gè)模型一樣的東西，限定了類有哪些成員變量
• 一個(gè)類可以實(shí)例化出多個(gè)對(duì)象，實(shí)例化出的對(duì)象會(huì)占用實(shí)際的物理空間，存儲(chǔ)類成員變量
• 就如上述的月餅的例子，類就如一個(gè)模子，并沒(méi)有實(shí)際的存在，實(shí)例化出的對(duì)象才能實(shí)際存儲(chǔ)數(shù)據(jù)，占用物理空間

// 定義一個(gè)類
class Person{
    // 屬性（成員變量）
    public int age;
    public String name;
    // 行為（成員方法）
    public void eat(){
        System.out.println("吃飯");
        int a = 10; // 局部變量
    }
}
public class Main{
    public static void main(String[] args){
        // 通過(guò) new 實(shí)例化一個(gè)對(duì)象
        Person person = new Person();
        // 成員方法調(diào)用需要使用對(duì)象的引用調(diào)用
        person.eat();
    }
}
// 結(jié)果為：吃飯

其中 Person 為我們創(chuàng)建的類，person 為我們使用 Person 類創(chuàng)建的引用類型。關(guān)鍵字 new 用于創(chuàng)建一個(gè)對(duì)象的實(shí)例。使用 . 符號(hào)來(lái)訪問(wèn)對(duì)象中的屬性和方法（既包含讀，也包含寫）

我們可以看一下在內(nèi)存中上述代碼是怎么存儲(chǔ)的

注意 Person 類中定義的 a 是一個(gè)局部變量，因?yàn)樗诜椒ɡ锩?。而局部變量保存在棧中，而?shí)例化的對(duì)象以及該類中的類成員變量，保存在堆中

三、類的成員

類的成員可以包含：字段、方法、代碼塊、內(nèi)部類和接口等

1. 字段/屬性/成員變量

在類中但是在方法外部定義的變量，我們稱為：“字段”或“屬性”或“成員變量”（一般不嚴(yán)格區(qū)分）

我們可以對(duì)上述創(chuàng)建的對(duì)象進(jìn)行調(diào)用

class Person{
    public int age;
    public String name;
}
public class Main{
    public static void main(String[] args){
        Person person = new Person();
        System.out.println("age = " + person.age);
        System.out.println("name = " + person.name);
    }
}
// 結(jié)果為：
// age = 0
// name = null

結(jié)果居然為 0 和 null，這是因?yàn)樵?Java 中有一個(gè)默值認(rèn)規(guī)則。

如果一個(gè)對(duì)象的字段沒(méi)有設(shè)置初始值，那么就會(huì)被設(shè)置為一個(gè)默認(rèn)的值

• 對(duì)于各類數(shù)字類型，默認(rèn)值為0 或者 0.0
• 對(duì)于 boolean 類型，默認(rèn)值為 false
• 對(duì)于引用類型（String、Array、以及自定制類），默認(rèn)值為 null
• 對(duì)于 char 類型，默認(rèn)值為 ‘\u0000'

因此我們要注意，如果字段本身沒(méi)有初始值，且使用前沒(méi)有初始化，可能調(diào)用時(shí)會(huì)出現(xiàn)異常（使用引用類型時(shí)），如

class Person{
    public int age;
    public String name;
}
public class Main{
    public static void main(String[] args){
        Person person = new Person();
        System.out.println(person.name.length);
    }
}
// 會(huì)出現(xiàn) NullPointerException 異常

2. 方法

方法其實(shí)之前就專門講過(guò)了，這里就特意講兩點(diǎn)

• 如果我們要想知道我們的對(duì)象里面有什么變量、值為多少，就類似于要做一個(gè) show 方法去展示。但是如果想看的類很多，就很麻煩，這是我們可以使用一下步驟（編譯器：IDEA）

在該類的空白處，點(diǎn)擊右鍵就可以看到 Generate

• 再點(diǎn)擊它，再找到 toString() 再點(diǎn)擊就會(huì)出現(xiàn)以下代碼（以上步驟可以使用快捷鍵：Alt + Insert 實(shí)現(xiàn)）

@Override
public String toString() {
return "Person{" +
 "age=" + age +
  ", name='" + name + '\'' +
 '}';

其中 @Override 叫做重寫的注解，就解釋了這段代碼是重寫的，又 toString 屬于 objet 的方法，所以就是重寫了 object 方法

為什么要這么做呢？如果我們直接通過(guò)

System.out.println(person);
// 結(jié)果為：Person@1b6d3586

但是如果我們講上述步驟完成后結(jié)果就變成了

// 結(jié)果為：Person{age=0.0, name='null'}

這是因?yàn)樯鲜霾襟E修改了 object 類中的 toString 方法

這里我們與不重寫前的結(jié)果比較可以知道 toString 方法 @ 后一段的內(nèi)容應(yīng)該就是表示地址

因此我們通過(guò)上面步驟對(duì) toString 進(jìn)行重寫，就可以直接通過(guò)打印對(duì)象來(lái)得到該對(duì)象中的參數(shù)。并且我們將重寫內(nèi)的值改變，打印結(jié)果也會(huì)改變，如

@Override
public String toString() {
 return "Person{" +
 "年齡=" + age +
  ", 名字='" + name + '\'' +
 '}';

打印結(jié)果就會(huì)改變?yōu)?/p>

// 結(jié)果為：Person{年齡=0.0, 名字='null'}

• 還有一點(diǎn)是關(guān)于構(gòu)造方法的，下面會(huì)講到！

3. static 關(guān)鍵字

上述的成員變量以及方法其實(shí)都是普通的成員變量以及方法，在 Java 中還有一種靜態(tài)成員變量（也叫類變量）和靜態(tài)成員方法。它們是由 static 修飾的

那么 static 有什么作用呢？

1. 修飾屬性
2. 修飾方法
3. 代碼塊
4. 修飾類

修飾屬性：

如果在成員變量前加上 static，此變量就叫做靜態(tài)變量

1. 靜態(tài)變量屬于類，和具體的實(shí)例無(wú)關(guān)。也就是同一個(gè)類的不同實(shí)例公用一個(gè)靜態(tài)屬性
2. 可以直接調(diào)用靜態(tài)變量，而無(wú)需創(chuàng)建類的實(shí)例
3. 靜態(tài)變量存儲(chǔ)在方法區(qū)

我們來(lái)看一個(gè)代碼

class Person{
    public static int cnt;
    public static void speak(){
        System.out.println("我是靜態(tài)成員方法！");
    }
}
public class Main{
    public static void main(String[] args){
        System.out.println("cnt = " + Person.cnt);
        Person.speak();
    }
}
// 打印結(jié)果為：
// cnt = 0
// 我是靜態(tài)成員方法！

大家注意沒(méi)，我調(diào)用時(shí)是直接使用的類名，而不是對(duì)象名。這就是靜態(tài)變量與普通成員變量的第一點(diǎn)不同，調(diào)用時(shí)直接使用類名。

既然和實(shí)例無(wú)關(guān)那會(huì)不會(huì)靜態(tài)變量的存儲(chǔ)也會(huì)不同，我們開(kāi)看一個(gè)代碼

class Test{
    public int a;
    public static int count; 
}
public class Main{
    
    public static void main(String[] args) {
        Test t1 = new Test();
        t1.a++;
        Test.count++;
        System.out.println(t1.a);
        System.out.println(Test.count);
        System.out.println("============");
        Test t2 = new Test();
        t2.a++;
        Test.count++;
        System.out.println(t2.a);
        System.out.println(Test.count);
    }
}
// 結(jié)果為：
/**
1
1
============
1
2*/

這是因?yàn)?count 被 static 修飾后，所有類共享，并且其存儲(chǔ)區(qū)域在方法區(qū)

修飾方法：

1. 靜態(tài)方法屬于類，而不屬于類的對(duì)象
2. 可以直接調(diào)用靜態(tài)方法，而無(wú)需創(chuàng)建類的實(shí)例
3. 靜態(tài)方法只能訪問(wèn)靜態(tài)數(shù)據(jù)成員，并且可以更改靜態(tài)數(shù)據(jù)成員的值
   

看一段代碼

class Person{
    int a;
    public static int cnt;
    public static void speak(){
        cnt = 10;
        //a = 100; 會(huì)報(bào)錯(cuò)，因?yàn)樵L問(wèn)量非靜態(tài)數(shù)據(jù)成員
        System.out.println("我是靜態(tài)成員方法！");
    }
}

注意：

this 和 super 兩個(gè)關(guān)鍵字不能在靜態(tài)上下文中使用（this 是當(dāng)前實(shí)例的引用, super 是當(dāng)前實(shí)例父類實(shí)例的引用，也是和當(dāng)前實(shí)例相關(guān)）【后面會(huì)介紹到！】

小結(jié)：

就用一段代碼作為總小結(jié)吧

class Person{
    public int age; // 實(shí)例變量（屬于對(duì)象）
    public static int count; // 靜態(tài)變量，編譯時(shí)已經(jīng)產(chǎn)生（屬于類本身），只有一份且存放在方區(qū)
    public final in SIZE = 10; // 被 final 修飾的叫常量，后續(xù)不可以更改（屬于對(duì)象）
    public static final in COUNT = 99; // 靜態(tài)的常量（屬于類本身）
    // 實(shí)例成員函數(shù)
    public void eat(){
        int a = 10; //局部變量（存放在棧中）
    }
    // 靜態(tài)成員函數(shù)
    public static void staticTest(){
        //不能訪問(wèn)非靜態(tài)成員
        // age = 10; 會(huì)報(bào)錯(cuò)
        System.out.println("StaticTest()");
    }
}
public class Main{
    public static void main(String[] args){
  // 產(chǎn)生對(duì)象 實(shí)例化對(duì)象
        Person person = new Person();// person 為對(duì)象的引用
        System.out.println(person.age);// 默認(rèn)值為0
        //System.out.println(person.count);// 會(huì)有警告!
        // 正確訪問(wèn)方式：
        System.out.println(Person.count);
        System.out.println(Person.COUNT);
        Person.staticTest();
        // 總結(jié)：所有被 stati c所修飾的方法或者屬性，全部不依賴于對(duì)象。
        person.eat();
    }
}

為啥 main 函數(shù)是靜態(tài)的，如果是非靜態(tài)的可以啵，比如

class TestDemo{
    
    public void main(String[] args){
        TestDemo testDemo = new TestDemo();
        testDemo.main();
    }
}

按照非普通成員方法的形式，如果 mian 函數(shù)要調(diào)就是上述代碼吧。但大家發(fā)現(xiàn)一個(gè)問(wèn)題沒(méi)？

如果此時(shí)要使用 main 方法，就需要使用對(duì)象調(diào)用，那么好我們就在 main 方法里創(chuàng)建對(duì)象并且調(diào)用好了吧。誒？不對(duì)呀，要調(diào)用 main 方法就要使用對(duì)象??？？？可我們創(chuàng)建的對(duì)象在 main 方法里面，怎么調(diào)用？？？

所以 main 方法要加上 static ！

還有一點(diǎn)就是靜態(tài)方法里面可以調(diào)用普通方法嗎？no！

• 調(diào)用普通方法，就要用對(duì)象的引用
• 而靜態(tài)方法的使用是直接使用類，不需要?jiǎng)?chuàng)建對(duì)象
• 所以靜態(tài)方法里不能使用普通方法

四、封裝

其實(shí)上面關(guān)于類主要也就是講了類的實(shí)現(xiàn)和類的調(diào)用。如果我們以后使用了別人實(shí)現(xiàn)的類，結(jié)果后來(lái)別人修改了里面的某個(gè)變量名。人傻了？我們要一個(gè)一個(gè)修改原有的變量名嗎？

因此出現(xiàn)了一種方法叫做：封裝

封裝的本質(zhì)就是讓類的調(diào)用者不必太多了解類的實(shí)現(xiàn)者是如何實(shí)現(xiàn)類的，只要知道如何使用就行

1. private 實(shí)現(xiàn)封裝

private / public 這兩個(gè)關(guān)鍵字表示訪問(wèn)權(quán)限控制

• 被 public 修飾的成員變量或者成員方法，可以直接被類的調(diào)用者使用
• 被 private 修飾的成員變量或者方法，不能直接被類的調(diào)用者使用
  

如果我們使用 public 修飾，那么類的實(shí)現(xiàn)的代碼被修改了，可能你創(chuàng)建的代碼就要花很多精力去維護(hù)。因此在實(shí)際中，我們一般用 private，至于 public 的使用要視情況而定，并且最好一個(gè)類只提供一個(gè)必要的 public 方法

讓我們看一個(gè)代碼更好的理解上述意思

class Person{
    private int age = 13;
    private String name = "ZhangSan";
    public void show(){
        System.out.println("name = "+name + " age = "+age);
    }
    }
}
public class Main{
    public static void main(String[] args){
        Person person = new Person();
        person.show();
    }
}
// 結(jié)果為：name = ZhangSan age = 13

上述代碼就是使用了 private 修飾，所以主類里面不可以使用 age 和 name，而當(dāng)我們要輸出它們時(shí)，就可以直接使用 show 方法，無(wú)論實(shí)現(xiàn) Person 類的函數(shù)中的 name 和 age 怎么改變，都可以正常打印。

如果你想獲取或者修改這個(gè) private 屬性，那么就要用到接下來(lái)介紹的 getter / setter 方法

2. getter 和 setter 方法

使用這個(gè)方法可以在所創(chuàng)建的類中空白處右擊鼠標(biāo)，選擇 Generate，就會(huì)出現(xiàn)

然后點(diǎn)擊就可以。Getter 是獲取這個(gè)屬性，Setter 是修改這個(gè)屬性，我們用上述代碼示范

class Person{
    private double age;
    private String name;
    // 使用 setter 和 getter 方法
    public double getAge() {
        return age;
    }

    public void setAge(double age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}
public class Main{
    public static void main(String[] args){
        Person person = new Person();
        person.setAge(13);
        person.setName("張三");
        double age = getAge();
        String name = getName();
        System.out.println("姓名：" + name + " 年齡：" + age);
    }
}
// 打印結(jié)果為：姓名：張三 年齡：13

注意

大家有注意沒(méi)，上述 setter 方法的代碼

public void setAge(double age) {
   this.age = age;
}

其中 this 是啥，為啥要用它呢？首先其實(shí)這份代碼可以改成這樣

public void setAge(double Myage) {
   age = Myage;
}

其中我將形參修改了，反正 Myage 就表示我要修改成的值，如果我不修改，直接這樣可以嗎

public void setAge(double age) {
   age = age;
}

應(yīng)該不行對(duì)吧，因?yàn)榇藭r(shí)的 age 就表示該方法里面的了，不能將對(duì)象的值進(jìn)行修改。所以為我們此時(shí)引入 this

this 表示當(dāng)前對(duì)象的引用

五、構(gòu)造方法

我們要知道，使用對(duì)象時(shí)，new 執(zhí)行了兩個(gè)過(guò)程

• 為對(duì)象分配內(nèi)存
• 調(diào)用對(duì)象的構(gòu)造方法

第二點(diǎn)的構(gòu)造方法是啥？？？其實(shí)我們上述代碼都都用到啦！

因?yàn)槿绻阕约簺](méi)有創(chuàng)建構(gòu)造方法的話，編譯器會(huì)默認(rèn)提供一個(gè)不帶參數(shù)的構(gòu)造方法

那什么又是不帶參數(shù)的構(gòu)造方法呢？

1. 基本語(yǔ)法

首先我們要知道構(gòu)造方法的語(yǔ)法規(guī)則

• 方法名必須與類名相同
• 構(gòu)造方法沒(méi)有返回值
• 每一個(gè)類中至少定義一個(gè)構(gòu)造方法（沒(méi)有明確定義，系統(tǒng)會(huì)自動(dòng)生成一個(gè)無(wú)參構(gòu)造，如果自己定義了，默認(rèn)構(gòu)造將不再生成）
  

我們來(lái)看一個(gè)構(gòu)造無(wú)參的構(gòu)造方法吧！

class Person{
    private double age;
    private String name;
    
    public Person(){
        System.out.println("這是一個(gè)無(wú)參的構(gòu)造方法");
    }
}
public class Main{
    public static void main(String[] args){
        Person person = new Person();
    }
}
// 結(jié)果為：這是一個(gè)無(wú)參的構(gòu)造方法

既然有無(wú)參數(shù)的，那么也有有參數(shù)的

class Person{
    private double age;
    private String name;
    public Person(){
        System.out.println("這是一個(gè)無(wú)參的構(gòu)造方法");
    }
    public Person(double age, String name){
        this.age = age;
        this.name = name;
        System.out.println("這是一個(gè)有參的構(gòu)造方法");
    }
    public void show(){ 
  System.out.println("name: "+name+" age: "+age); 
  }
}
public class Main{
    public static void main(String[] args){
        Person person1 = new Person();
        Person person2 = new Person(13, "張三");
        person2.show();
    }
}
// 結(jié)果為：
// 這是一個(gè)無(wú)參的構(gòu)造方法 
// 這是一個(gè)有參的構(gòu)造方法
// name：張三 age：13

小結(jié)

構(gòu)造方法不僅僅可以構(gòu)造對(duì)象，同時(shí)也可以幫助我們進(jìn)行成員變量的初始化

上述代碼里面的構(gòu)造方法其實(shí)構(gòu)成了重載（方法名相同、參數(shù)列表不同、返回值不做要求）

2. this 關(guān)鍵字

其實(shí)上面已經(jīng)講了 this，但是大家要格外注意，this 是表示當(dāng)前對(duì)象的引用（注意不是當(dāng)前對(duì)象）原因如下

對(duì)象的形成要經(jīng)過(guò)兩步：1. 為對(duì)象分配內(nèi)存 2. 調(diào)用合適的構(gòu)造方法

而我們使用 this 時(shí)，其實(shí)我們已經(jīng)完成了內(nèi)存的分配，但我們并沒(méi)有完成構(gòu)造方法的調(diào)用，所以此時(shí)還不能說(shuō)創(chuàng)建了對(duì)象，只是將對(duì)象的地址得到了，也就是對(duì)象的引用

this 的用法

this.成員變量：調(diào)用成員變量
this.成員方法：調(diào)用成員方法
this() ：調(diào)用其他的構(gòu)造方法

其中調(diào)用成員變量我們上面用了很多了，接下來(lái)我們先看下調(diào)用成員方法吧！

class Person{
    private double age;
    private String name;
    public Person(double age, String name){
        this.age = age;
        this.name = name;
        System.out.println("這是一個(gè)有參的構(gòu)造方法");
    }
    public void show(){ 
  System.out.println("name: "+name+" age: "+age); 
        this.eat();
  }
    public void eat(){
        System.out.println("吃飯");
    }
}
public class Main{
    public static void main(String[] args){
        Person person = new Person(13， "張三");
        person.show();
    }
}
// 結(jié)果為：
// 這是一個(gè)有參的構(gòu)造方法
// name：張三 age：13
// 吃飯

上述代碼的 show 方法中就用到了 this 調(diào)用成員方法。接下來(lái)我們?cè)倏纯丛趺凑{(diào)用其他構(gòu)造的方法

class Person{
    private double age;
    private String name;
    public Person(){
        this(15, "李四");
        System.out.println("這是一個(gè)無(wú)參的構(gòu)造方法");
    }
    public Person(double age, String name){
        this.age = age;
        this.name = name;
        System.out.println("這是一個(gè)有參的構(gòu)造方法");
    }
    public void show(){ 
  System.out.println("name: "+name+" age: "+age); 
  }
}
public class Main{
    public static void main(String[] args){
        Person person = new Person();
        person.show();
    }
}
// 結(jié)果為：
// 這是一個(gè)有參的構(gòu)造方法
// 這是一個(gè)無(wú)參的構(gòu)造方法
// name：李四 age：15

大家看結(jié)果，自己思考下執(zhí)行的順序

注意

使用 this() 調(diào)用構(gòu)造函數(shù)，必須放在第一行
不能在靜態(tài)方法中使用

六、認(rèn)識(shí)代碼塊

1. 什么是代碼塊

代碼塊就是

根據(jù)代碼塊定義的位置以及關(guān)鍵字，可以分為四種

本地代碼塊
實(shí)例代碼塊（也叫構(gòu)造代碼塊）
靜態(tài)代碼塊
同步代碼塊（這個(gè)先不講，俺也不會(huì)）

2. 本地代碼塊

本地代碼塊是定義在方法中，比如

public class Main{ 
    public static void main(String[] args) { 
        {
        int x = 10 ; 
        System.out.println("x1 = " +x); 
        } 
        int x = 100 ; 
        System.out.println("x2 = " +x); 
    } 
}

這個(gè)在 C 語(yǔ)言里也見(jiàn)過(guò)，但幾乎沒(méi)用過(guò)

3. 實(shí)例代碼塊

構(gòu)造代碼塊是定義在類中（且不加修飾符）

一般用于初始化實(shí)例成員變量

class Person{
    private double age;
    private String name;
    public Person(){
        System.out.println("這是一個(gè)無(wú)參的構(gòu)造方法");
    }
    // 實(shí)例代碼塊
    {
        this.name = "Yb";
        this.age = 15;
        System.out.println("實(shí)例代碼塊");
    }
   
}
public class Main{
    public static void main(String[] args){
        Person person = new Person();
    }
}

4. 靜態(tài)代碼塊

靜態(tài)代碼塊是定義在類中（且加上 static 修飾）

一般用于初始化靜態(tài)成員屬性和需要提前準(zhǔn)備的一些數(shù)據(jù)

class Person{
    private double age;
    private String name;
    public Person(){
        System.out.println("這是一個(gè)無(wú)參的構(gòu)造方法");
    }
 // 實(shí)例代碼塊
    {
使用 {} 定義的一段代碼
        this.name = "Yb";
        this.age = 15;
        System.out.println("實(shí)例代碼塊");
    } 
    // 靜態(tài)代碼塊
    static{
        // 不能用 this
        // this.age = 15; 會(huì)報(bào)錯(cuò)
        System.out.println("靜態(tài)代碼塊");
    }
}
public class Main{
    public static void main(String[] args){
        Person person1 = new Person();
        Person person2 = new Person();
    }
}
// 結(jié)果為：
/**
靜態(tài)代碼塊
實(shí)例代碼塊
這是一個(gè)無(wú)參的構(gòu)造函數(shù)
實(shí)例代碼塊
這是一個(gè)無(wú)參的構(gòu)造函數(shù)
*/

注意：上述代碼的打印結(jié)果，是先實(shí)行靜態(tài)代碼塊，再實(shí)行實(shí)例代碼塊，最后才執(zhí)行構(gòu)造函數(shù)，并且在同一個(gè)類中，靜態(tài)代碼塊不管生成多少對(duì)象，只會(huì)執(zhí)行一次

七、補(bǔ)充說(shuō)明

1. toString 方法

其實(shí)上面已經(jīng)講到了，重寫 object 的 toString 方法，將對(duì)象自動(dòng)轉(zhuǎn)換成字符串，因此不需要使用 show 方法去查看對(duì)象的參數(shù)

因此這里就再重述一些知識(shí)點(diǎn)

• toString 方法會(huì)在使用 println 的時(shí)候被自動(dòng)調(diào)用
• 將對(duì)象轉(zhuǎn)換成字符串這樣的操作叫做序列化
• toString 使 Object 提供的方法，我們自己創(chuàng)建的 Person 類默認(rèn)繼承了 Object 類，可以重寫 toString 方法實(shí)現(xiàn)我們自己的版本
• @Override 在 Java 中稱為注釋，上述代碼中的 @Override 表示下面實(shí)現(xiàn)的 tostring 方法使重寫了父類的方法

2. 匿名對(duì)象

匿名對(duì)象顧名思義是表示沒(méi)有名字的對(duì)象，即沒(méi)有引用對(duì)象，可以看下面的代碼

// 不使用匿名對(duì)象
Person person = new Person();
person.eat();
// 使用匿名對(duì)象
new Person().eat();

并且如果一個(gè)對(duì)象只是用一次，后面不需要使用了，可以考慮使用匿名對(duì)象.。理由如下

// 不使用匿名對(duì)象
Person person = new Person();
person.eat();
person.show();
// 使用匿名對(duì)象
new Person().eat();
new Person().show();

其中我們注意到，不使用匿名對(duì)象的代碼，只需要 new 一個(gè)對(duì)象就行，而使用匿名對(duì)象的代碼，其實(shí) new 了兩個(gè)對(duì)象

還有匿名對(duì)象只能在創(chuàng)建對(duì)象時(shí)使用，就是說(shuō)創(chuàng)建匿名對(duì)象就要使用它

八、總結(jié)

最好我們?cè)賮?lái)鞏固幾個(gè)問(wèn)題吧！

（1）引用一定在棧上嗎？ 不一定

我們來(lái)看一段代碼

class Person{
    private double age;
    private String name;
 private int[] elem = new int[10];
}
public class Main{
    public static void main(String[] args){
        Person person = new Person();
    }
}

我們用一張圖來(lái)清晰感受下吧

其中 person是一個(gè)引用它在棧上，而 elem 是數(shù)組，它也是引用，可是它卻存放在堆中，所以引用不一定在棧上

（2）引用能指向引用嗎？ 不能

之前就講過(guò)了，引用不能指向引用，這個(gè)說(shuō)法不對(duì)。正確的說(shuō)法應(yīng)該是，該引用指向了另一個(gè)引用所指向的對(duì)象

一個(gè)引用可以指向多個(gè)對(duì)象嗎？ 不能

（3）一個(gè)引用可以指向多個(gè)對(duì)象嗎？ 不能

這不就是海王了嘛，比如 person 去找對(duì)象

Person person = new Person(); // person 先找了一個(gè)對(duì)象
person = new Person(); // 然后又找了一個(gè)
person = new Person(); // 牛逼！又找了一個(gè)
person = new Person(); // 佩服！還找了一個(gè)

你問(wèn) perosn 有幾個(gè)對(duì)象，我告訴你，就一個(gè)，而且還是最后一個(gè)，你問(wèn)我為啥？海外必死

（4）一個(gè)引用賦值null 代表什么?

代表當(dāng)前引用不指向任何對(duì)象

（5）你能用上述知識(shí)寫一個(gè)代碼實(shí)現(xiàn)交換兩個(gè)值嗎？

class Value{
    private int val;

    public int getVal() {
        return val;
    }

    public void setVal(int val) {
        this.val = val;
    }
}
public class TestDemo{
    public static void swap(Value val1, Value val2){
        int tmp = val1.getVal();
        val1.setVal(val2.getVal());
        val2.setVal(tmp);
    }
    public static void main(String[] args) {
        Value value1 = new Value();
        value1.setVal(10);
        Value value2 = new Value();
        value2.setVal(20);
        System.out.println("交換前：value1 = " + value1.getVal() + " value2 = " + value2.getVal());
        swap(value1,value2);
        System.out.println("交換前：value1 = " + value1.getVal() + " value2 = " + value2.getVal());
    }
}
/**結(jié)果為：
交換前：value1 = 10 value2 = 20
交換前：value1 = 20 value2 = 10*/

到此這篇關(guān)于Java 基礎(chǔ)語(yǔ)法讓你弄懂類和對(duì)象的文章就介紹到這了,更多相關(guān)Java 基礎(chǔ)語(yǔ)法內(nèi)容請(qǐng)搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

最新評(píng)論