在对象创建过程中到底发生了什么？ (爪哇)

Question

I've been studying from Head First Java and I'm currently on the constructors chapter. They've explained that an object is created by calling a constructor after the new keyword.

My question: What is it exactly that runs when you create a new object?

Let's take the following as sample code:

public class Const {

    // instance variables
    int number;
    String name;


    // Constructors
    public Const() {
        //implicit super
        System.out.println("no-arg constructor");
    }
    public Const(int i, String s) {
        //implicit super()
        number = i;
        name = s;
        System.out.println("two-arg constructor");
    }


    // test method
    public void doSomething() {
        System.out.println("I'm a test");
    }


    // Main
    public static void main(String[] args) {

        Const c1 = new Const();
        Const c2 = new Const(5, "Jerry");
    }
}

Now here is what I believe is happening under the hood when creating c1 :

1. public Const() is called
2. super() is called
3. the Object part of Const is built.
4. public Const() is back on top of the stack.
5. Now here comes my trouble. When and how exactly are the instance variables and methods for the object created (what implicit code is added)?

Answer 1

What exactly happens during object creation? (Java)

• Constructor being called, which will call the super method of the parent Class(By Default Object class, so the new Class will have access of all members of Object class)
• Memory Allocation
• Fields are initialized (by assigned value or if not given then by default value)
• rest code block of the constructor will be executed

So the only difference here is:

Const c1 = new Const();

Here number will be initialized by int default value which is 0 and name will be initialized by null , which is the default value of String

Const c2 = new Const(5, "Jerry");

Instead here it will be 5 and Jerry respecively

With the new Const() , the constructor will be called and the class will be loaded to the main memory.

public Const() {
        //implicit super 
        super()
    }

The super keyword in java is a reference variable that is used to refer parent class objects, which is by default Object class. The keyword “super” came into the picture with the concept of Inheritance.

So now it has access of all members of Object class ie toString, equals :

as you can access

c1.toString() or c1.equals(obj)

When and how exactly are the instance variables and methods for the object created (what implicit code is added)?

I think now you understood how instance variables are created, and the default values are assigned to them based on the type.

If still not clear, try to understand the internal arch, that might help:

JVM Arch