Day31--構造器詳解

1hahahahahahahaha發表於2024-11-07

Day31--構造器詳解

使用 new 關鍵字建立物件。使用 new 關鍵字建立的時候,除了分配記憶體空間之外,還會給建立好的物件進行預設的初始化以及對類中構造器的呼叫。

類中的構造器也稱為構造方法,是在進行建立物件的時候必須要呼叫的。並且構造器有以下兩個特點:

  1. 必須和類的名字相同;
    \2. 必須沒有返回型別,也不能寫 void。

構造器必須要掌握!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

構造器的快捷鍵:alt+insert ------>建構函式

​ 如果想要定義無參構造器,就是alt+insert ------>建構函式------->無選擇

舉例理解:

我在下面的程式碼裡面,建立了Person方法,方法和類名相同,沒有引數

package com.liu.oop.demo02;

public class Person {

    //一個類即使什麼都不寫,也會存在一個方法
    //顯示的定義構造器
    //無參構造; 沒有引數的構造
    public Person(){}
}

在同一個包的Application類裡面,就可以呼叫這個方法了

package com.liu.oop.demo02;

//一個專案只應該有一個main方法,我們在這裡把他放在Application裡
public class Application {
    public static void main(String[] args) {
        //new例項化了一個物件
        Person person = new Person();
    }
}

上面講的是無參構造器

下面是有參構造器:

//有參構造
    public Person(String name){
            this.name=name;
    }

this.name=name;

在右邊的name,是傳入的name,

左邊的name,指的是屬性name

一旦定義了有參構造,無參構造就必須要顯示定義,否則就會報錯

可以這樣看:

當無參構造刪除掉之後,Application就立刻報錯了

package com.liu.oop.demo02;

public class Person {

        String name;
    //一個類即使什麼都不寫,也會存在一個方法
    //顯示的定義構造器
    //無參構造; 沒有引數的構造


    //無參構造
    //例項化初始值
    //使用new關鍵字,本質是在呼叫構造器
//    public Person() {
//        this.name = "哈哈";
//    }

    //有參構造
    //一旦定義了有參構造,無參構造就必須要顯示定義,否則就會報錯
    public Person(String name){
            this.name=name;
    }
}

package com.liu.oop.demo02;

//一個專案只應該有一個main方法,我們在這裡把他放在Application裡
public class Application {
    public static void main(String[] args) {
        //new例項化了一個物件
        Person person = new Person();

        System.out.println(person.name);//哈哈

    }
}

錯誤原因:java: 無法將類 com.liu.oop.demo02.Person中的構造器 Person應用到給定型別;
需要: java.lang.String
找到: 沒有引數
原因: 實際引數列表和形式引數列表長度不同

解決方法:

當我們定義了一個實參構造器之後,就再定義一個空的無參構造器,就像這樣

public Person() {
    }

構造器

//1.使用new關鍵字,本質是在呼叫構造器
//2.初始化值

好奇怪啊, public Person(){}

類的首字母可以大寫了嗎?在java裡面,方法的名稱可以與類的名稱一樣嗎?

深入理解:

  1. 程式碼分析

    • 在你的程式碼中,你並沒有建立一個名為Person的方法,而是建立了一個名為Person的類,並且這個類中有一個無參構造器。在Java中,構造器是一種特殊的方法,用於建立和初始化物件。它的名字必須與類名相同,並且沒有返回型別(甚至不能寫void)。你的public Person(){}就是這樣一個構造器,它用於建立Person類的物件,當你使用new Person()來例項化一個Person物件時,就會呼叫這個無參構造器。這就是為什麼在IDEA中沒有顯示錯誤的原因。
  2. 方法名稱與類名是否可以相同

    • (1)構造器:構造器的名稱必須與類名相同。構造器用於初始化類的新物件,這是Java語法的規定。例如,對於類Student,其構造器可以是public Student()或者public Student(int age, String name)等形式,名字必須是Student

    • (2)普通方法:普通方法的名稱可以與類名相同,但這可能會引起混淆。不過在一些特定的設計模式或者程式碼結構中,這種命名方式是被允許的。例如,在一些工廠方法模式的實現中,可能會有一個與類名相同的靜態工廠方法,用於建立該類的物件。例如:

      • class MyClass {
            public static MyClass MyClass() {
                return new MyClass();
            }
        }
        
        • 這裡定義了一個名為MyClass的靜態方法,它返回一個MyClass型別的物件。這種用法雖然不太常見,但在某些情況下是合理的。
  3. 方法名稱首字母是否可以大寫

    • 方法名稱首字母可以大寫。在Java中,方法名遵循識別符號命名規則,即可以包含字母、數字、下劃線(_)和美元符號($),並且不能以數字開頭。雖然通常建議方法名採用小寫字母開頭的駝峰命名法(如calculateSum),但大寫字母開頭的方法名也是合法的。例如,public void CalculateTax()這樣的方法定義是合法的,不過這種命名方式不符合Java的常見命名習慣,可能會讓其他開發者在閱讀程式碼時產生誤解。

在構造器裡面進行賦值:

package com.liu.oop.demo02;

public class Person {

        String name;
    //一個類即使什麼都不寫,也會存在一個方法
    //顯示的定義構造器
    //無參構造; 沒有引數的構造

    //構造器的作用:例項化初始值
    public Person(){
        this.name="哈哈";
    }
}

package com.liu.oop.demo02;

//一個專案只應該有一個main方法,我們在這裡把他放在Application裡
public class Application {
    public static void main(String[] args) {
        //new例項化了一個物件
        Person person = new Person();

        System.out.println(person.name);//哈哈

    }
}

一個小擴充:

在Person類裡面建立了name屬性

package com.liu.oop.demo02;

public class Person {

        String name;
    //一個類即使什麼都不寫,也會存在一個方法
    //顯示的定義構造器
    //無參構造; 沒有引數的構造
    public Person(){}
}

在Application類裡輸出name屬性:

快捷鍵:people.name.sout System.out.println(person.name);

package com.liu.oop.demo02;

//一個專案只應該有一個main方法,我們在這裡把他放在Application裡
public class Application {
    public static void main(String[] args) {
        //new例項化了一個物件
        Person person = new Person();
        
        System.out.println(person.name);
    }
}

總結:

構造器:

  1. 和類名相同。

  2. 沒有返回值。

作用:

  1. new 本質在呼叫構造方法。
  2. 初始化物件的值。

注意點:

  1. 定義有參構造之後,如果想使用無參構造,顯示的定義一個無參的構造。
    Alt + Insert。

再詳細學一下

  1. 構造器的基本概念

    • 構造器(Constructor)是一種特殊的方法,用於建立和初始化物件。它的主要作用是在建立物件時,為物件的成員變數賦初始值,確保物件在使用前處於一個合理的初始狀態。構造器的名稱必須與類名相同,並且沒有返回型別(不能寫void)。
  2. 無參構造器示例

    • 以下是一個簡單的Person類,包含一個無參構造器:

      • class Person {
            private String name;
            private int age;
            //無參構造器
            public Person() {
                name = "未命名";
                age = 0;
            }
        }
        
      • 在這個例子中,Person類有兩個私有成員變數nameage。無參構造器public Person()在建立Person物件時被呼叫,它將name初始化為“未命名”,age初始化為0。例如,你可以這樣建立Person物件:

        • public class Main {
              public static void main(String[] args) {
                  Person person = new Person();
                  System.out.println("姓名:" + person.name + ",年齡:" + person.age);
              }
          }
          
        • 輸出結果為:“姓名:未命名,年齡:0”。

  3. 有參構造器示例

    • (1)基本使用

      • 可以為Person類新增有參構造器,用於根據傳入的引數初始化物件。例如:

        • class Person {
              private String name;
              private int age;
              //有參構造器
              public Person(String name, int age) {
                  this.name = name;
                  this.age = age;
              }
          }
          
      • 這裡的有參構造器public Person(String name, int age)接受兩個引數,一個是String型別的name,另一個是int型別的age。在構造器內部,使用this關鍵字來區分成員變數和引數。this.name表示物件的成員變數namename(沒有this)表示傳入的引數。現在可以使用有參構造器建立Person物件:

        • public class Main {
              public static void main(String[] args) {
                  Person person = new Person("張三", 20);
                  System.out.println("姓名:" + person.name + ",年齡:" + person.age);
              }
          }
          
        • 輸出結果為:“姓名:張三,年齡:20”。

    • (2)構造器的過載

      • 在一個類中可以有多個構造器,只要它們的引數列表不同(引數個數、引數型別或者引數順序不同),這就是構造器的過載。例如,為Person類新增另一個有參構造器:

        • class Person {
              private String name;
              private int age;
              //有參構造器1
              public Person(String name, int age) {
                  this.name = name;
                  this.age = age;
              }
              //有參構造器2
              public Person(String name) {
                  this.name = name;
                  this.age = 18;
              }
          }
          
      • 第二個有參構造器public Person(String name)只接受一個String型別的引數name,並將age預設設定為18。這樣就可以根據不同的需求選擇不同的構造器來建立物件:

        • public class Main {
              public static void main(String[] args) {
                  Person person1 = new Person("李四", 22);
                  System.out.println("姓名:" + person1.name + ",年齡:" + person1.age);
                  Person person2 = new Person("王五");
                  System.out.println("姓名:" + person2.name + ",年齡:" + person2.age);
              }
          }
          
        • 輸出結果為:“姓名:李四,年齡:22”和“姓名:王五,年齡:18”。

  4. 預設構造器

    • 如果一個類沒有顯式地定義構造器,Java編譯器會自動為這個類生成一個預設構造器。這個預設構造器是無參的,並且它會將物件的成員變數初始化為預設值(例如,對於基本資料型別,int型別初始化為0,boolean型別初始化為false等;對於引用資料型別,初始化為null)。例如:

      • class Book {
            private String title;
            private int pageCount;
        }
        
      • 雖然這裡沒有定義構造器,但Java編譯器會自動生成一個預設構造器。可以像這樣使用:

        • public class Main {
              public static void main(String[] args) {
                  Book book = new Book();
                  System.out.println("書名:" + book.title + ",頁數:" + book.pageCount);
              }
          }
          
          • 輸出結果為:“書名:null,頁數:0”。不過,一旦你在類中顯式地定義了任何一個構造器,Java編譯器就不會再為你自動生成預設構造器。

相關文章