在Java中模拟构造函数覆盖？

Question

有几次我认为在 Java 中拥有可覆盖的构造函数会很好。

“可覆盖”表示构造逻辑可以在降级类中被覆盖和/或扩展，就像可以覆盖普通方法一样，即能够在子类之后调用父方法。

这个任务可以被表述为有一个方法，比如说，称为init()，它在构造时被调用，但只能在堆栈的最后一个构造函数中调用。

喜欢：

public class InitializationOverride {

   public static class A {
      A() {
         System.out.println("Constructor of A");
      }

      void init() {
         System.out.println("Init of A");
      }
   }

   public static class B extends A {

      B() {
         System.out.println("Constructor of B");
      }

      @Override
      void init() {
         System.out.println("Init of B");
      }
   }

   public static class C extends B {

      C() {
         System.out.println("Constructor of C");
      }

      @Override
      void init() {
         System.out.println("Init of C");
      }
   }

   public static void main(String[] args) {

      new A(); // should print "Constructor of A, Init of A"
      new B(); // should print "Constructor of A, Constructor of B, Init of B"
      new C(); // should print "Constructor of A, Constructor of B, Constructor of C, Init of C"

   }
}

明显的方法是写

public static void main(String[] args) {

      new A().init();
      new B().init();
      new C().init();

   }

但这并不能保证init() 不会忘记调用。

有没有可能做点什么？

更新

在设计时不知道哪个类将是“最后一个”。预计将来会开发该类树。

更新 2

下面是反射和构造函数代码要求的解决方案，最后调用currentStage()：

public class InitializationOverride {

   public static class A {
      A() {
         System.out.println("Constructor of A");

         currentStage(A.class);
      }

      void currentStage(Class<?> cls) {
         if( cls == getClass() ) {
            init();
         }
      }

      void init() {
         System.out.println("Init of A");
      }
   }

   public static class B extends A {

      B() {
         System.out.println("Constructor of B");

         currentStage(B.class);
      }

      @Override
      void init() {
         System.out.println("Init of B");
      }
   }

   public static class C extends B {

      C() {
         System.out.println("Constructor of C");

         currentStage(C.class);
      }

      @Override
      void init() {
         System.out.println("Init of C");
      }
   }

   public static void main(String[] args) {

      new A(); // should print "Constructor of A, Init of A"
      new B(); // should print "Constructor of A, Constructor of B, Init of B"
      new C(); // should print "Constructor of A, Constructor of B, Constructor of C, Init of C"

   }

可以写得更简单吗？

Answer 1

构造函数不应调用可覆盖的方法。如果需要调用此类方法，更好的解决方案是保护构造函数并提供静态工厂方法：

public class InitializationOverride {

   public static class A {
      protected A() {
         System.out.println("Constructor of A");
      }

      public static A newInstance(){
        A a = new A();
        a.init();
        return a;
      }

      protected void init() {
         System.out.println("Init of A");
      }
   }

   public static class B extends A {

      protected B() {
         System.out.println("Constructor of B");
      }

      public static B newInstance(){
        B b = new B();
        b.init();
        return b;
      }

      @Override
      protected void init() {
         System.out.println("Init of B");
      }
   }

   public static class C extends B {

      protected C() {
         System.out.println("Constructor of C");
      }

      public static C newInstance(){
        C c = new C();
        c.init();
        return c;
      }

      @Override
      protected void init() {
         System.out.println("Init of C");
      }
   }

   public static void main(String[] args) {

      A.newInstance(); // should print "Constructor of A, Init of A"
      B.newInstance(); // should print "Constructor of A, Constructor of B, Init of B"
      C.newInstance(); // should print "Constructor of A, Constructor of B, Constructor of C, Init of C"

   }
}

编辑 更多解释：这种解决方案提供了好处，但也有缺点。您应该为类（即在 Javadoc 中）提供一个合同，扩展您的类的子类应该遵循这个对象创建标准。它还创建了更多代码。好处是对象以这种方式创建：

C obj = C.newInstance() 

...总是完全初始化，不需要记住调用 init() 方法显式。

请记住，它也是在类的包外创建对象的唯一方法（构造函数不可用），但在同一个包内的构造函数仍然可用（受保护的方法在同一个包内可用）

Answer 2

在Java中，当子class被实例化时，总是调用父类的默认constructor（除非指定了任何其他constructor）。现在，如果您需要有一个公共代码需要为所有classes 执行，建议将它放在constructor 中。但是，如果您希望仅在层次结构中的最后一个 class 中执行某些操作，那么 (a) 您可以将其写入最后一个 constructor 本身或 (b) 编写一个初始化块，下面的示例演示了这一点：

public class Test extends Test2{

    public Test(){
        System.out.println("In test");
        System.out.println("Init last");
    }

    {
        System.out.println("Init");
    }

    public static void main(String[] args) {
        new Test();
    }
}

class Test2{
    public Test2(){
        System.out.println("In test 2");
    }
}

Answer 3

像这样改变你的类构造函数，每个对象的init方法都会调用this.init()，你只需要改变最上层的构造函数。因为在创建对象时父类构造函数肯定会调用

public class Test {
    public static class A {

        public A() {

            this.init();
        }

        void init() {
            System.out.println("Called in A");
        }
    }

    public static class B extends A {

        @Override
        void init() {
            System.out.println("Called in B");
        }
    }

    public static class C extends B {

        @Override
        void init() {
            System.out.println("Called in C");
        }
    }

    public static void main(String[] args) {

        new A(); // should "Called in A" printed
        new B(); // should "Called in B" printed
        new C(); // should "Called in C" printed

    }
}

Answer 4

为此使用 super.init() 调用根父类 init()。