Java 中的构造器

原文：https://www.studytonight.com/java/constructor-in-java.php

构造器是一种用于初始化对象的特殊方法。每个类都有一个隐式或显式的构造器。

如果我们没有在类中声明一个构造器，那么 JVM 会为这个类构建一个默认的构造器。这就是所谓的默认构造器。

构造器与声明它的类名同名。构造器必须没有显式返回类型。Java 中的构造器不能是抽象的、静态的、最终的或者同步的。构造器不允许使用这些修饰符。

声明构造器的语法

  className (parameter-list){
  code-statements
}

类名是类名，因为构造器名与类名相同。

参数列表是可选的，因为构造器可以参数化，也可以非参数化。

构造器示例

在 Java 中，构造器在结构上看起来像下面程序中给出的。Car 类有一个为实例变量提供值的构造器。

class Car
{
 String name ;
 String model;
 Car( )    **//Constructor**
 {
  name ="";
  model="";
 }
}

构造器的类型

Java 支持两种类型的构造器:

• 默认构造器
• 参数化构造器

每次创建新对象时，至少会调用一个构造器。

Car c = new Car()       **//Default constructor invoked**
Car c = new Car(name); **//Parameterized constructor invoked**

默认构造器

在 Java 中，如果一个构造器没有任何参数，它就被称为默认构造器。默认构造器可以是用户定义的，也可以由 JVM 提供。

如果一个类不包含任何构造器，那么在运行时 JVM 会生成一个默认构造器，称为系统定义默认构造器。

如果一个类包含一个不带参数的构造器，那么它被称为用户定义的默认构造器。在这种情况下，JVM 不会创建默认构造器。

创建构造器的目的是初始化对象的状态。

下图显示了 JVM 如何在运行时向类添加构造器。

用户定义默认构造器

程序员在类中定义的构造器称为用户定义的默认构造器。

示例:

在本例中，我们创建了一个与类名同名的构造器。

  class AddDemo1
{  
  AddDemo1()
  {
    int a=10;
    int b=5;
    int c;
    c=a+b;
    System.out.println("*****Default Constructor*****");
    System.out.println("Total of 10 + 5 = "+c);
  }  

  public static void main(String args[])
  {  
    AddDemo1 obj=new AddDemo1();  
  }  
}

构造器重载

像方法一样，构造器也可以重载。重载构造器根据其Parameter类型或参数数量进行区分。构造器重载与方法重载没有太大区别。在方法重载的情况下，您有多个名称相同但签名不同的方法，而在构造器重载中，您有多个签名不同的构造器，但唯一的区别是构造器没有返回类型。

构造器重载示例

class Cricketer
{
 String name;
 String team;
 int age;
 Cricketer ()   **//default constructor**.
 {
  name ="";
  team ="";
  age = 0;
 }
 Cricketer(String n, String t, int a)   **//constructor overloaded**
 {
  name = n;
  team = t;
  age = a;
 }
 Cricketer (Cricketer ckt)     **//constructor similar to copy constructor of c++** 
 {
  name = ckt.name;
  team = ckt.team;
  age = ckt.age;
 }
 public String toString()
 {
  return "this is " + name + " of "+team;
 }
}

Class test:
{
 public static void main (String[] args)
 {
  Cricketer c1 = new Cricketer();
  Cricketer c2 = new Cricketer("sachin", "India", 32);
  Cricketer c3 = new Cricketer(c2 );
  System.out.println(c2);
  System.out.println(c3);
  c1.name = "Virat";
  c1.team= "India";
  c1.age = 32;
  System .out. print in (c1);
 }
}

这是印度的萨钦这是印度的萨钦这是印度的维拉特

构造器链接

构造器链接是从同一个类中的另一个构造器调用一个构造器的过程。由于只能从另一个构造器调用构造器，因此构造器链接用于此目的。

从另一个构造器调用构造器时，使用this关键字。此关键字用于引用当前对象。

让我们看一个理解构造器链接的例子。

  class Test
{
 Test()
 {
  this(10);
 }
 Test(int x)
 {
  System.out.println("x="+x);
 }
public static void main(String arg[])
{
Test object = new Test();
}
}

x=10

当我们想要通过创建类的单个对象来执行多个任务时，使用构造器链接。

在下图中，我们描述了同一类中构造器调用的流程。

示例:

让我们再看一个例子来理解构造器链。这里我们已经创建了三个构造器，并通过使用this关键字来调用它们。

  class abc
{
  public abc()
  {
    this(5);
    System.out.println("Default Constructor");
  }
  public abc(int x)
  {
    this(5, 6);
    System.out.println("Constructor with one Parameter");
    System.out.println("Value of x ==> "+x);
  }
  public abc(int x, int y)
  {
    System.out.println("Constructor with two Parameter");
    System.out.println("Value of x and y ==> "+x+" "+y);
  }
}
class ChainingDemo1
{
  public static void main(String as[])
  {
    abcobj = new abc();
  }
}

私有构造器

在 Java 中，我们可以创建私有构造器来防止类被实例化。这意味着通过声明一个私有构造器，它限制创建该类的对象。

私有构造器用于创建单例类。一个只能有一个对象的类，称为单例类。

在私有构造器中，只能创建一个对象，该对象是在类中创建的，并且所有方法都是静态的。如果类中存在私有构造器，则无法创建对象。一个有私有构造器并且所有方法都是静态的类叫做实用类。

示例:

  final class abc
{
  private abc()
  {}
  public static void add(int a, int b)
  {
    int z = a+b;
    System.out.println("Addition: "+z);
  }
  public static void sub(int x, int y)
  {
    int z = x-y;
    System.out.println("Subtraction: "+z);
  }

}
class PrivateConDemo
{
  public static void main(String as[])
  {
    abc.add(4, 5);
    abc.sub(5, 3);
  }
}