Java 使用静态块的构造函数重载

实例化一个对象会调用其对应的构造函数，这是面向对象编程中许多功能的基础。值得注意的是，任何使用对象的程序中都会无缝地生成一个默认构造函数，以便轻松地使用。

在这篇文章中，我们将深入探讨在Java中使用静态块进行构造函数重载的概念。构造函数重载是在一个类中定义多个具有不同参数的构造函数的概念。

语法

Public class class_name {
   Class_name() {
   }
   Class_name(par1, par2..) {
   }
}

使用带有静态块的构造函数可以在对象初始化过程中提供更多的功能和灵活性。

步骤

使用静态块进行构造函数重载，按照以下步骤进行：

步骤1 - 创建一个具有不同参数的多个构造函数的类。
步骤2 - 使用”static”关键字创建一个静态块。

这个块会在类被加载到内存时执行一次。

步骤3 - 当一个类被加载时，静态块先执行，然后在创建对象时执行构造函数。
步骤4 - 构造函数根据提供的参数被调用。

方法1：分别定义静态块

这种方法包括分别定义静态块和重载的构造函数。

示例

Class Class_name{
   Static {
   }
   Public class_name(){
   }
   Public class_name(int value) {
   }
   Public class_name(string name) {
   }
   //Other methods
}

在这种方法中，类可以有具有不同参数列表的重载构造函数，这些参数列表还包括初始化代码。还有一个独立的静态块，用于对类进行静态初始化。这个块只会执行一次。

示例

在这个示例中，我们将演示第一种方法。

class Emp { int id, exp;String name;static String company;
   static { company = "XYZ Corp"; }
   public Emp(){
      System.out.println("-"
                           + "\t"
                           + "-"
                           + "\t"
                           + "-"
                           + "\t"
                           + "\t"
                           + "-"); }
   public Emp(int id, String name){ System.out.println(id + "\t" + name + "\t"
                           + company + "\t" + exp); }
   public Emp(int id, String name, int exp) {
      System.out.println(id + "\t" + name + "\t"  + company + "\t" + exp); }
}
public class Way2Class {
   public static void main(String[] args) {
      System.out.println("Id"
                           + "\t"
                           + "Name"
                           + "\t"
                           + "Company"
                           + "\t"
                           + "Exp");
      Emp obj1 = new Emp(001, "Apoorva");
      Emp obj2 = new Emp(004, "Anu", 10);
      Emp obj3 = new Emp();
   }
}

输出结果

Id  Name    Company Exp
1   Apoorva XYZ Corp    0
4   Anu XYZ Corp    10
-   -   -       -

解释

在一家公司中，任何年头的员工都可能在同一家公司工作。因此，如果没有传入公司变量的值，则将自动将公司名称设置为同一家公司。为此，我们使用了静态块。

方法2：从构造函数调用静态方法

为了执行共享的初始化代码，您可以在类中声明静态方法，并从构造函数中调用它们。

示例

public class Way2Class {
   private int value;
   private String name;

   private static void initialize() {
      System.out.println("Common initialization code");
   }

   public Way2Class() {
      initialize();
      value = 0;
      name = "Default";
      System.out.println("No-arg constructor called");
   }

   public Way2Class(int value) {
      initialize();
      this.value = value;
      name = "Value";
      System.out.println("Int constructor called");
   }

   public Way2Class(String name) {
      initialize();
      value = 0;
      this.name = name;
      System.out.println("String constructor called");
   }

   public static void main(String[] args) {
      Way2Class obj1 = new Way2Class();
      Way2Class obj2 = new Way2Class(10);
      Way2Class obj3 = new Way2Class("Hello");
   }
}

输出

Common initialization code
No-arg constructor called
Common initialization code
Int constructor called
Common initialization code
String constructor called

说明

此示例中的Way2Class类包含三个构造函数，每个构造函数都调用静态的initialize()方法来执行共享的初始化代码。每个构造函数都调用被指定在类中的静态函数initialize()。根据给定的参数，在对象创建时调用适当的构造函数，并使用静态方法initialize()来执行共同的初始化代码。

方法1和方法2的比较

准则	方法1	方法2
类型	分开静态块	从构造函数调用静态方法
方法	重复使用具有不同构造函数的常见静态方法。	具有公共构造函数的分离静态方法。
方法逻辑	带有静态块的构造函数重载	带有静态块的构造函数重载