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

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

当前回答

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

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

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

2014-04-21 19:04:16

其他回答

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

2022-02-22 03:59:53

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

2020-11-07 10:24:42

父类的构造函数需要在子类的构造函数之前调用。这将确保如果在构造函数中调用父类上的任何方法，父类已经正确设置。

你要做的是，将参数传递给超级构造函数是完全合法的，你只需要像你所做的那样内联构造这些参数，或者将它们传递给你的构造函数，然后将它们传递给super:

public MySubClassB extends MyClass {
        public MySubClassB(Object[] myArray) {
                super(myArray);
        }
}

如果编译器没有强制执行，你可以这样做:

public MySubClassB extends MyClass {
        public MySubClassB(Object[] myArray) {
                someMethodOnSuper(); //ERROR super not yet constructed
                super(myArray);
        }
}

在父类有默认构造函数的情况下，编译器会自动插入对super的调用。由于Java中的每个类都继承自Object，所以必须以某种方式调用Object的构造函数，并且必须首先执行它。编译器可以自动插入super()。强制super首先出现，强制构造函数主体以正确的顺序执行，即:Object -> Parent -> Child -> ChildOfChild -> SoOnSoForth

2009-07-22 21:27:09

我相当肯定(那些熟悉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

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

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

举个例子:

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

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

推荐文章

最新文章

标签