Java 构造函数

在本教程中，我们将通过示例了解 Java 构造函数、它们的类型以及如何使用它们。

什么是构造函数？

Java 中的构造函数类似于在创建类的对象时调用的方法。

与 Java 方法不同，构造函数与类具有相同的名称，并且没有任何返回类型。例如，

class Test {
  Test() {
    // constructor body
  }
}

这里，Test() 是一个构造函数。它与类同名，没有返回类型。

推荐阅读： 为什么构造函数不返回值

示例 1：Java 构造函数

class Main {
  private String name;

  // constructor
  Main() {
    System.out.println("Constructor Called:");
    name = "Programiz";
  }

  public static void main(String[] args) {

    // constructor is invoked while
    // creating an object of the Main class
    Main obj = new Main();
    System.out.println("The name is " + obj.name);
  }
}

输出：

Constructor Called:
The name is Programiz

在上面的示例中，我们创建了一个名为 Main() 的构造函数 .在构造函数内部，我们正在初始化 name 的值变量。

注意创建Main的对象的语句类。

Main obj = new Main();

这里，当对象被创建时，Main() 构造函数被调用。并且，name 的值变量已初始化。

因此，程序打印 name 的值变量为 Programiz .

构造函数的类型

在Java中，构造函数可以分为3种：

无参数构造函数
参数化构造函数
默认构造函数

1. Java 无参数构造函数

与方法类似，Java 构造函数可能有也可能没有任何参数（参数）。

如果构造函数不接受任何参数，则称为无参数构造函数。例如，

private Constructor() {
   // body of the constructor
}

示例 2：Java 私有无参数构造函数

class Main {

  int i;

  // constructor with no parameter
  private Main() {
    i = 5;
    System.out.println("Constructor is called");
  }

  public static void main(String[] args) {

    // calling the constructor without any parameter
    Main obj = new Main();
    System.out.println("Value of i: " + obj.i);
  }
}

输出：

Constructor is called
Value of i: 5

在上面的例子中，我们创建了一个构造函数 Main() .在这里，构造函数不接受任何参数。因此，它被称为无参数构造函数。

请注意，我们已将构造函数声明为私有。

一旦声明了构造函数 private ，它不能从类外访问。因此，禁止使用私有构造函数从类外部创建对象。

在这里，我们在同一个类中创建对象。因此，程序能够访问构造函数。要了解更多信息，请访问 Java 实现私有构造函数。

但是，如果我们想在类之外创建对象，那么我们需要将构造函数声明为public .

示例 3：Java 公共无参数构造函数

class Company {
  String name;

  // public constructor
  public Company() {
    name = "Programiz";
  }
}

class Main {
  public static void main(String[] args) {

    // object is created in another class
    Company obj = new Company();
    System.out.println("Company name = " + obj.name);
  }
}

输出：

Company name = Programiz

推荐阅读： Java 访问修饰符

2. Java 参数化构造函数

Java 构造函数也可以接受一个或多个参数。这样的构造函数称为参数化构造函数（带参数的构造函数）。

示例4：参数化构造函数

class Main {

  String languages;

  // constructor accepting single value
  Main(String lang) {
    languages = lang;
    System.out.println(languages + " Programming Language");
  }

  public static void main(String[] args) {

    // call constructor by passing a single value
    Main obj1 = new Main("Java");
    Main obj2 = new Main("Python");
    Main obj3 = new Main("C");
  }
}

输出：

Java Programming Language
Python Programming Language
C Programming Language

在上面的示例中，我们创建了一个名为 Main() 的构造函数 .在这里，构造函数采用单个参数。注意表达式，

Main obj1 = new Main("Java");

在这里，我们将单个值传递给构造函数。根据传递的参数，语言变量在构造函数中被初始化。

3。 Java 默认构造函数

如果我们不创建任何构造函数，Java 编译器会在程序执行期间自动创建一个无参数构造函数。这个构造函数称为默认构造函数。

示例 5：默认构造函数

class Main {

  int a;
  boolean b;

  public static void main(String[] args) {

    // A default constructor is called
    Main obj = new Main();

    System.out.println("Default Value:");
    System.out.println("a = " + obj.a);
    System.out.println("b = " + obj.b);
  }
}

输出：

a = 0
b = false

在这里，我们还没有创建任何构造函数。因此，Java 编译器会自动创建默认构造函数。

默认构造函数使用默认值初始化任何未初始化的实例变量。

类型	默认值
`boolean`	假
`byte`	0
`short`	0
`int`	0
`long`	0L
`char`	\u0000
`float`	0.0f
`double`	0.0d
`object`	引用空

在上面的程序中，变量 a 和 b 用默认值0初始化和 false 分别。

上面的程序相当于：

class Main {

  int a;
  boolean b;

  // a private constructor
  private Main() {
    a = 0;
    b = false;
  }

  public static void main(String[] args) {
    // call the constructor
    Main obj = new Main();

    System.out.println("Default Value:");
    System.out.println("a = " + obj.a);
    System.out.println("b = " + obj.b);
  }
}

程序的输出与示例5相同。

Java 构造函数的重要说明

在实例化对象时隐式调用构造函数。
创建构造函数的两条规则是：
构造函数的名称应与类相同。
Java 构造函数不能有返回类型。
如果一个类没有构造函数，Java 编译器会自动创建一个默认构造函数 在运行时。默认构造函数使用默认值初始化实例变量。例如，int 变量将被初始化为 0
构造函数类型：
无参数构造函数 - 不接受任何参数的构造函数
参数化构造函数 - 接受参数的构造函数
默认构造函数 - 如果没有明确定义，Java 编译器会自动创建一个构造函数。
构造函数不能是abstract 或 static 或 final .
构造函数可以重载，但不能被覆盖。

Java 中的构造函数重载

与 Java 方法重载类似，我们也可以创建两个或多个具有不同参数的构造函数。这称为构造函数重载。

示例 6：Java 构造函数重载

class Main {

  String language;

  // constructor with no parameter
  Main() {
    this.language = "Java";
  }

  // constructor with a single parameter
  Main(String language) {
    this.language = language;
  }

  public void getName() {
    System.out.println("Programming Langauage: " + this.language);
  }

  public static void main(String[] args) {

    // call constructor with no parameter
    Main obj1 = new Main();

    // call constructor with a single parameter
    Main obj2 = new Main("Python");

    obj1.getName();
    obj2.getName();
  }
}

输出：

Programming Language: Java
Programming Language: Python

在上面的例子中，我们有两个构造函数：Main() 和 Main(String language) .这里，两个构造函数都用不同的值初始化变量语言的值。

根据创建对象时传递的参数，调用不同的构造函数，分配不同的值。

也可以从另一个构造函数调用一个构造函数。要了解更多信息，请访问 Java Call One Constructor from another。

注意 :我们使用了 this 关键字来指定类的变量。了解更多关于 this 关键字，访问Java this关键字。

Java 方法 Java 字符串

java