Java 中的构造函数类似于在创建类的对象时调用的方法。
与 Java 方法不同，构造函数的名称与类名相同，并且没有返回类型。例如，
class Test {
Test() {
// constructor body
}
}
这里，Test() 是一个构造函数。它与类名相同，并且没有返回类型。
示例：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 中，构造函数可分为三种类型
无参构造函数
参数化构造函数
默认构造函数
1. Java 无参构造函数
与方法类似，Java 构造函数可以接受参数，也可以不接受参数。
如果构造函数不接受任何参数，则称为无参构造函数。例如，
private Constructor() {
// body of the constructor
}
示例：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。
一旦构造函数被声明为 private，就无法从类外部访问它。
因此，使用私有构造函数禁止从类外部创建对象。
这里，我们在同一类内创建对象。
因此，程序能够访问构造函数。要了解更多信息，请访问 Java 实现私有构造函数。
但是，如果我们想在类外部创建对象，则需要将构造函数声明为 public。
示例：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
2. Java 参数化构造函数
Java 构造函数也可以接受一个或多个参数。此类构造函数称为参数化构造函数（带参数的构造函数）。
示例：参数化构造函数
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");
这里，我们将单个值传递给构造函数。
根据传递的参数，在构造函数内部初始化 language 变量。
3. Java 默认构造函数
如果我们不创建任何构造函数，Java 编译器会在程序执行期间自动创建一个无参构造函数。
此构造函数称为默认构造函数。
示例：默认构造函数
class Main {
int a;
boolean b;
public static void main(String[] args) {
// calls default constructor
Main obj = new Main();
System.out.println("Default Value:");
System.out.println("a = " + obj.a);
System.out.println("b = " + obj.b);
}
}
输出
Default Value:
a = 0
b = false
这里，我们没有创建任何构造函数。
因此，Java 编译器会自动创建默认构造函数。
默认构造函数会使用默认值初始化任何未初始化的实例变量。
类型
默认值
boolean
false
byte
0
short
0
int
0
long
0L
char
\u0000
浮点数
0.0f
双精度浮点数
0.0d
object
Reference null
要了解更多信息，请访问 Java 数据类型。
在上面的程序中，变量 a 和 b 分别用默认值 0 和 false 初始化。
上述程序等同于
class Main {
int a;
boolean b;
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);
}
}
输出
Default Value:
a = 0
b = false
关于 Java 构造函数的重要说明
实例化对象时会隐式调用构造函数。
创建构造函数的两条规则是1. 构造函数的名称应与类名相同。2. Java 构造函数必须没有返回类型。
如果一个类没有构造函数，Java 编译器会在运行时自动创建一个默认构造函数。默认构造函数使用默认值初始化实例变量。例如，int 变量将被初始化为 0
构造函数类型
无参构造函数 - 一个不接受任何参数的构造函数
参数化构造函数 - 一个接受参数的构造函数
默认构造函数 - 如果没有显式定义，Java 编译器会自动创建的构造函数。
构造函数不能是 abstract、static 或 final。
构造函数可以重载，但不能重写。
Java 中的构造函数重载
与 Java 方法重载类似，我们还可以创建两个或多个具有不同参数的构造函数。这称为构造函数重载。
示例：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 Language: " + 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)。
这里，两个构造函数都用不同的值初始化 language 变量。
根据对象创建期间传递的参数，会调用不同的构造函数，并分配不同的值。
也可以从一个构造函数调用另一个构造函数。要了解更多信息，请访问 Java 从另一个构造函数调用一个构造函数。
注意：我们使用了 this 关键字来指定类的变量。要了解有关 this 关键字的更多信息，请访问 Java this 关键字。
另请阅读
Enum 构造函数
构造函数调用
私有构造函数实现
Java 访问修饰符