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