Java创建教程！(* ￣3)(ε￣ *)

news2024/9/19 8:07:11

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) {
  }
}

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

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

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

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

默认构造函数

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

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

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

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

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

Java 初始化块

Java面向对象设计 - Java初始化块

实例初始化块

实例初始化块用于初始化类的对象。

一个实例初始化程序只是一个类的代码块，但在任何方法或构造函数之外。

实例初始值设定程序没有名称。它的代码只是放置在一个开放大括号和闭包。

例子

下面的代码展示了如何为Test类声明一个实例初始化器。

注意，实例初始化程序在实例上下文中执行，并且关键字this在实例初始化程序中可用。

class Test {
  private int num;
  // An instance initializer
  {
    this.num = 101;

    /* Other code for the instance initializer*/
  }

  /* Other code for Test class*/
}

多重实例初始化

我们可以有一个类的多个实例初始化器。对于我们创建的每个对象，它们都以文本顺序自动执行。

所有实例初始值的代码在任何构造函数之前执行。

下面的代码演示了构造函数和实例初始化函数的执行顺序。

public class Main {
  {
    System.out.println("Inside instance initializer 1.");
  }

  {
    System.out.println("Inside instance initializer 2.");
  }

  public Main() {
    System.out.println("Inside  no-args constructor.");
  }

  public static void main(String[] args) {
    Main m = new Main();
  }
}

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

实例初始化程序不能有return语句。

静态初始化块

静态初始化块也称为静态初始化器。它类似于实例初始化块。

它用于初始化一个类。每个对象执行一个实例初始化器，而当类定义被加载到JVM中时，只对一个类执行一次静态初始化器。

我们需要在其声明的开头使用static关键字。

我们可以在类中有多个静态初始化器。所有静态初始化器都按文本出现的顺序执行，并在任何实例初始化器之前执行。

以下代码演示了何时执行静态初始化程序。

public class Main {
  private static int num;
  {// An instance initializer
    System.out.println("Inside instance initializer.");
  }
  // A static initializer. Note the use of the keyword static below.
  static {
    num = 2014;
    System.out.println("Inside static initializer.");
  }

  // Constructor
  public Main() {
    System.out.println("Inside constructor.");
  }

  public static void main(String[] args) {
    System.out.println("Inside  main() #1.   num: " + num);
    // Declare a reference variable of the class
    Main si;
    System.out.println("Inside  main() #2.   num: " + num);
    new Main();    // Create an object

    System.out.println("Inside  main() #3.   num: " + num);
    new Main();// Create another object
  }
}

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