In Java, how can we know when super() is finished in constructor?

Question

AFAIK: When a subclass is created, all constructors implicitly or explicitly call super().

Example:

class subclass extends superclass {
    public subclass() {
        super();  // unnecessary, but explicit
    }

How can I know when super() is finished? I am creating a subclass of JTable that needs to auto-fit columns, but can only do so safely after super() is finished.

-- Edit --

To clarify based on comments below, imagine that super() will also call some class methods. I may override some of these methods in my subclass. I want to modify behaviour in these methods during base class construction. Perhaps certain required members will not yet be (completely) initialised...

It's finished when you reach the line after `super().` You can't even *write* any code before the super() call, so what exactly is the problem here? — user207421, Oct 24 '11 at 05:51
Maybe he is asking what happens if you don't explicitly write the `super()`, or why (where in the docs does it say this) you can't write code before the call? — Konerak, Oct 24 '11 at 06:28

score 3 · Answer 1 · answered Oct 24 '11 at 04:27

super() is finished when the call to super() returns (the same applies to any other method invocation, as well).

If you are calling it explicitly as per your example, then super() has finished executing when the line immediately after the super() call is reached. If you are allowing it to be called implicitly, then super() has finished by the time execution reaches the first line in your constructor.

Of course, it may be that case that super() is spawning one or more background threads which perform various tasks and which are still executing at the time when the call to super() returns. But that really has nothing to do with the call to super(). In such a case the time when the other tasks finish has nothing whatsoever to do with the time when the invocation of super() finishes.

score 2 · Answer 2 · answered Oct 24 '11 at 04:26

2

How about calling your code after super() finishes like this:

class subclass extends superclass {
    public subclass() {
        super();  // unnecessary, but explicit
        callYourFunctionHereKnowingThatSuperHasFinished();
    }
}

answered Oct 24 '11 at 04:26

spatulamania

6,613
2
30
26

score 2 · Answer 3 · answered Oct 24 '11 at 09:43

2

... imagine that super() will also call some class methods. I may override some of these methods in my subclass

The simple answer is "don't do this". It is madness.

answered Oct 24 '11 at 09:43

user207421

305,947
44
307
483

JTable during initialisation will fire events saying table data has changed. It is normal to overide these methods. How can I avoid? – kevinarpe Oct 25 '11 at 04:00

score 1 · Answer 4 · answered Oct 24 '11 at 04:26

Super is finished if the subclass instance was created. If the super() didn't complete, it would never return without exception to finish the constructor of the subclass - i.e. you would never have instantiated the subclass, if the super call didn't complete.

score 1 · Answer 5 · edited May 23 '17 at 12:19

The super() must be the first statement.

An implied super() is therefore included in each constructor which does not include either the this() function or an explicit super() call as its first statement. The super() statement invokes a constructor of the super class. The implicit super() can be replaced by an explicit super(). The super statement must be the first statement of the constructor.

And since the JVM will wait for the first statement to finish, your second statement is safe to manipulate the object or call super.methods() as it pleases.

score 0 · Answer 6 · answered Oct 24 '11 at 04:30

0

If you want to do columns auto size you shoud watch after the dataModel . . The data is in there.

answered Oct 24 '11 at 04:30

Deian

1,237
15
31

score 0 · Answer 7 · answered Oct 24 '11 at 04:36

The thing you are talking about is called Constructor Chaining.

Every constructor method will call up the chain until the class at the top has been reached and initialized. Then each subsequent class below is initialized as the chain winds back down to the original subclass. This process is called constructor chaining.

So yes, you can safely add your method after the super() call in the constructor of original subclass.

In Java, how can we know when super() is finished in constructor?

7 Answers7