为什么this()和super()必须是构造函数中的第一个语句?

Java要求，如果在构造函数中调用this()或super()，它必须是第一条语句。为什么?

例如:

public class MyClass {
    public MyClass(int x) {}
}

public class MySubClass extends MyClass {
    public MySubClass(int a, int b) {
        int c = a + b;
        super(c);  // COMPILE ERROR
    }
}

Sun编译器说，调用super必须是构造函数中的第一条语句。Eclipse编译器说，构造函数调用必须是构造函数中的第一个语句。

然而，你可以通过稍微重新安排代码来解决这个问题:

public class MySubClass extends MyClass {
    public MySubClass(int a, int b) {
        super(a + b);  // OK
    }
}

下面是另一个例子:

public class MyClass {
    public MyClass(List list) {}
}

public class MySubClassA extends MyClass {
    public MySubClassA(Object item) {
        // Create a list that contains the item, and pass the list to super
        List list = new ArrayList();
        list.add(item);
        super(list);  // COMPILE ERROR
    }
}

public class MySubClassB extends MyClass {
    public MySubClassB(Object item) {
        // Create a list that contains the item, and pass the list to super
        super(Arrays.asList(new Object[] { item }));  // OK
    }
}

因此，它不会阻止您在调用super()之前执行逻辑。它只是阻止您执行无法放入单个表达式中的逻辑。

调用this()也有类似的规则。编译器说，调用this必须是构造函数中的第一条语句。

为什么编译器有这些限制?你能给出一个代码例子，如果编译器没有这个限制，就会发生不好的事情吗?

当前回答

因此，它不会阻止您在调用之前执行逻辑超级。它只是阻止你执行你无法适应的逻辑变成一个表达式。

实际上，你可以用几个表达式执行逻辑，你只需要把你的代码包装在一个静态函数中，然后在超级语句中调用它。

举个例子:

public class MySubClassC extends MyClass {
    public MySubClassC(Object item) {
        // Create a list that contains the item, and pass the list to super
        super(createList(item));  // OK
    }

    private static List createList(item) {
        List list = new ArrayList();
        list.add(item);
        return list;
    }
}

2014-06-18 09:00:35

其他回答

在调用子对象的构造函数之前，可以使用匿名初始化块初始化子对象中的字段。这个例子将演示:

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

class Parent {
    public Parent() {
        System.out.println("In parent");
    }
}

class Child extends Parent {

    {
        System.out.println("In initializer");
    }

    public Child() {
        super();
        System.out.println("In child");
    }
}

这将输出:

在父在初始化在儿童

2009-07-22 21:34:35

因为JLS是这么说的。是否可以以兼容的方式更改JLS以允许它?是的。

然而，这会使语言规范变得更加复杂，因为语言规范已经足够复杂了。这不是一件非常有用的事情，并且有一些方法可以绕过它(使用静态方法或lambda表达式this(fn())的结果调用另一个构造函数-该方法在另一个构造函数之前调用，因此也是超级构造函数)。所以改变的功率重量比是不利的。

请注意，该规则本身并不阻止在父类完成构造之前使用字段。

想想这些非法的例子。

super(this.x = 5);

super(this.fn());

super(fn());

super(x);

super(this instanceof SubClass);
// this.getClass() would be /really/ useful sometimes.

这个例子是合法的，但却是“错误的”。

class MyBase {
    MyBase() {
        fn();
    }
    abstract void fn();
}
class MyDerived extends MyBase {
    void fn() {
       // ???
    }
}

在上面的例子中，如果MyDerived。fn需要MyDerived构造函数的参数，它们需要通过ThreadLocal进行处理。；（

顺便提一下，自Java 1.4以来，包含外部this的合成字段在调用内部类的超构造函数之前被赋值。这在针对早期版本编译的代码中导致了特殊的NullPointerException事件。

还要注意，在存在不安全发布的情况下，构造可以由其他线程重新排序查看，除非采取了预防措施。

编辑2018年3月:在消息记录:构造和验证中，Oracle建议删除此限制(但与c#不同的是，在构造函数链接之前，这将肯定是未分配的(DU))。

从历史上看，this()或super()在构造函数中必须位于第一个。这限制从来不受欢迎，被认为是武断的。有一些微妙的原因，包括验证 invokspecial，导致了这种限制。多年来，我们已经在虚拟机级别解决了这些问题，直到它变成考虑取消这一限制是可行的，不仅仅是为了记录，但对于所有的构造函数。

2009-07-22 21:38:30

在子类构造函数中添加super()的主要目标是编译器的主要工作是将所有类与Object类建立直接或间接的连接，这就是为什么编译器检查我们是否提供了super(参数化)，然后编译器不承担任何责任。这样所有的实例成员从Object初始化为子类。

2020-11-07 10:24:42

我完全同意，限制太严格了。使用静态辅助方法(如Tom Hawtin - tackline所建议的)或将所有“pre-super()计算”推入参数中的单个表达式并不总是可行的，例如:

class Sup {
    public Sup(final int x_) { 
        //cheap constructor 
    }
    public Sup(final Sup sup_) { 
        //expensive copy constructor 
    }
}

class Sub extends Sup {
    private int x;
    public Sub(final Sub aSub) {
        /* for aSub with aSub.x == 0, 
         * the expensive copy constructor is unnecessary:
         */

         /* if (aSub.x == 0) { 
          *    super(0);
          * } else {
          *    super(aSub);
          * } 
          * above gives error since if-construct before super() is not allowed.
          */

        /* super((aSub.x == 0) ? 0 : aSub); 
         * above gives error since the ?-operator's type is Object
         */

        super(aSub); // much slower :(  

        // further initialization of aSub
    }
}

正如Carson Myers所建议的那样，使用“尚未构造的对象”异常会有所帮助，但是在每个对象构造期间检查这个异常会减慢执行速度。我希望Java编译器能够更好地区分(而不是不合理地禁止if语句，但允许在形参中使用?-操作符)，即使这会使语言规范复杂化。

2011-07-14 17:38:30

class C
{
    int y,z;

    C()
    {
        y=10;
    }

    C(int x)
    {
        C();
        z=x+y;
        System.out.println(z);
    }
}

class A
{
    public static void main(String a[])
    {
        new C(10);
    }
}

请看例子，如果我们调用构造函数C(int x)，那么z的值取决于y，如果我们不在第一行调用C()，那么这将是z的问题，z将无法得到正确的值。

2017-03-02 06:00:09

为什么this()和super()必须是构造函数中的第一个语句?

推荐文章

最新文章

标签