# Java 构造器

> 原文： [https://www.programiz.com/java-programming/constructors](https://www.programiz.com/java-programming/constructors)

#### 在本教程中，您将在示例的帮助下了解 Java 构造器，如何创建和使用它们以及不同类型的构造器。

## 什么是构造器？

在 Java 中，每个类都有其构造器，该构造器在创建该类的对象时会自动调用。 构造器类似于方法，但实际上，它不是方法。

[Java 方法](/java-programming/methods "Java Method")和 Java 构造器可以通过名称和返回类型来区分。 构造器与类具有相同的名称，并且不返回任何值。 例如，

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

在这里，`Test()`是一个构造器。 它具有与该类相同的名称，并且没有返回类型。

```java
class Test {
    void Test() {
        // method body
    }
}
```

在此，`Test()`与该类具有相同的名称。 但是，它具有返回类型`void`。 因此，它是一种方法，而不是构造器。

**推荐阅读**： [构造器为什么不返回值](https://stackoverflow.com/questions/1788312/why-do-constructors-not-return-values)

* * *

### 示例：Java 构造器

```java
class Main {
   private int x;

   // constructor
   private Main(){
       System.out.println("Constructor Called");
       x = 5;
   }

   public static void main(String[] args){
       // constructor is called while creating object
       Main obj = new Main();
       System.out.println("Value of x = " + obj.x);
   }
}
```

**输出**：

```java
Constructor Called
Value of x = 5
```

在上面的示例中，我们有一个名为`Main()`的`private`构造器。 在`main`方法内部，我们正在创建一个名为`obj`的对象。

```java
Main obj = new Main();
```

在此过程中，将调用构造器。 因此，将执行打印语句，并初始化变量`x`。

* * *

### 构造器的类型

在 Java 中，构造器可以分为 3 种类型：

*   无参构造器
*   默认构造器
*   参数化构造器

* * *

### 无参构造器

Java 构造器可以具有或可以不具有任何参数（参数）。 如果构造器不接受任何参数，则称为无参数构造器。 例如，

```java
private Constructor() {
   // body of constructor
}
```

* * *

### 无参数构造器的示例

```java
class Main {

   int i;

   // constructor with no parameter
   private Main(){
       i = 5;
       System.out.println("Object created and i = " + i);
   }

   public static void main(String[] args) {

       // calling the constructor without any parameter
       Main obj = new Main();
   }
}
```

**输出**：

```java
Object created and i = 5
```

此处，构造器`Main()`不接受任何参数。

**您是否注意到`Main()`构造器的访问修饰符是私有的？**

这是因为该对象是从同一类中实例化的。 因此，它可以访问构造器。

但是，如果对象是在类外部创建的，则必须声明构造器`public`才能访问它。 例如：

```java
class Company {
    String domainName;

    // public constructor
    public Company(){
        domainName = "programiz.com";
    }
}

public class Main {

    public static void main(String[] args) {

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

**输出**：

```java
Domain name = programiz.com
```

**推荐阅读**： [Java 访问修饰符](/java-programming/access-modifiers "Java Access Modifier")

* * *

### 默认构造器

如果不创建任何构造器，则 Java 编译器将在运行时自动创建无参数的构造器。 该构造器称为默认构造器。 默认构造器使用默认值初始化所有未初始化的实例变量。

| 类型 | 默认值 |
| --- | --- |
| `boolean` | `false` |
| `byte` | `0` |
| `short` | `0` |
| `int` | `0` |
| `long` | `0l` |
| `char` | `\u0000` |
| `float` | `0.0f` |
| `double` | `0.0d` |
| `object` | `null` |

* * *

### 示例：默认构造器

```java
class DefaultConstructor {

    int a;
    boolean b;

    public static void main(String[] args) {

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

        System.out.println("a = " + obj.a);
        System.out.println("b = " + obj.b);
    }
}
```

**输出**：

```java
a = 0
b = false
```

在上面的程序中，我们尚未初始化两个变量`a`和`b`的值。 但是，当我们创建类的对象时，我们可以在输出中看到这些值已使用某些值进行了初始化。

这是因为 Java 编译器已自动创建了默认构造器。 构造器将使用默认值`0`和`false`初始化变量`a`和`b`的值。

上面的程序等效于：

```java
class DefaultConstructor {

    int a;
    boolean b;

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

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

        System.out.println("a = " + obj.a);
        System.out.println("b = " + obj.b);
    }
}
```

**输出**：

```java
a = 0
b = false
```

* * *

### 参数化构造器

与方法类似，我们可以将参数传递给构造器。 此类构造器称为参数化构造器。 例如，

```java
private Constructor (arg1, arg2, ..., argn) {
    // constructor body
}
```

* * *

### 示例：参数化构造器

```java
class Vehicle {

    int wheels;

    // constructor accepting single value
    private Vehicle(int wheels){
        this.wheels = wheels;
        System.out.println(wheels + " wheeler vehicle created.");
    }

    public static void main(String[] args) {

        // calling the constructor by passing single value
        Vehicle v1 = new Vehicle(2);
        Vehicle v2 = new Vehicle(3);
        Vehicle v3 = new Vehicle(4);
    }
}
```

**输出**：

```java
2 wheeler vehicle created.
3 wheeler vehicle created.
4 wheeler vehicle created.
```

在上面的示例中，我们有一个名为`Vehicle()`的构造器。 构造器接受一个名为`wheel`的参数。

在这里，在创建对象时，我们将参数传递给构造器。 并且，基于该参数，它正在生成输出。

* * *

## Java 中的构造器重载

与方法重载类似，我们也可以重载 Java 中的构造器。 如果您不熟悉方法重载，请访问 [Java 方法重载](/java-programming/method-overloading "Java Method Overloading")。

在构造器重载中，有两个或多个具有不同参数的构造器。 例如，

```java
class Company {

    String domainName;

    // constructor with no parameter
    public Company(){
        this.domainName = "default";
    }

    // constructor with single parameter
    public Company(String domainName){
        this.domainName = domainName;
    }

    public void getName(){
        System.out.println(this.domainName);
    }

    public static void main(String[] args) {
        // calling the constructor with no parameter
        Company defaultObj = new Company();

        // calling the constructor with single parameter
        Company programizObj = new Company("programiz.com");

        defaultObj.getName();
        programizObj.getName();
    }
}
```

**输出**：

```java
default
programiz.com
```

在上面的示例中，我们有两个构造器：`public Company(`）和`public Company(String domainName)`。

在这里，两个构造器都使用不同的值初始化变量`domainName`。 因此，基于所需的值，我们可以从`main()`方法中调用构造器。

注意，我们已经使用`this`关键字指定该类的变量。 要了解有关`this`关键字的更多信息，请访问 [Java `this`关键字](/java-programming/this-keyword "Java this Keyword")。

* * *

## 重要笔记

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