Java 构造函数

Java面向对象设计 - Java构造函数

构造函数是用于在对象创建后立即初始化对象的代码块。

构造函数的结构看起来类似于一个方法。

声明构造函数

构造函数声明的一般语法是

<Modifiers> <Constructor Name>(<parameters list>) throws <Exceptions list> {

}

构造函数的声明以修饰符开头。

构造函数可以将其访问修饰符作为public，private，protected或package-level（无修饰符）。

构造函数名称与类的简单名称相同。

构造函数名称后面是一对括号，可能包括参数。

可选地，右括号后面可以是关键字throws，其后面是逗号分隔的异常列表。

以下代码显示了声明类Test的构造函数的示例。类的名称和构造函数的名称必须匹配。

public class Test {

  public Test() {
    // Code goes here

  }
}

与方法不同，构造函数没有返回类型。

使用构造函数

我们使用一个带有new操作符的构造函数来在创建新实例之后初始化类的实例。

new运算符创建一个对象，构造函数初始化该对象。

以下语句使用Test类的构造函数来初始化Test类的对象：

Test t = new Test();

以下代码显示了如何使用构造函数

class Cat {
  public Cat() {
    System.out.println("in constructor...");
  }
}

public class Main {
  public static void main(String[] args) {
    // Create a Cat object and ignore its reference
    new Cat();
    // Create another Cat object and store its reference in c
    Cat c = new Cat();
  }
}

上面的代码生成以下结果。

重载构造函数

一个类可以有多个构造函数。它们称为重载构造函数。

如果一个类有多个构造函数，它们的数量，顺序或参数类型都必须与其他构造函数不同。

下面的代码声明两个构造函数。一个构造函数不接受参数，另一个接受String参数。

class Car {
  // Constructor #1
  public Car() {
    System.out.println("A car  is created.");
  }

  // Constructor #2
  public Car(String name) {
    System.out.println("A car  named " + name + "  is created.");
  }
}

public class Main {
  public static void main(String[] args) {
    Car d1 = new Car(); // Uses Constructor #1
    Car d2 = new Car("My Car"); // Uses Constructor #2
  }
}

上面的代码生成以下结果。

每个对象创建表达式调用一次构造函数。

我们可以在对象创建的过程中只执行一个构造函数的代码一次。

从另一个构造函数调用构造函数

构造函数可以调用同一类的另一个构造函数。让我们考虑下面的Test类。它声明两个构造函数;一个不接受参数，一个接受一个int参数。

我们必须使用关键字this从另一个构造函数调用构造函数。

下面的代码使用语句“this（1）;”从没有参数的构造函数中调用具有int参数的构造函数。

class Test {
  Test() {
    this(1); // OK. Note the use of the keyword this.
  }

  Test(int x) {
  }
}

如果构造函数调用另一个构造函数，它必须是构造函数体中的第一个可执行语句。

构造函数不能调用自身，因为它将导致递归调用。

从构造函数返回

构造函数在其声明中不能有返回类型。

我们可以在构造函数体中使用没有返回表达式的return语句。

当一个构造函数中的返回语句被执行时，控制返回给调用者，忽略构造函数的其余代码。

以下代码显示了在构造函数中使用return语句的示例。

class Test {
  public Test(int x) {
    if (x < 0) {
      return;
    }

    System.out.println("here");
  }
}

构造函数的访问级别修饰符

构造函数的访问级别决定了可以在对象创建表达式中使用该构造函数的程序。

我们可以为构造函数指定四个访问级别之一：public，private，protected和package-level。

下面的代码声明了Test类的四个构造函数。

// Class Test   has  public access level 
public class Test {
  // Constructor #1 - Package-level access
  Test() {
  }

  // Constructor #2 - public access level
  public Test(int x) {
  }

  // Constructor #3 - private access level
  private Test(int x, int y) {
  }

  // Constructor #4 - protected access level
  protected Test(int x, int y, int z) {
  }
}

具有公共访问级别的构造函数可以在程序的任何部分中使用。

具有私有访问级别的构造函数只能在声明它的同一类中使用。

具有受保护访问级别的构造函数可以在具有在其中声明类的相同包的程序中以及在任何包中的任何后代类内使用。

具有包级访问权限的构造函数可以在声明其类的同一个包中使用。

默认构造函数

具有包级访问权限的构造函数可以在声明其类的同一个包中使用。

编译器添加的构造函数称为默认构造函数。

默认构造函数没有任何参数。

默认构造函数也称为无参数构造函数。

如果类已经有一个构造函数，编译器不会添加任何构造函数。