为什么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必须是构造函数中的第一条语句。

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

当前回答

我完全同意，限制太严格了。使用静态辅助方法(如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

我完全同意，限制太严格了。使用静态辅助方法(如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
    }
}

2011-07-14 17:38:30

这是因为你的构造函数依赖于其他构造函数。要使你的构造函数正常工作，其他构造函数正常工作是必要的，这是依赖的。这就是为什么有必要首先检查由this()或super()在构造函数中调用的依赖构造函数。如果由this()或super()调用的其他构造函数有问题，那么什么点执行其他语句，因为如果被调用的构造函数失败，所有的构造函数都会失败。

2018-10-04 14:03:44

Java为什么这样做的问题已经有了答案，但由于我无意中发现了这个问题，希望找到一个更好的单行程序的替代品，因此在此分享我的解决方法:

public class SomethingComplicated extends SomethingComplicatedParent {

    private interface Lambda<T> {
        public T run();
    }

    public SomethingComplicated(Settings settings) {
        super(((Lambda<Settings>) () -> {

            // My modification code,
            settings.setting1 = settings.setting2;
            return settings;
        }).run());
    }
}

调用静态函数应该执行得更好，但如果我坚持将代码“置于”构造函数内部，或者如果我必须更改多个参数，并且发现定义许多静态方法不利于可读性，我会使用这种方法。

2020-09-29 01:00:36

实际上，super()是构造函数的第一个语句，因为要确保在构造子类之前父类已经完全形成。即使在第一个语句中没有super()，编译器也会为你添加它!

2017-12-30 02:40:08

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

推荐文章

最新文章

标签