第三章java中的构造函数

---

Constructor在 java 中是允许您创建对象实例的代码块。它没有返回类型。 它有两个要点

• 构造函数名称应与类相同

• 构造函数不应该有任何返回类型，否则它将与方法相同。

  ava中有三种构造函数。

  • 默认构造函数
  • 没有 arg 构造函数
  • 参数化构造函数

  ## 如何调用构造函数？

  要调用构造函数，您需要使用关键字 new，后跟类名，如果有参数，则后跟。 例如：如果要创建Employee类的对象，可以这样调用构造函数：new Employee()

  ## 承包商的类型

  ### 默认构造函数：

  当您不为您的类提供构造函数时，JVM 将创建默认构造函数。它对您不可见，JVM 会在初始化类的对象时自动创建它。

  让我们看看例子：

package org.arpit.java2blog;

public class Employee {

    String name;
    int age;

    public void workOnAssignment()
    {
        // Working on assignment
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public static void main(String args[])
    {
        Employee e1=new Employee();
        e1.setName("John");
        e1.setAge(20);
        System.out.println(e1.getName());
        System.out.println(e1.getAge());
    }
}

正如您在此处看到的，我们没有为此类提供任何构造函数，但JVM在这种情况下会创建默认构造函数。 当你运行上面的程序时，你会得到下面的输出：

John 20

没有 arg 构造函数

no arg constructor是您在类中明确提供的构造函数，它没有任何参数。

package org.arpit.java2blog;

public class Employee {

    String name;
    int age;

    public Employee()
    {
        System.out.println("Calling no arg constructor");
    }
    public void workOnAssignment()
    {
        // Working on assignment
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public static void main(String args[])
    {
        Employee e1=new Employee();
        e1.setName("John");
        e1.setAge(20);
        System.out.println(e1.getName());
        System.out.println(e1.getAge());
    }
}

当您调用上述程序时，您将得到以下输出：

Calling no arg constructor
John
20

参数化构造函数

当您将参数传递给构造函数时，会调用这种类型的构造函数Parameterized constructor。

package org.arpit.java2blog;

public class Employee {

    String name;
    int age;

    public Employee(String name,int age)
    {
        System.out.println("Calling Parameterized constructor");
        this.name=name;
        this.age=age;       
    }
    public void workOnAssignment()
    {
        // Working on assignment
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public static void main(String args[])
    {
        Employee e1=new Employee("John",20);
        System.out.println(e1.getName());
        System.out.println(e1.getAge());
    }
}

当你运行上面的程序时，你会得到下面的输出：

Calling Parameterized constructor
John
20

如果您提供参数化构造函数，那么您需要小心。 让我们看看下面的程序：

package org.arpit.java2blog;

public class Employee {

    String name;
    int age;

    public Employee(String name,int age)
    {
        System.out.println("Calling Parameterized constructor");
        this.name=name;
        this.age=age;       
    }
    public void workOnAssignment()
    {
        // Working on assignment
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public static void main(String args[])
    {
        Employee e1=new Employee();
        e1.setName("John");
        e1.setAge(20);
        System.out.println(e1.getName());
        System.out.println(e1.getAge());
    }
}

如果你注意到，你会在第 38 行得到编译错误。为什么这样？ 因为如果您在类中创建参数化构造函数，JVM 不会为您提供默认构造函数。如果您不编写任何构造函数，那么只有 JVM 会为您提供默认构造函数。

构造函数链

Constructor chaining是子类在内部或显式调用其父类的构造函数的概念。 每当您在 Java 中创建对象时，都会调用其超类构造函数。编译器只是在内部将 super() 放入构造函数中。 让我们在示例的帮助下查看： 假设您有 Person 具有属性名称的类，并且您有名为Employee扩展类的子Person类。

package org.arpit.java2blog;

public class Person
{
    String name;
    public Person()
    {
        System.out.println("Calling Person constructor");
        name="John";
    }
}
class Employee extends Person{

    int age;

    public Employee()
    {
        System.out.println("Calling Employee class constructor");
        name="Martin";
    }
    public void workOnAssignment()
    {
        // Working on assignment
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public static void main(String args[])
    {
        Employee e1=new Employee();

        System.out.println(e1.getName());
    }
}

当你运行上面的程序时，你会得到下面的输出：

Calling Person constructor
Calling Employee class constructor
Martin

正如您在此处看到的，First Person 构造函数被调用并将 name 变量设置为John Then Employee 构造函数被调用，该构造函数将 name 变量覆盖为Martin。 这就是为什么我们最后看到一个变量名为“Martin”。

如果要显式调用超类参数化构造函数怎么办

您可以使用super 关键字轻松完成。 让我们在示例的帮助下看看。

package org.arpit.java2blog;

public class Person
{
    String name;
    public Person(String name)
    {
        this.name=name;
        System.out.println("Calling Person Parameterized constructor");
    }
}
class Employee extends Person{

    int age;

    public Employee(String name)
    {
        super(name);
        System.out.println("Calling Employee class constructor");
    }
    public void workOnAssignment()
    {
        // Working on assignment
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public static void main(String args[])
    {
        Employee e1=new Employee("John");

        System.out.println("Employee's name:"+e1.getName());
    }
}

当你运行上面的程序时，你会得到下面的输出：

调用人员参数化构造函数 调用员工类构造函数 员工姓名：John

如果你想调用同一个类的另一个构造函数怎么办

如果你想调用overloaded constructor同一个类，你可以使用这个关键字来做到这一点。 例如：

package org.arpit.java2blog;

public class Employee {

    String name;
    int age;

    public Employee() {
        System.out.println("Calling No arg constructor");
    }

    public Employee(String name,int age)
    {
        this();
        System.out.println("Calling Parameterized constructor");    
        this.name=name;
        this.age=age;       
    }

    public void workOnAssignment()
    {
        // Working on assignment
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public static void main(String args[])
    {
        Employee e1=new Employee("John",20);
        System.out.println("Employee's name : "+e1.getName());
        System.out.println("Employee's age : "+e1.getAge());
    }
}

当你运行上面的程序时，你会得到下面的输出：

Calling No arg constructor
Calling Parameterized constructor
Employee’s name : John
Employee’s age : 20

请注意，用于调用重载构造函数的 this 关键字应该是该构造函数中的第一个语句。

这就是Java中的构造函数。

---

原文链接：https://codingdict.com/

---