Question

假设从子类调用超类的构造函数，子类隐藏构造函数调用的超类的方法。然后java使用超类构造函数中子类的方法。但在大多数情况下，这不是理想的行为，因为超类的设计并未考虑子类 - 它是另一种方式。

如何使用超类自己的方法强制执行初始化而不使它们成为最终或静态，重命名它们或将代码复制到构造函数中？（或者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.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）。

解决方案：

私人和最终方法只有你说的
如果你有几个构造函数调用this(...)并在一个构造函数中收集所有精心的初始化。

所以没有init方法。对于具有复杂初始化的构造函数，它也可能是代码气味，然后难以进行单元测试。然后构造函数不应该做太多，另外一个方法应该做的工作：void open(...)等。特别是当有几个构造函数时。

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

1 个答案: