Java 基礎語法

其實在學習 C 語言時就一直聽到 C 語言是面向過程的，而 Java 是面向對象的這句話。并且我們之前的學習中也遇到了類，但是對它好像沒有其他的認知。
那么面向過程與面向對象到底是什么呢？它們有哪些不同的意義呢？

類與對象到底是什么呢？這章就來帶你揭曉！

一、類與對象的初步認知

我們可以舉一個洗衣服的例子來認識面向對象和面向過程

對于面向過程： 我們可以看成是手洗衣服的過程

對于面向對象： 我們可以看作直接用洗衣機去洗

其中總共有四個對象：人、衣服、洗衣粉、洗衣機
而整個洗衣服的過程就是：人將衣服放進洗衣機、人倒入洗衣粉、人啟動洗衣

因此整個過程主要就是上述四個對象之間交互完成的，人不需要關心洗衣機具體是如何洗衣服并且甩干的

因此對于面向對象，重點就是

找對象
創建對象
使用對象

那么對象從何而來呢？它其實是由類的實例化產生的

下面讓我們來了解類以及類的實例化吧！

二、類和類的實例化

類

就是一類對象的統稱

對象

就是這一類具體化的一個實例

舉個栗子講講

比如我們做月餅的模子就是一個類，而通過這個模子可以做出月餅。那么在這個例子中，做月餅的模子就是類，而那個月餅就是對象。并且一個月餅就是一個實體，而一個模子可以實例化無數個對象，也就是說一個類可以產生無數的對象

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

聲明一個類就是創建一個新的數據類型（感覺類似于 C 語言中的 struct）
類在 Java 中屬于引用類型
Java 使用關鍵字 class 來聲明類，并且類中可以定義一些屬性和行為

上個代碼看看

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

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

注意：

此處寫的方法不帶關鍵字 static

類的實例化

用類類型創建對象的過程，稱為類的實例化

我們要理解

• 類只是一個模型一樣的東西，限定了類有哪些成員變量
• 一個類可以實例化出多個對象，實例化出的對象會占用實際的物理空間，存儲類成員變量
• 就如上述的月餅的例子，類就如一個模子，并沒有實際的存在，實例化出的對象才能實際存儲數據，占用物理空間

// 定義一個類
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){
      // 通過 new 實例化一個對象
      Person person = new Person();
      // 成員方法調用需要使用對象的引用調用
      person.eat();
  }
}
// 結果為：吃飯

其中 Person 為我們創建的類，person 為我們使用 Person 類創建的引用類型。關鍵字 new 用于創建一個對象的實例。使用 . 符號來訪問對象中的屬性和方法（既包含讀，也包含寫）

我們可以看一下在內存中上述代碼是怎么存儲的

注意 Person 類中定義的 a 是一個局部變量，因為它在方法里面。而局部變量保存在棧中，而實例化的對象以及該類中的類成員變量，保存在堆中

三、類的成員

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

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

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

我們可以對上述創建的對象進行調用

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);
  }
}
// 結果為：
// age = 0
// name = null

結果居然為 0 和 null，這是因為在 Java 中有一個默值認規則。

如果一個對象的字段沒有設置初始值，那么就會被設置為一個默認的值

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

因此我們要注意，如果字段本身沒有初始值，且使用前沒有初始化，可能調用時會出現異常（使用引用類型時），如

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);
  }
}
// 會出現 NullPointerException 異常

2. 方法

方法其實之前就專門講過了，這里就特意講兩點

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

在該類的空白處，點擊右鍵就可以看到 Generate

• 再點擊它，再找到 toString() 再點擊就會出現以下代碼（以上步驟可以使用快捷鍵：Alt + Insert 實現）

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

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

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

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

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

// 結果為：Person{age=0.0, name='null'}

這是因為上述步驟修改了 object 類中的 toString 方法

這里我們與不重寫前的結果比較可以知道 toString 方法 @ 后一段的內容應該就是表示地址

因此我們通過上面步驟對 toString 進行重寫，就可以直接通過打印對象來得到該對象中的參數。并且我們將重寫內的值改變，打印結果也會改變，如

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

打印結果就會改變為

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

• 還有一點是關于構造方法的，下面會講到！

3. static 關鍵字

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

那么 static 有什么作用呢？

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

修飾屬性：

如果在成員變量前加上 static，此變量就叫做靜態變量

1. 靜態變量屬于類，和具體的實例無關。也就是同一個類的不同實例公用一個靜態屬性
2. 可以直接調用靜態變量，而無需創建類的實例
3. 靜態變量存儲在方法區

我們來看一個代碼

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

大家注意沒，我調用時是直接使用的類名，而不是對象名。這就是靜態變量與普通成員變量的第一點不同，調用時直接使用類名。

既然和實例無關那會不會靜態變量的存儲也會不同，我們開看一個代碼

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);
  }
}
// 結果為：
/**
1
1
============
1
2*/

這是因為 count 被 static 修飾后，所有類共享，并且其存儲區域在方法區

修飾方法：

1. 靜態方法屬于類，而不屬于類的對象
2. 可以直接調用靜態方法，而無需創建類的實例
3. 靜態方法只能訪問靜態數據成員，并且可以更改靜態數據成員的值

看一段代碼

class Person{
  int a;
  public static int cnt;
  public static void speak(){
      cnt = 10;
      //a = 100; 會報錯，因為訪問量非靜態數據成員
      System.out.println("我是靜態成員方法！");
  }
}

注意：

this 和 super 兩個關鍵字不能在靜態上下文中使用（this 是當前實例的引用, super 是當前實例父類實例的引用，也是和當前實例相關）【后面會介紹到！】

小結：

就用一段代碼作為總小結吧

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

為啥 main 函數是靜態的，如果是非靜態的可以啵，比如

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

按照非普通成員方法的形式，如果 mian 函數要調就是上述代碼吧。但大家發現一個問題沒？

如果此時要使用 main 方法，就需要使用對象調用，那么好我們就在 main 方法里創建對象并且調用好了吧。誒？不對呀，要調用 main 方法就要使用對象啊？？？可我們創建的對象在 main 方法里面，怎么調用？？？

所以 main 方法要加上 static ！

還有一點就是靜態方法里面可以調用普通方法嗎？no！

• 調用普通方法，就要用對象的引用
• 而靜態方法的使用是直接使用類，不需要創建對象
• 所以靜態方法里不能使用普通方法

四、封裝

其實上面關于類主要也就是講了類的實現和類的調用。如果我們以后使用了別人實現的類，結果后來別人修改了里面的某個變量名。人傻了？我們要一個一個修改原有的變量名嗎？

因此出現了一種方法叫做：封裝

封裝的本質就是讓類的調用者不必太多了解類的實現者是如何實現類的，只要知道如何使用就行

1. private 實現封裝

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

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

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

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

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();
  }
}
// 結果為：name = ZhangSan age = 13

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

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

2. getter 和 setter 方法

使用這個方法可以在所創建的類中空白處右擊鼠標，選擇 Generate，就會出現

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

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);
  }
}
// 打印結果為：姓名：張三 年齡：13

注意

大家有注意沒，上述 setter 方法的代碼

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

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

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

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

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

應該不行對吧，因為此時的 age 就表示該方法里面的了，不能將對象的值進行修改。所以為我們此時引入 this

this 表示當前對象的引用

五、構造方法

我們要知道，使用對象時，new 執行了兩個過程

• 為對象分配內存
• 調用對象的構造方法

第二點的構造方法是啥？？？其實我們上述代碼都都用到啦！

因為如果你自己沒有創建構造方法的話，編譯器會默認提供一個不帶參數的構造方法

那什么又是不帶參數的構造方法呢？

1. 基本語法

首先我們要知道構造方法的語法規則

• 方法名必須與類名相同
• 構造方法沒有返回值
• 每一個類中至少定義一個構造方法（沒有明確定義，系統會自動生成一個無參構造，如果自己定義了，默認構造將不再生成）

我們來看一個構造無參的構造方法吧！

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

既然有無參數的，那么也有有參數的

class Person{
  private double age;
  private String name;
  public Person(){
      System.out.println("這是一個無參的構造方法");
  }
  public Person(double age, String name){
      this.age = age;
      this.name = name;
      System.out.println("這是一個有參的構造方法");
  }
  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();
  }
}
// 結果為：
// 這是一個無參的構造方法 
// 這是一個有參的構造方法
// name：張三 age：13

小結

構造方法不僅僅可以構造對象，同時也可以幫助我們進行成員變量的初始化

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

2. this 關鍵字

其實上面已經講了 this，但是大家要格外注意，this 是表示當前對象的引用（注意不是當前對象）原因如下

對象的形成要經過兩步：1. 為對象分配內存 2. 調用合適的構造方法

而我們使用 this 時，其實我們已經完成了內存的分配，但我們并沒有完成構造方法的調用，所以此時還不能說創建了對象，只是將對象的地址得到了，也就是對象的引用

this 的用法

this.成員變量：調用成員變量
this.成員方法：調用成員方法
this() ：調用其他的構造方法

其中調用成員變量我們上面用了很多了，接下來我們先看下調用成員方法吧！

class Person{
  private double age;
  private String name;
  public Person(double age, String name){
      this.age = age;
      this.name = name;
      System.out.println("這是一個有參的構造方法");
  }
  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();
  }
}
// 結果為：
// 這是一個有參的構造方法
// name：張三 age：13
// 吃飯

上述代碼的 show 方法中就用到了 this 調用成員方法。接下來我們再看看怎么調用其他構造的方法

class Person{
  private double age;
  private String name;
  public Person(){
      this(15, "李四");
      System.out.println("這是一個無參的構造方法");
  }
  public Person(double age, String name){
      this.age = age;
      this.name = name;
      System.out.println("這是一個有參的構造方法");
  }
  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();
  }
}
// 結果為：
// 這是一個有參的構造方法
// 這是一個無參的構造方法
// name：李四 age：15

大家看結果，自己思考下執行的順序

注意

使用 this() 調用構造函數，必須放在第一行
不能在靜態方法中使用

六、認識代碼塊

1. 什么是代碼塊

代碼塊就是

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

本地代碼塊
實例代碼塊（也叫構造代碼塊）
靜態代碼塊
同步代碼塊（這個先不講，俺也不會）

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); 
  } 
}

這個在 C 語言里也見過，但幾乎沒用過

3. 實例代碼塊

構造代碼塊是定義在類中（且不加修飾符）

一般用于初始化實例成員變量

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

4. 靜態代碼塊

靜態代碼塊是定義在類中（且加上 static 修飾）

一般用于初始化靜態成員屬性和需要提前準備的一些數據

class Person{
  private double age;
  private String name;
  public Person(){
      System.out.println("這是一個無參的構造方法");
  }
// 實例代碼塊
  {

使用 {} 定義的一段代碼

this.name = "Yb"; this.age = 15; System.out.println("實例代碼塊"); } // 靜態代碼塊 static{ // 不能用 this // this.age = 15; 會報錯 System.out.println("靜態代碼塊"); } } public class Main{ public static void main(String[] args){ Person person1 = new Person(); Person person2 = new Person(); } } // 結果為： /** 靜態代碼塊 實例代碼塊 這是一個無參的構造函數 實例代碼塊 這是一個無參的構造函數 */

注意：上述代碼的打印結果，是先實行靜態代碼塊，再實行實例代碼塊，最后才執行構造函數，并且在同一個類中，靜態代碼塊不管生成多少對象，只會執行一次

七、補充說明

1. toString 方法

其實上面已經講到了，重寫 object 的 toString 方法，將對象自動轉換成字符串，因此不需要使用 show 方法去查看對象的參數

因此這里就再重述一些知識點

• toString 方法會在使用 println 的時候被自動調用
• 將對象轉換成字符串這樣的操作叫做序列化
• toString 使 Object 提供的方法，我們自己創建的 Person 類默認繼承了 Object 類，可以重寫 toString 方法實現我們自己的版本
• @Override 在 Java 中稱為注釋，上述代碼中的 @Override 表示下面實現的 tostring 方法使重寫了父類的方法

2. 匿名對象

匿名對象顧名思義是表示沒有名字的對象，即沒有引用對象，可以看下面的代碼

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

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

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

其中我們注意到，不使用匿名對象的代碼，只需要 new 一個對象就行，而使用匿名對象的代碼，其實 new 了兩個對象

還有匿名對象只能在創建對象時使用，就是說創建匿名對象就要使用它

八、總結

最好我們再來鞏固幾個問題吧！

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

我們來看一段代碼

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();
  }
}

我們用一張圖來清晰感受下吧

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

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

之前就講過了，引用不能指向引用，這個說法不對。正確的說法應該是，該引用指向了另一個引用所指向的對象

一個引用可以指向多個對象嗎？ 不能

（3）一個引用可以指向多個對象嗎？ 不能

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

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

你問 perosn 有幾個對象，我告訴你，就一個，而且還是最后一個，你問我為啥？海外必死

 

（4）一個引用賦值null 代表什么?

代表當前引用不指向任何對象

（5）你能用上述知識寫一個代碼實現交換兩個值嗎？

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());
  }
}
/**結果為：
交換前：value1 = 10 value2 = 20
交換前：value1 = 20 value2 = 10*/

到此這篇關于Java 基礎語法讓你弄懂類和對象的文章就介紹到這了,更多相關Java 基礎語法內容請搜索服務器之家以前的文章或繼續瀏覽下面的相關文章希望大家以后多多支持服務器之家！

原文鏈接：https://blog.csdn.net/weixin_51367845/article/details/119881437