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

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

当前回答

这是官方回放: 从历史上看，this()或super()在构造函数中必须位于第一个。这限制从来不受欢迎，被认为是武断的。有一个一些微妙的原因，包括验证调用特殊，这导致了这种限制。这些年来，我们已经解决了这些都是虚拟机级别的，直到它变得实用考虑取消这一限制，不只是对记录，而是对所有人构造函数。

2022-02-22 03:59:53

其他回答

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

我知道我有点晚了，但我已经用过几次这个技巧了(我知道这有点不寻常):

我用一个方法创建了一个泛型接口InfoRunnable<T>:

public T run(Object... args);

如果我需要在把它传递给构造函数之前做一些事情，我只需要这样做:

super(new InfoRunnable<ThingToPass>() {
    public ThingToPass run(Object... args) {
        /* do your things here */
    }
}.run(/* args here */));

2016-07-22 17:22:38

我猜他们这样做是为了让那些编写处理Java代码的工具的人更轻松，在某种程度上也让阅读Java代码的人更轻松。

如果允许super()或this()调用移动，则需要检查更多的变化。例如，如果您将super()或this()调用移动到条件if()中，它可能必须足够聪明，将隐式super()插入到else中。如果调用super()两次，或者同时使用super()和this()，它可能需要知道如何报告错误。它可能需要禁止在接收器上调用方法，直到super()或this()被调用，并计算出何时会变得复杂。

让每个人都做额外的工作似乎是弊大于利。

2014-04-21 19:04:16

我相当肯定(那些熟悉Java规范的人会说)，它是为了防止你(a)被允许使用部分构造的对象，(b)强迫父类的构造函数在一个“新”对象上构造。

“坏”事情的一些例子是:

class Thing
{
    final int x;
    Thing(int x) { this.x = x; }
}

class Bad1 extends Thing
{
    final int z;
    Bad1(int x, int y)
    {
        this.z = this.x + this.y; // WHOOPS! x hasn't been set yet
        super(x);
    }        
}

class Bad2 extends Thing
{
    final int y;
    Bad2(int x, int y)
    {
        this.x = 33;
        this.y = y; 
        super(x); // WHOOPS! x is supposed to be final
    }        
}

2009-07-22 21:28:45

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

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

推荐文章

最新文章

标签