为什么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 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

其他回答

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

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

你问为什么，其他的答案，在我看来，并没有真正说为什么它是可以调用你的超级构造函数，但只有当它是第一行。原因是您并没有真正调用构造函数。在c++中，等价的语法是

MySubClass: MyClass {

public:

 MySubClass(int a, int b): MyClass(a+b)
 {
 }

};

When you see the initializer clause on its own like that, before the open brace, you know it's special. It runs before any of the rest of the constructor runs and in fact before any of the member variables are initialized. It's not that different for Java. There's a way to get some code (other constructors) to run before the constructor really starts, before any members of the subclass are initialized. And that way is to put the "call" (eg super) on the very first line. (In a way, that super or this is kind of before the first open brace, even though you type it after, because it will be executed before you get to the point that everything is fully constructed.) Any other code after the open brace (like int c = a + b;) makes the compiler say "oh, ok, no other constructors, we can initialize everything then." So it runs off and initializes your super class and your members and whatnot and then starts executing the code after the open brace.

如果几行之后，它遇到一些代码说“哦，是的，当你构造这个对象时，这是我想让你传递给基类构造函数的参数”，那就太晚了，这没有任何意义。所以你会得到一个编译器错误。

2011-07-14 17:56:03

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()在构造函数中调用的依赖构造函数。如果由this()或super()调用的其他构造函数有问题，那么什么点执行其他语句，因为如果被调用的构造函数失败，所有的构造函数都会失败。

2018-10-04 14:03:44

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

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

推荐文章

最新文章

标签