How is a child object constructed in Java?

In java, how is a child object constructed?
I just started inheritance and these few points are not very clear to me:

Does the child object depend only on the child class' constructor, or does it also depend on the parent's constructor? I need some details about that point.

Also, is super() always called by default in a child constructor?

Any other information regarding this topic is appreciated.

I don't think "A child object" is a good way to think about this.

You're making an object. Like all objects, it is an instance of some specific class, (After all, new SomeInterface() does not compile) and like (almost) all objects, it is made because some code someplace (doesn't have to be your code, of course) ran the java expression new SomeSpecificClass(args); somewhere.

We could say it is a 'child object' because SomeSpecificClass is a child class of some other class.

But that's rather useless. That means the only way to ever make a new 'non-child' object would be to write new Object(); - after all, all classes except java.lang.Object are a child class: If you write public class Foo {}, java will interpret that exactly the same as if you had written public class Foo extends java.lang.Object {}, after all.

So, barring useless* irrelevancies, all objects are child objects, and therefore as a term, 'child object', I'd not use that.

That also means that ALL object creation goes through this 'okay and in what order and how do the constructors work' song and dance routine.

How it works is probably most easily explained by desugaring it all. Javac (the compiler) injects things if you choose to omit them, because a lot of things that feel optional (such as a constructor, a super call, or an extend clause), at the class file / JVM level, aren't**.

Sugar #1 - extends clause

Already covered: if you have no extends clause on your class def, javac injects extends java.lang.Object for you.

Sugar #2 - no super call in constructor

A constructor must either call some specific super constructor on its very first line, or, it it must call some other constructor from the same class on its very first line (this(arg1, arg2);). If you don't, java will inject it for you:

public MyClass(String arg) { this.arg = arg; }
// is treated as:
public MyClass(String arg) {
    super();
    this.arg = arg;
}

Notably including a compiler error if your parent class has no zero-arg constructor available.

Sugar #3: No constructor

If you write a class that has no constructor, then java makes one for you:

public YourClass() {}

It will be public, it will have no args, and it will have no code on it. However, as per sugar #2 rule, this then gets expanded even further, to:

public YourClass() {super();}

Field inits and code blocks get rewritten to a single block.

The constructor isn't the only thing that runs when you make new objects. Imagine this code:

public class Example {
    private final long now = System.currentTimeMillis();
}

This code works; you can compile it. You can make new instances of Example, and the now field will hold the time as it was when you invoked new Example(). So how does that work? That feels a lot like constructor code, no?

Well, this is how it works: Go through the source file top to bottom and find every non-static initializing code you can find:

public class Example {
    int x = foo(); // all non-constant initial values count
    {
        x = 10;
        // this bizarre constructor is legal java, and also
        // counts as an initializer.
    }
}

and then move all that over to the one and only initializer that classes get, in the order you saw them.

Ordering

So, via sugar rules we have reduced ALL classes to adhere to the following rules:

1. ALL classes have a parent class.
2. ALL classes have at least 1 constructor.
3. ALL constructors invoke either another constructor or a constructor from parent.
4. There is one 'initializer' code block.

Now the only question is, in what order are things executed?

The answer is crazy. Hold on to your hats.

This is the order:

First, set all fields to 0/false/null of the entire 'construct' (the construct involves every field from Child all the way down to Object, of course).

Start with the actual constructor invoked on Child. Run it directly, which means, start with the first line, which neccessarily is either a this() or a super() invocation.

Evaluate the entire line, notably, evaluate all expressions passed as arguments. Even if those are themselves invocations of other methods. But, javac will do some minor effort to try to prevent you from accessing your fields (because those are all uninitialized! I haven't mentioned initializers yet!!).

Yeah, really. This means this:

public class Example {
    private final long x = System.currentTimeMillis();

    public Example() {
        super(x); // x will be .... 0
        // how's that for 'final'?
    }
}

This will either end up invoking the first line of some other constructor of yours (which is itself also either a this() or a super() call). Either we never get out of this forest and a stack overflow error aborts our attempt to create this object (because we have a loop of constructors that endlessly invoke each other), or, at some point, we run into a super() call, which means we now go to our parent class and repeat this entire song and dance routine once more.

We keep going, all the way to java.lang.Object, which by way of hardcoding, has no this() or super() call at all and is the only one that does.

Then, we stop first. Now the job is to run the rest of the code in the constructor of j.l.Object, but first, we run Object's initializer.

Then, object's constructor runs all the rest of the code in it.

Then, Parent's initializer is run. And then the rest of the parent constructor that was used. and if parent has been shifting sideways (this() invokes in its constructors), those are all run in reverse order as normal in method invocations.

We finally end up at Child; its initializer runs, then the constructor(s) run in order, and finally we're done.

Show me!

class Parent {
    /* some utility methods so we can run this stuff */
    static int print(String in) {
        System.out.println("@" + in);
        return 0;

        // we use this to observe the flow.
        // as this is a static method it has no bearing on constructor calls.
    }

    public static void main(String[] args) {
        new Child(1, 2);
    }

    /* actual relevant code follows */
    Parent(int arg) {
        print("Parent-ctr");
        print("the result of getNow: " + getNow());
    }
    int y = print("Parent-init");

    long getNow() { return 10; }
}

class Child extends Parent {
    Child(int a, int b) {
        this(print("Child-ctr1-firstline"));
        print("Child-ctr1-secondline");
    }

    int x = print("Child-init");

    Child(int a) {
        super(print("Child-ctr2-firstline"));
        print("Child-ctr2-secondline");
    }

    final long now = System.currentTimeMillis();

    @Override long getNow() { return now; }
}

and now for the great puzzler. Apply the above rules and try to figure out what this will print.

>! @Child-ctr1-firstline<br>
>! @Child-ctr2-firstline<br>
>! @Parent-init<br>
>! @Parent-ctr<br>
>! @the result of getNow: 0<br>
>! @Child-init<br>
>! @Child-ctr2-secondline<br>
>! @Child-ctr1-secondline<br>

• Constructor execution ordering is effectively: the first line goes first, and the rest goes last.
• a final field was 0, even though it seems like it should never be 0.
• You always end up running your parent's constructor.

--

*) You can use them for locks or sentinel pointer values. Let's say 'mostly useless'.

**) You can hack a class file so that it describes a class without a parent class (not even j.l.Object); that's how java.lang.Object's class file works. But you can't make javac make this, you'd have to hack it together, and such a thing would be quite crazy and has no real useful purpose.

• In inheritance, the construction of a child object depends on at least one parent constructor.
• Calling the super () method is not mandatory. By default, Java will call the parent constructor without argument except if you precise a custom constructor.
• Here an example

Mother

public class Mother {

int a;

public Mother() {
    System.out.println("Mother without argument");
    a = 1;
}

public Mother(int a) {
    System.out.println("Mother with argument");
    this.a = a;
}

}

child

 public class Child extends Mother {

public Child() {
    System.out.println("Child without argument");
}

public Child(int a) {
    super(a);
    System.out.println("Child with argument");
}

}

If you do this :

Child c1 = new Child();

you will get :

Mother without argument
Child without argument

If you do this :

Child c1 = new Child(a);

You will get :

Mother with argument
Child with argument

But if you change the second child constructor to and remove the super(arg) the parent constructor without argument will be called :

    public Child(int a) {
    //        super(a);
    System.out.println("Child with argument");
    }

You will get :

Mother without argument
Child with argument

• May be this course for beginners can help you Coursera java inheritance