Java 构造函数

Java 构造函数 是方法，用于在创建对象时对其进行初始化。它与其类具有相同的名称，并且在语法上类似于方法。但是，构造函数没有显式返回类型。

通常，您将使用构造函数为实例赋予初始值变量由类定义或执行创建完全形成的对象所需的任何其他启动过程。

所有类都有构造函数，无论您是否定义一个构造函数，因为 Java 自动提供了一个默认构造函数将所有成员变量初始化为零。但是，一旦定义构造函数，就不再使用默认构造函数。

创建 Java 构造函数的规则

创建 Java 构造函数时必须遵循以下规则:

构造函数的名称必须与类名称相同。
Java 构造函数没有返回类型。甚至不使用 void 作为返回类型。
同一个类中可以有多个构造函数，这个概念称为构造函数重载。
访问修饰符可以与构造函数一起使用，如果您想更改构造函数的可见性/可访问性，请使用它。
Java 提供了一个默认构造函数，在对象创建期间被调用。如果您创建任何类型的构造函数，则不会调用默认构造函数（由 Java 提供）。

创建 Java 构造函数

要在 Java 中创建构造函数，只需在括号内写入构造函数的名称（与类名称相同），然后在大括号内写入构造函数的主体 ({})。

语法

以下是构造函数的语法 -

class ClassName {
   ClassName() {
   }
}

创建 Java 构造函数的示例

以下示例创建一个简单的构造函数，它将打印"Hello world"。

public class Main {
  // 创建构造函数
  Main() {
    System.out.println("Hello, World!");
  }

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

    // 创建类的对象
    // 将调用构造函数
    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) {
    //我们没有创建任何结构
    //默认构造函数将在此处调用
    Main obj_x = new Main();

    // 打印值
    System.out.println("num1 : " + obj_x.num1);
    System.out.println("num2 : " + obj_x.num2);
  }
}

输出

num1 : 0
num2 : 0

2. 无参构造函数

正如名称所示，无参数构造函数不接受任何参数。通过使用无参数构造函数，您可以初始化类数据成员并执行对象创建时所需的各种活动。

示例:无参数构造函数

此示例创建无参数args 构造函数。

public class Main {
  int num1;
  int num2;

  // 创建无参数构造函数
  Main() {
    num1 = -1;
    num2 = -1;
  }

  public static void main(String[] args) {
    // 无参数构造函数将调用
    Main obj_x = new Main();

    // 打印值
    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;

  // 创建参数化构造函数
  Main(int a, int b) {
    num1 = a;
    num2 = b;
  }

  public static void main(String[] args) {
    // 通过传递值创建两个对象
    //初始化属性。
    //参数化构造函数将调用
    Main obj_x = new Main(10, 20);
    Main obj_y = new Main(100, 200);

    // 打印对象值
    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:参数化构造函数

这里是一个使用构造函数的简单示例−

// 一个简单的构造函数。
class MyClass {
   int x;
   
   //以下是构造函数
   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 中的构造函数重载

构造函数重载是指一个类中有多个构造函数。当您有多个列出不同参数的构造函数时，则称为构造函数重载。

示例:构造函数重载

在此示例中，我们有多个构造函数。

//Java构造函数重载示例
// 创建学生班级
class Student {
  String name;
  int age;

  // 无参数构造函数
  Student() {
    this.name = "Unknown";
    this.age = 0;
  }

  // 有一个参数的参数化构造函数
  Student(String name) {
    this.name = name;
    this.age = 0;
  }

  // 具有两个参数的参数化构造函数
  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(); //调用无参数构造函数
    Student std2 = new Student("Jordan"); //调用参数化构造函数
    Student std3 = new Student("Paxton", 25); //调用参数化构造函数

    //打印详细信息
    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