什么是构造函数？
在Java中，每个类都有其构造函数，该构造函数在创建该类的对象时会自动调用。构造函数类似于方法，但是实际上，它不是方法。
Java方法和Java构造函数可以通过其名称和返回类型来区分。构造函数与类具有相同的名称，并且不返回任何值。例如，
class Test {
Test() {
// constructor body
}
}在这里， Test()是一个构造函数。它具有与该类相同的名称，并且没有返回类型。
class Test {
void Test() {
// method body
}
}在这里， Test()与该类具有相同的名称。但是，它的返回类型为void 。因此，它是一种方法，而不是构造函数。
推荐读物：为什么构造函数不返回值
示例：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);
}
}输出 ：
Constructor Called
Value of x = 5在上面的示例中，我们有一个名为Main()的private构造函数。在main方法内部，我们正在创建一个名为obj的类的对象。
Main obj = new Main();在此过程中，将调用构造函数。因此，将执行print语句并初始化变量x 。
构造函数的类型
在Java中，构造函数可以分为3种类型：
- 无Arg构造函数
- 默认构造函数
- 参数化构造函数
无Arg构造函数
Java构造函数可以具有或可以不具有任何参数(参数)。如果构造函数不接受任何参数，则称为无参数构造函数。例如，
private Constructor() {
// body of constructor
}无参数构造函数的示例
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();
}
}输出 ：
Object created and i = 5在这里，构造函数Main()不接受任何参数。
您是否注意到Main()构造函数的访问修饰符是私有的？
这是因为该对象是从同一类中实例化的。因此，它可以访问构造函数。
但是，如果对象是在类外部创建的，则必须将构造方法声明为public才能访问它。例如：
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);
}
}输出 ：
Domain name = programiz.com推荐读物： Java访问修饰符
默认构造函数
如果不创建任何构造函数，则Java编译器将在运行时自动创建无参数构造函数。此构造函数称为默认构造函数。默认构造函数使用默认值初始化所有未初始化的实例变量。
| Type | Default Value |
|---|---|
boolean |
false |
byte |
0 |
short |
0 |
int |
0 |
long |
0L |
char |
\u0000 |
float |
0.0f |
double |
0.0d |
object |
Reference null |
示例：默认构造函数
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);
}
}输出 ：
a = 0
b = false在上面的程序中，我们尚未初始化变量a和b的值 。但是，当我们创建类的对象时，我们可以在输出中看到这些值已使用某些值进行了初始化。
这是因为Java编译器已自动创建了默认构造函数。构造函数将使用默认值0和false初始化变量a和b的值。
上面的程序等效于：
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);
}
}输出 ：
a = 0
b = false参数化构造函数
与方法类似，我们可以将参数传递给构造函数。此类构造函数称为参数化构造函数。例如，
private Constructor (arg1, arg2, ..., argn) {
// constructor body
}示例：参数化构造函数
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);
}
}输出 ：
2 wheeler vehicle created.
3 wheeler vehicle created.
4 wheeler vehicle created.在上面的示例中，我们有一个名为Vehicle()的构造函数。构造函数接受一个名为wheel的参数。
在这里，在创建对象时，我们将参数传递给构造函数。并且，基于自变量，它正在生成输出。
Java中的构造方法重载
与方法重载类似，我们也可以重载Java中的构造函数。如果您不熟悉方法重载，请访问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();
}
}输出 ：
default
programiz.com在上面的示例中，我们有两个构造函数： public Company( )和public Company(String domainName) 。
在这里，两个构造函数都使用不同的值初始化变量domainName 。因此，基于所需的值，我们可以从main()方法中调用构造函数。
请注意，我们已经使用this关键字来指定类的变量。要了解有关this关键字的更多信息，请访问Java this关键字。
重要笔记
- 实例化对象时，将隐式调用构造函数。
- 创建构造函数的两个规则是：
- 构造函数的名称应与类的名称相同。
- Java构造函数不得具有返回类型。
- 如果类没有构造函数，则Java编译器会在运行时自动创建默认构造函数 。默认构造函数使用默认值初始化实例变量。例如，将
int变量初始化为0 - 构造函数类型：
- No-Arg构造函数 -不接受任何参数的构造函数
- 默认构造函数 -如果未明确定义，则由Java编译器自动创建的构造函数。
- 参数化构造函数 -接受参数的构造函数
- 构造函数不能是抽象的，静态的或最终的。
- 构造函数可以重载，但不能被覆盖。