Java中的构造函数

Java构造函数或Java中的构造函数是用于在我们的程序中构造某些东西的术语。 Java中的构造函数是一种用于初始化对象的特殊方法。创建类的对象时调用构造函数。它可用于设置对象属性的初始值。

在Java中，构造函数是类似于方法的代码块。在创建类的实例时调用它。在调用构造函数时，在内存中为对象分配内存。它是一种特殊类型的方法，用于初始化对象。每次使用 new() 关键字创建对象时，都会调用至少一个构造函数。

Note: It is not necessary to write a constructor for a class. It is because java compiler creates a default constructor if your class doesn’t have any.

构造函数与Java中的方法有何不同？

• 构造函数必须与定义它的类同名，而Java中的方法则不需要。
• 构造函数不返回任何类型，而方法具有返回类型，如果不返回任何值，则为void 。
• 构造函数在对象创建时只被调用一次，而方法可以被调用任意次数。

现在让我们想出在创建对象或实例时调用的构造函数的语法。

class Geek
{   
  .......

  // A Constructor
  new Geek() {}

  .......
}

// We can create an object of the above class
// using the below statement. This statement
// calls above constructor.
Geek obj = new Geek(); 

建设者的需要

想想一个盒子。如果我们谈论一个盒子类，那么它将有一些类变量（比如长度、宽度和高度）。但是当涉及到创建它的对象时（即 Box 现在将存在于计算机的内存中），那么一个没有为其尺寸定义值的盒子是否可以存在。答案是不。
因此构造函数用于在创建对象时为类变量赋值，要么由程序员显式完成，要么由Java本身（默认构造函数）显式完成。

什么时候调用构造函数？

每次使用new()关键字创建对象时，都会调用至少一个构造函数（它可能是默认构造函数）来为同一类的数据成员分配初始值。

构造函数的编写规则如下：

• 类的构造函数的名称必须与其所在的类名相同。
• Java中的构造函数不能是抽象的、最终的、静态的或同步的。
• 可以在构造函数声明中使用访问修饰符来控制其访问，即哪个其他类可以调用构造函数。

到目前为止，我们已经学习了构造函数用于初始化对象的状态。与方法一样，构造函数也包含一组在创建对象时执行的语句（即指令）。

Java中的构造函数类型

现在是讨论构造函数类型的正确时机，因此Java中的构造函数主要有两种类型：

• 无参数构造函数
• 参数化构造函数

1. 无参数构造函数

没有参数的构造函数称为默认构造函数。如果我们没有在类中定义构造函数，那么编译器会为该类创建一个默认构造函数（不带参数） 。如果我们编写带参数或无参数的构造函数，则编译器不会创建默认构造函数。

Note: Default constructor provides the default values to the object like 0, null, etc. depending on the type.

例子：

Java

// Java Program to illustrate calling a
// no-argument constructor
  
import java.io.*;
  
class Geek {
    int num;
    String name;
  
    // this would be invoked while an object
    // of that class is created.
    Geek() { System.out.println("Constructor called"); }
}
  
class GFG {
    public static void main(String[] args)
    {
        // this would invoke default constructor.
        Geek geek1 = new Geek();
  
        // Default constructor provides the default
        // values to the object like 0, null
        System.out.println(geek1.name);
        System.out.println(geek1.num);
    }
}

输出

Constructor called
null
0

2.参数化构造函数

具有参数的构造函数称为参数化构造函数。如果我们想用我们自己的值初始化类的字段，那么使用参数化构造函数。

例子：

Java

// Java Program to Illustrate Working of
// Parameterized Constructor
  
// Importing required inputoutput class
import java.io.*;
  
// Class 1
class Geek {
    // data members of the class.
    String name;
    int id;
  
    // Constructor would initialize data members
    // With the values of passed arguments while
    // Object of that class created
    Geek(String name, int id)
    {
        this.name = name;
        this.id = id;
    }
}
  
// Class 2
class GFG {
    // main driver method
    public static void main(String[] args)
    {
        // This would invoke the parameterized constructor.
        Geek geek1 = new Geek("adam", 1);
        System.out.println("GeekName :" + geek1.name
                           + " and GeekId :" + geek1.id);
    }
}

输出

GeekName :adam and GeekId :1

Remember: Does constructor return any value?

There are no “return value” statements in the constructor, but the constructor returns the current class instance. We can write ‘return’ inside a constructor.

现在最重要的话题是 OOPS 与构造函数的强结合，称为构造函数重载。 JustLike 方法，我们可以重载构造函数，以不同的方式创建对象。编译器根据参数的数量、参数的类型和参数的顺序来区分构造函数。

例子：

Java

// Java Program to illustrate constructor overloading
// using same task (addition operation ) for different
// types of arguments.
  
import java.io.*;
  
class Geek
{
    // constructor with one argument
    Geek(String name)
    {
        System.out.println("Constructor with one " +
                      "argument - String : " + name);
    }
  
    // constructor with two arguments
    Geek(String name, int age)
    {
  
        System.out.println("Constructor with two arguments : " +
                " String and Integer : " + name + " "+ age);
  
    }
  
    // Constructor with one argument but with different
    // type than previous..
    Geek(long id)
    {
        System.out.println("Constructor with one argument : " +
                                            "Long : " + id);
    }
}
  
class GFG
{
    public static void main(String[] args)
    {
        // Creating the objects of the class named 'Geek'
        // by passing different arguments
  
        // Invoke the constructor with one argument of
        // type 'String'.
        Geek geek2 = new Geek("Shikhar");
  
        // Invoke the constructor with two arguments
        Geek geek3 = new Geek("Dharmesh", 26);
  
        // Invoke the constructor with one argument of
        // type 'Long'.
        Geek geek4 = new Geek(325614567);
    }
}

输出

Constructor with one argument - String : Shikhar
Constructor with two arguments :  String and Integer : Dharmesh 26
Constructor with one argument : Long : 325614567

为了深入了解构造函数，有两个概念被广泛使用，如下所示：

• 构造函数链
• 复制构造函数