如何在所有子构造函数中自动包含父方法的执行？

Question

我有一个抽象类（Parent），它有一个抽象方法（doSetup）和一个调用doSetup 方法的成员方法。我需要的是子类（实现Parent）在构造时应该自动调用doSetup 方法，不管子类可能有多少构造函数。是否有 Java 机制或设计模式可以帮助我解决这个问题？

public abstract class Parent {
  abstract protected void sayHi();
  protected void doSetup() {
    sayHi();
  }
}

public class Child1 extends Parent {
  @Override
  protected void sayHi() {
    System.out.println("hi");
  }
  public Child1() {
    // Construction needs to automatically include exec of doSetup()
  }
  public Child1(String string) {
    // Construction needs to automatically include exec of doSetup()
    System.out.println("another constructor");
  }
}

Answer 1

这是实现通用构造代码的一种方式：

Parent.java

public abstract class Parent {
    public Parent() {
        this("Default Value Goes Here");
    }

    // Funneling everything through this main constructor.
    public Parent(String value) {
        this.doSetup(value);
    }

    // I've made this method private, as it shouldn't really
    // be accessed from sub classes, but if you require that, then
    // mark this method as protected & final instead.
    private void doSetup(String value) {
        System.out.println(value);
    }
}

Child.java

public class Child extends Parent {
    // Deliberately not implementing constructors here,
    // but if I did, the first call would be to a super()
    // constructor to retain parent's construction functionality.
}

MainApp.java

public class MainApp {
    public static void main(String[] args) {
        Child child = new Child();
    }
}

运行上面的MainApp，你会看到默认值构造函数运行，它会输出“Default Value Goes Here”，因为它是由父构造函数强制执行的。

Answer 2

一个好的 IDE 可能会警告不要在构造函数中使用可覆盖的方法。

原因可以用下面的代码来证明，这可能会产生令人惊讶的结果。

class Base {
    Base() {
        init();
    }

    protected void init() {
    }
}
class Child extends base {
    String a = "a";
    String b;
    String c = "c";
    String d;

    public Child() {
        // 1. Fields are nulled
        // 2. super() called
        // 2.1. init() called
        // 3. Field initialisations done (a, c)
        // 4. Rest of constructor:
        System.out.printf("EndConstr a: %s, b: %s, c: %s%n", a, b, c);
    }

    @Overridable
    protected void init() {
        System.out.printf("Init a: %s, b: %s, c: %s%n", a, b, c);
        c = "cc";
        d = "dd";
    }
}

---

控制行为的一种解决方案是提供一个最终的不​​可覆盖方法，该方法以指定的方式调用可覆盖的受保护方法：

class Base {
    public final void f() {
        X x = ...;
        onF(x);
    }
    protected /*abstract*/ void onF(X x) {
    }
}
class Child extends Base {
    @Overridable
    protected void onF(X x) {
        ...
    }
}

Answer 3

为什么不在父构造函数中包含doSetup()？为了避免从构造函数调用可覆盖的方法，你可以稍微改变你的模式：

public abstract class Parent {
  final String greeting;

  public Parent(String greeting) {
    this.greeting = greeting;
    doSetup();
  }

  final void doSetup() {
    System.out.println(greeting);
  }
}

那么你的每个子类的构造函数都需要显式调用超级构造函数，例如：

public class Child1 extends Parent {
  private static String default_greeting = "hi";

  public Child1() {
    super(default_greeting); // prints "hi"
  }

  public Child1(String string) {
    super(string); // print a different greeting
  }
}

Answer 4

正如其他人所说，您不应该从超类的构造函数中调用可覆盖的方法。这是为了避免this to escape 并最终产​​生难以调试的竞争条件，或者只是避免在从覆盖的方法中访问尚未初始化的字段时抛出NullPointerExceptions。

现在，关于这个问题，如果你想对所有构造函数运行公共代码，你需要一个initializer block：

public abstract class Parent {
    {
         // this is an initializer block that is inherited 
         // by all subclasses and runs for every constructor
         // in the hierarchy
        this.doSetup();
    }

    protected final void sayHi() { // final to avoid this to escape
        System.out.println("hi");
    }

    protected final void doSetup() { // final to avoid this to escape
        sayHi();
    }
}

public class Child1 extends Parent {

    public Child1() {
        // initilizer block automatically called
    }

    public Child1(String string) {
        // initilizer block automatically called
        System.out.println("another constructor");
    }
}

运行此测试：

new Child1();
new Child1("something");

产生以下输出：

hi
hi
another constructor