Java - 構造方法

---

---

Java 構造方法

Java 構造方法是用於在建立物件時初始化該物件的特殊型別的方法。它與類名相同，並且在語法上類似於方法。但是，構造方法沒有顯式的返回型別。

通常，您將使用構造方法為類定義的例項變數提供初始值，或執行建立完整形成的物件所需的任何其他啟動過程。

所有類都具有構造方法，無論您是否定義了一個，因為 Java 自動提供一個預設構造方法，該構造方法將所有成員變數初始化為零。但是，一旦您定義了自己的構造方法，便不再使用預設構造方法。

建立 Java 構造方法的規則

在建立 Java 構造方法時，必須遵循以下規則

• 構造方法的名稱必須與類名相同。
• Java 構造方法沒有返回型別。甚至不要使用 void 作為返回型別。
• 同一個類中可以有多個構造方法，這個概念稱為構造方法過載。
• 可以使用訪問修飾符與構造方法一起使用，如果您想更改構造方法的可見性/可訪問性，請使用它們。
• Java 提供了一個在物件建立期間呼叫的預設構造方法。如果您建立任何型別的構造方法，則不會呼叫預設構造方法（由 Java 提供）。

建立 Java 構造方法

要在 Java 中建立構造方法，只需編寫構造方法的名稱（與類名相同），後跟括號，然後在花括號 ({}) 內編寫構造方法的主體。

語法

以下是構造方法的語法：

class ClassName {
   ClassName() {
   }
}

建立 Java 構造方法的示例

以下示例建立了一個簡單的構造方法，它將列印“Hello world”。

public class Main {
  // Creating a constructor
  Main() {
    System.out.println("Hello, World!");
  }

  public static void main(String[] args) {
    System.out.println("The main() method.");

    // Creating a class's object
    // that will invoke the constructor
    Main obj_x = new Main();
  }
}

此程式將列印

The main() method.
Hello, World!

Java 構造方法的型別

Java 中有三種不同的構造方法型別，我們已將其列出如下

• 預設構造方法
• 無參構造方法
• 帶參構造方法

1. 預設構造方法

如果您沒有在類中建立任何構造方法，則 Java 會提供一個預設構造方法來初始化物件。

示例：預設構造方法（沒有構造方法的類）

在此示例中，我們沒有定義任何構造方法。預設構造方法用於初始化物件。

public class Main {
  int num1;
  int num2;

  public static void main(String[] args) {
    // We didn't created any structure
    // a default constructor will invoke here
    Main obj_x = new Main();

    // Printing the values
    System.out.println("num1 : " + obj_x.num1);
    System.out.println("num2 : " + obj_x.num2);
  }
}

輸出

num1 : 0
num2 : 0

2. 無參（無引數）構造方法

顧名思義，無引數構造方法不接受任何引數。透過使用無參構造方法，您可以初始化類資料成員並執行您希望在物件建立時執行的各種活動。

示例：無參構造方法

此示例建立了一個無參構造方法。

public class Main {
  int num1;
  int num2;

  // Creating no-args constructor
  Main() {
    num1 = -1;
    num2 = -1;
  }

  public static void main(String[] args) {
    // no-args constructor will invoke
    Main obj_x = new Main();

    // Printing the values
    System.out.println("num1 : " + obj_x.num1);
    System.out.println("num2 : " + obj_x.num2);
  }
}

輸出

num1 : -1
num2 : -1

3. 帶參構造方法

帶有一個或多個引數的構造方法稱為帶參構造方法。

大多數情況下，您將需要一個接受一個或多個引數的構造方法。引數以與新增到方法相同的方式新增到構造方法中，只需在構造方法名稱後的括號內宣告它們。

示例 1：帶參構造方法

此示例建立了一個帶參構造方法。

public class Main {
  int num1;
  int num2;

  // Creating parameterized constructor 
  Main(int a, int b) {
    num1 = a;
    num2 = b;
  }

  public static void main(String[] args) {
    // Creating two objects by passing the values 
    // to initialize the attributes.
    // parameterized constructor will invoke
    Main obj_x = new Main(10, 20);
    Main obj_y = new Main(100, 200);

    // Printing the objects values
    System.out.println("obj_x");
    System.out.println("num1 : " + obj_x.num1);
    System.out.println("num2 : " + obj_x.num2);

    System.out.println("obj_y");
    System.out.println("num1 : " + obj_y.num1);
    System.out.println("num2 : " + obj_y.num2);
  }
}

輸出

obj_x
num1 : 10
num2 : 20
obj_y
num1 : 100
num2 : 200

示例 2：帶參構造方法

這是一個使用構造方法的簡單示例：

// A simple constructor.
class MyClass {
   int x;
   
   // Following is the constructor
   MyClass(int i ) {
      x = i;
   }
}

您可以按如下方式呼叫構造方法來初始化物件：

public class ConsDemo {
   public static void main(String args[]) {
      MyClass t1 = new MyClass( 10 );
      MyClass t2 = new MyClass( 20 );
      System.out.println(t1.x + " " + t2.x);
   }
}

輸出

10 20

Java 中的構造方法過載

構造方法過載意味著一個類中的多個構造方法。當您有多個具有不同引數列表的構造方法時，則稱為構造方法過載。

示例：構造方法過載

在此示例中，我們有多個構造方法。

// Example of Java Constructor Overloading
// Creating a Student Class
class Student {
  String name;
  int age;

  // no-args constructor
  Student() {
    this.name = "Unknown";
    this.age = 0;
  }

  // parameterized constructor having one parameter
  Student(String name) {
    this.name = name;
    this.age = 0;
  }

  // parameterized constructor having both parameters
  Student(String name, int age) {
    this.name = name;
    this.age = age;
  }

  public void printDetails() {
    System.out.println("Name : " + this.name);
    System.out.println("Age : " + this.age);
  }
}

public class Main {
  public static void main(String[] args) {
    Student std1 = new Student(); // invokes no-args constructor
    Student std2 = new Student("Jordan"); // invokes parameterized constructor
    Student std3 = new Student("Paxton", 25); // invokes parameterized constructor

    // Printing details
    System.out.println("std1...");
    std1.printDetails();

    System.out.println("std2...");
    std2.printDetails();

    System.out.println("std3...");
    std3.printDetails();
  }
}

輸出

td1...
Name : Unknown
Age : 0
std2...
Name : Jordan
Age : 0
std3...
Name : Paxton
Age : 25