Java 构造函数

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

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

注意： 没有必要为一个类写一个构造函数。因为如果你的类没有构造函数，java编译器会创建一个默认的构造函数（无参数的构造函数）。

构造函数与Java中的方法有什么不同

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

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

class Geek
{   
  .......

  // A Constructor
  Geek() {
  }

  .......
}

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

构造函数的第一行是对super()或this()的调用，（对超类的构造函数或重载的构造函数的调用），如果你没有在你的构造函数中输入对super的调用，编译器会在你代码的第一行提供对super的非参数调用，必须调用super构造函数来创建一个对象。

import java.io.*;
 
class Geeks {
    Geeks() { super(); }
    public static void main(String[] args)
    {
        Geeks geek = new Geeks();
    }
}

输出
“`java

<pre><code class=" line-numbers"><br />如果你认为你的类不是一个子类，它实际上是，java中的每个类都是一个类 **对象** 的子类，即使你在类的定义中没有说extends object。

## 构造函数的必要性

想一想一个盒子。如果我们谈论一个盒子类，那么它将有一些类的变量（比如长度、宽度和高度）。但是当我们要创建它的对象时（即盒子现在存在于计算机的内存中），那么一个盒子可以在没有定义其尺寸值的情况下存在吗？答案是否定 **的。**
所以构造函数是用来在创建对象时给类变量赋值的，可以由程序员明确完成，也可以由Java本身完成（默认构造函数）。

### 构造函数什么时候被调用

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

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

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

到目前为止，我们已经知道构造函数是用来初始化对象的状态的。像方法一样，构造函数也包含了在创建对象时执行的语句（即指令）的集合。

## Java中构造函数的类型

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

* **无参数构造函数**
* **参数化** 构造函数
* **默认构造函数**

### 1.无参数构造器

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

**注意：** 默认构造函数为对象提供默认值，如0、null，等等，这取决于类型。

**例子**
“`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.参数化构造函数

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

例子

import java.io.*;
class Geek {
    // data members of the class.
    String name;
    int id;
    Geek(String name, int id)
    {
        this.name = name;
        this.id = id;
    }
}
class GFG {
    public static void main(String[] args)
    {
        // This would invoke the parameterized constructor.
        Geek geek1 = new Geek("avinash", 68);
        System.out.println("GeekName :" + geek1.name  + " and GeekId :" + geek1.id);
    }
}

输出

GeekName :avinash and GeekId :68

记住:构造函数是否返回任何值？

在构造函数中没有 “返回值 “语句，但构造函数会返回当前的类实例。我们可以在构造函数里面写 “返回”。

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

例子

// 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

3.缺省构造函数

一个没有参数的构造函数被称为默认构造函数。默认构造函数是不可见的。如果我们写一个有参数或无参数的构造函数，那么编译器就不会创建一个默认的构造函数。它被取出来了。它被重载并称为参数化构造函数。默认构造函数变成了参数化构造函数。但参数化构造函数不能改变默认构造函数。

import java.io.*;
 
class GFG {
    GFG() { System.out.println("Default constructor"); }
    public static void main(String[] args)
    {
 
        GFG hello = new GFG();
    }
}

输出