Java中的构造方法详解

Java构造函数是在实例化对象时调用的特殊方法。换句话说，当您使用new关键字时。Java 构造函数的目的是在使用之前初始化新创建的对象。本 Java 构造函数教程将更详细地探讨 Java 构造函数。

这是一个创建对象的简单示例，它会调用类构造函数：

MyClass myClassObj = new MyClass();

此示例导致MyClass创建一个新对象，并调用 的无参数构造函数 MyClass。稍后您将了解什么是无参数构造函数。

Java 类构造函数初始化该类的实例(对象)。通常，构造函数会初始化需要初始化的对象的字段。Java 构造函数也可以带参数，因此可以在创建时在对象中初始化字段。

在 Java 中定义构造函数

这是一个简单的 Java 构造函数声明示例。该示例显示了一个非常简单的 Java 类，它只有一个构造函数。

公开课 MyClass {
    公共 MyClass() {
    }
}

构造函数是这部分：

    公共 MyClass() {
    }

Java 构造函数声明的第一部分是访问修饰符。访问修饰符与方法和字段具有相同的含义。它们确定哪些类可以访问(调用)构造函数。

Java 构造函数声明的第二部分是构造函数所属类的名称。使用构造函数的类名向 Java 编译器发出这是一个构造函数的信号。还要注意构造函数没有返回类型，就像其他方法一样。

Java 构造函数声明的第三部分是构造函数可以采用的参数列表。构造函数参数在构造函数()的类名部分之后的括号内声明。在上面的构造函数声明示例中，没有声明任何参数。我将在本文后面展示一个带有参数的 Java 构造函数声明示例。

Java 构造函数声明的第四部分是构造函数的主体。{ }构造函数的主体定义在参数列表之后的大括号内。在上面的构造函数示例中，构造函数在构造函数体内没有任何操作。它被称为“空”构造函数。

构造函数重载 - 一个 Java 类的多个构造函数

一个类可以有多个构造函数，只要它们的签名(它们采用的参数)不相同即可。您可以根据需要定义任意数量的构造函数。当一个 Java 类包含多个构造函数时，我们说构造函数被重载(有多个版本)。这就是 构造函数重载的意思，一个 Java 类包含多个构造函数。

这是一个 Java 构造函数重载示例：

公开课 MyClass {
    私人整数 = 0;
    公共 MyClass() {
    }
    公共 MyClass(int theNumber) {
        this.number = theNumber;
    }
}

上面的 Java 类包含两个构造函数。第一个构造函数是一个无参数构造函数，这意味着它没有参数(没有参数)。第二个构造函数接受一个int参数。在构造函数体内，int参数值被分配给一个字段，这意味着参数的值被复制到该字段中。该字段因此被初始化为给定的参数值。

this字段名前面的 关键字( this.number)不是必须的。它只是向编译器发出信号，表明它是number被引用的命名字段。这在有关构造函数参数的部分中有更详细的解释。

默认，无参数构造函数

您不必为类定义构造函数，但如果您没有定义任何构造函数，Java 编译器将为您插入一个默认的无参数构造函数。因此，一旦类被编译，它总是至少有一个无参数的构造函数。

如果您确实为您的类定义了构造函数，那么 Java 编译器不会将默认的无参数构造函数插入到您的类中。

构造函数参数

正如您已经看到的，Java 构造函数可以采用参数。然后可以使用这些参数来初始化新创建对象的内部状态(字段)。这是一个例子：

公共课员工{
    私有字符串 firstName = null；
    私有字符串 lastName = null；
    私人诠释出生年 = 0;
    公共员工（首先是字符串，
        字符串最后，
        整数年）{
        名字 = 第一个；
        姓氏 = 姓氏；
        出生年份 = 年；
    }
}

在此示例中，Java 构造函数声明以粗体标记。如您所见，声明了三个参数：first,last和year。在构造函数的主体中，这三个参数的值被分配给Employee 对象的字段。

每个参数后的换行符是可选的。Java 编译器忽略此处的换行符。如果需要，您也可以将参数声明写在一行中，如下所示：

public Employee(String first, String last, int year) {
    名字 = 第一个；
    姓氏 = 姓氏；
    出生年份 = 年；
}

要调用这个采用三个参数的构造函数，您可以Employee像这样实例化一个对象：

雇员 employee = new Employee("Jack", "Daniels", 2000);

参数在等号右侧的类名之后的括号内传递给构造函数。然后创建对象，并执行构造函数。执行上述构造函数后，构造函数初始化的字段将具有传递给构造函数的参数值。

Java 构造函数参数可以与字段同名。如果构造函数参数与字段同名，则 Java 编译器无法知道您指的是哪个。默认情况下，如果参数(或局部变量)与同一类中的字段同名，则参数(或局部变量)为该字段“隐藏”。看看这个构造函数示例：

公共课员工{
    私有字符串 firstName = null；
    私有字符串 lastName = null；
    私人诠释出生年 = 0;
    公共雇员（字符串名字，
        字符串姓氏，
        整数出生年）{
        名字 = 名字；
        姓氏 = 姓氏；
        出生年 = 出生年；
    }   
}

在 Employee 类的构造函数中，firstName,lastName和birthYear 标识符现在引用构造函数参数，而不是同名的 Employee 字段。因此，构造函数现在只需将参数设置为等于它们自己。Employee 字段永远不会被初始化。

要向 Java 编译器表明您指的是 Employee 类的字段而不是参数，请 this在字段名称前放置关键字和一个点。以下是之前的 Java 构造函数声明在更改后的样子：

公共课员工{
    私有字符串 firstName = null；
    私有字符串 lastName = null；
    私人诠释出生年 = 0;
    公共雇员（字符串名字，
        字符串姓氏，
        整数出生年）{
        this.firstName = firstName;
        this.lastName = lastName;
        this.birthYear = birthYear;
    }    
}

现在，Employee 字段已在构造函数中正确初始化。

调用构造函数

在创建包含构造函数的类的新实例时调用构造函数。这是一个 Java 构造函数调用示例：

MyClass myClassVar = new MyClass();

MyClass此示例调用(调用)本文前面定义 的无参数构造函数。

如果你想将参数传递给构造函数，你可以在类名后的括号中包含参数，如下所示：

MyClass myClassVar = new MyClass(1975);

此示例将一个参数传递给采用as 参数 的MyClass构造函数。int

从构造函数调用构造函数

在 Java 中，可以从另一个构造函数内部调用一个构造函数。当您从另一个构造函数内部调用一个构造函数时，您可以使用this关键字来引用该构造函数。下面是在 Java 中从另一个构造函数中调用一个构造函数的示例：

公共课员工{
    私有字符串 firstName = null；
    私有字符串 lastName = null；
    私人诠释出生年 = 0;
    公共员工（首先是字符串，
        字符串最后，
        整数年）{
        名字 = 第一个；
        姓氏 = 姓氏；
        出生年份 = 年；
    }
    公共员工（首先是字符串，最后是字符串）{
        这个（第一个，最后一个，-1）；
    }
}

注意第二个构造函数定义。在构造函数的主体中，您可以找到以下 Java 语句：

这个（第一个，最后一个，-1）；

this关键字后跟圆括号和参数表示正在调用同一个 Java 类中的另一个构造函数 。调用哪个其他构造函数取决于您传递给构造函数调用的参数(在this关键字后的括号内)。在此示例中，它是被调用的类中的第一个构造函数。

在超类中调用构造函数

在 Java 中，一个类可以扩展另一个类。当一个类扩展另一个类时，它也被称为从它扩展的类“继承”。扩展的类称为子类，被扩展的类称为超类。在我的关于Java 中的继承的教程中更详细地介绍了继承。

扩展另一个类的类不继承其构造函数。但是，子类必须在其子类构造函数内部调用超类中的构造函数!如果子类在其自身内部调用另一个构造函数，则被调用的构造函数必须调用超类构造函数。

查看以下两个 Java 类。Car 类扩展(继承自)Vehicle 类。

公共类车辆{
    私有字符串 regNo = null；
    公共车辆（字符串编号）{
        this.regNo = 否；
    }
}

公共类汽车扩展车辆{
    私人字符串品牌=空；
    public Car(String br, String no) {
        超级（没有）；
        这个品牌 = br;
    }
}

注意 Car 类中的构造函数。它使用此 Java 语句调用超类中的构造函数：

超级（没有）；

使用关键字super是指使用关键字的类的超类super。当super关键字后跟括号时，就像这里一样，它指的是超类中的构造函数。在这种情况下，它指的是 Vehicle 类中的构造函数。因为 Car 扩展了 Vehicle，所以 Car 的构造函数必须都调用 Vehicle 中的构造函数。

Java 构造函数访问修饰符

构造函数的访问修饰符决定了应用程序中哪些类可以调用该构造函数。访问修饰符在有关Java 访问修饰符的文本中有更详细的解释 。

例如，如果声明了构造函数，protected则只有同一包中的类或该类的子类才能调用该构造函数。

一个类可以有多个构造函数，每个构造函数可以有自己的访问修饰符。因此，某些构造函数可能对应用程序中的所有类都可用，而其他构造函数仅对同一包中的类、子类可用，甚至仅对类本身可用(私有构造函数)。

从构造函数中抛出异常

可以从 Java 构造函数中抛出异常。下面是一个带有可以抛出异常的构造函数的 Java 类的示例：

公共汽车类 {
    公共汽车（字符串品牌）抛出异常{
        如果（品牌==空）{
            throw new Exception("品牌参数不能为空！");
        }
    }
}

注意throws Exception构造函数声明的部分。该部分声明构造函数可能会抛出一个Exception. 如果发生这种情况，则创建的Car实例无效。

下面是调用Car构造函数的示例：

车车=空；
尝试{
    car = new Car("梅赛德斯");
    //对汽车对象做点什么
} 赶上（异常 e）{
    // 处理异常
}

Car如果构造函数抛出异常，car则永远不会为该变量分配对Car您尝试创建的对象的引用。该car变量仍将指向 null。

如果要防止在无效状态下创建给定类的对象，让构造函数抛出异常是个好主意。通常是构造函数的输入参数可能导致对象无效。如果构造函数检测到无效的输入参数，它会抛出异常并阻止将对象赋值给任何变量。