java - java中如何强制构造函数使用类自己的方法

Question

假设从子类调用父类(super class)的构造函数，并且子类隐藏构造函数调用的父类(super class)的方法。然后java在父类(super class)的构造函数中使用子类的方法。但在大多数情况下，这不是所需的行为，因为父类(super class)在设计时并未考虑到子类 - 情况恰恰相反。

如何使用父类(super class)自己的方法强制执行初始化，而不将它们设为最终或静态、重命名它们或将代码复制到构造函数中？ (或者java不支持/不鼓励在构造函数中使用可重写方法？如果是，那么为什么？这种令人不满意的行为的隐藏原理是什么？)

我尝试了显式转换...

((SuperClass) this).method()

...这不起作用。

示例:

3   class SuperClass {
4       private int[] valField = new int[10];
5   
6       SuperClass(int[] cloneField) {
7           for (int i = 0; i < 10; i++) set(i, cloneField[i]);
8       }
9   
10      void set(int pos, int val) {
11          if (val < 0) throw new IllegalArgumentException("val must be positive; val was " + val);
12          if (pos < 0 || pos > 10) throw new IllegalArgumentException("pos must be within [0, 10]; pos was " + pos);
13          valField[pos] = val;
14      }
15  
16      int get(int pos) {
17          return valField[pos];
18      }
20  }


6   class SubClass extends SuperClass {
7       private Set<Integer> isZero = new HashSet();
8   
9       SubClass(int[] cloneField) {
10          super(cloneField);
11          isZero.clear();
12          for (int i = 0; i < 10; i++) 
13              if (this.get(i) == 0) 
14                  isZero.add(i); 
15      }
16      
17      void set(int pos, int val) {
18          super.set(pos, val);
19          if (val == 0) isZero.add(pos);
20          else isZero.remove(pos);
21      }
22  }

这会导致:

Exception in thread "main" java.lang.NullPointerException
    at testingJava.SubClass.set(SubClass.java:19)
    at testingJava.SuperClass.<init>(SuperClass.java:7)
    at testingJava.SubClass.<init>(SubClass.java:10)
    at testingJava.MainClass.main(MainClass.java:9)

编辑:一些进一步的测试和探索表明有一个奇怪的解决方案。将父类(super class)分成两部分并在构造函数中使用 super.method() 似乎给了 java 解释器一个足够清晰的标志，让他能够找出正确的方法。

示例:

class SuperClass {
    void message() {
        System.out.println("I am the super class.");
    }
}

class MiddleClass extends SuperClass {
    MiddleClass() {
        super.message();
    }
}

class SubClass extends MiddleClass {
    void message() {
        System.out.println("I am the sub class.");
    }
}

现在...

SubClass mySubClass = new SubClass();

...评估为:

I am the super class.

Answer 1

永远不应该在可扩展类中调用可重写的方法:

class A {
    A() {
        init();
    }
    void init() {
    }
}

class B extends A {
    String s = "";
    String t = null;
    String u;

    B() {
        // - s, t and u are zeroed (null)
        // - super() is called
        // - - init() assign "sss" to s, "ttt" to t and "uuu" to u
        // - field initialisations are done for initialized fields
        //   assigns "" to s and null to t.
        System.out.printf("s=%s, t=%s, u=%s%n", s, t, u);
        // s=, t=null, u=uuu
    }

    @Override
    void init() {
        s = "sss";
        t = "ttt";
        u = "uuu";
    }
}

由于容器类通常在此类“init”方法中“初始化”，因此会出现 NullPointerException 或丢失初始化结果(此处为 s)。

解决办法:

• 仅按照您所说的私有(private)和 final方法
• 如果您有多个构造函数，则调用 this(...) 并将所有精心设计的初始化收集到一个构造函数中。

所以没有初始化方法。对于具有复杂初始化的构造函数来说，它也可能是一种代码味道，很难进行单元测试。那么构造函数不应该做太多事情，而应该有一个额外的方法来完成这项工作:void open(...) 等等。特别是当有多个构造函数时。