CODEWITHSUNDEEP
javainheritance
Mrutyunjaya Thakur
Mrutyunjaya Thakur

Reputation: 161

Does creating an instance of a child class automatically create its super class object?

If I create an object of sub class then will the super class object also be created from which the sub class is inherited? If not then how by creating a sub class of Thread class (in multi-threading) calls the Thread class constructor and creates a Thread object?

Upvotes: 15

Views: 8609

Answers (6)

BraveNewCurrency
BraveNewCurrency

Reputation: 13065

When you create an object, it gets one piece of memory with one set of variables to hold the all of its data.

The subclass will contain fields from the child and any fields from its ancestors. So it's a single object that acts like the child and its ancestors. There is no parent class object created when you create a subclass.

Upvotes: 2

Noman_ibrahim
Noman_ibrahim

Reputation: 558

No there Is only one Object there. There Is a misconception that constructor is for creating an object. But It actually for initializing an object. So when we created child class object along with the child class constructor the parent class constructor also executed because of the first line of the child class constructor either this() or super(). Now, look at the following code.

Public class P{    
    public P(){    
        System.out.println(this.hashCode()); // Parent class Constructor    
    }   
}

public class C extends P{    
    public C(){
        System.out.println(this.hashCode()); // Child Class constructor    
    }
}

public class Test{    
    public static void main(String [] args){    
        C c = new C();
        System.out.println(c.hashCode());    
    }    
}

If you run the code you can see There is only one HashCode. and an object just has one hashCode. If the parent class object would be created then there must be another hashCode for that object.You can see The hashCodes are same

Upvotes: 1

krishna
krishna

Reputation: 1

Nope. It will not create instance of parent class. But certainly it will create an instance.And the object reference passed to child class. Hence instance is created at parent class and invoked by child class constructor. and child class methods operates.

Upvotes: -1

Vikrant Kashyap
Vikrant Kashyap

Reputation: 6846

Here I am abbreviating with an example that

If a child class object is created, does it automatically create super class object?

class P{
  P(){
   System.out.println(this.hashCode()); // it will print 2430287
  }
}

class C extends P{
   C(){
     System.out.println(this.hashCode());   // it will also print 2430287
    }
}

public class Test{

   public static void main(String... args){
        C obj = new C();
        System.out.println(c.hashCode());   //Again, it will print 2430287
   }     
}

If you compile and run this code you will find same Object hashCode is getting printed. So, this means there is only one object is created.

Now, how is the parent class object being initialized?

In this example only one object is created which is an instance of the child class, but there are two constructors (parent and child) being executed. But the constructor are just in context of child class only.

Upvotes: 0

Jon Skeet
Jon Skeet

Reputation: 1500495

An instance of the subclass is an instance of the superclass. Only one object is created, but as part of that creation, constructor calls are chained together all the way up to java.lang.Object. So for example:

public class Superclass {

    // Note: I wouldn't normally use public variables.
    // It's just for the sake of the example.
    public int superclassField = 10;

    public Superclass() {
        System.out.println("Superclass constructor");
    }
}

public class Subclass extends Superclass {

    public int subclassField = 20;

    public Subclass() {
        super(); // Implicit if you leave it out. Chains to superclass constructor
        System.out.println("Subclass constructor");
    }
}

...

Subclass x = new Subclass();
System.out.println(x instanceof Subclass);
System.out.println(x instanceof Superclass);
System.out.println(x.superclassField);
System.out.println(x.subclassField);

The output of this is:

Superclass constructor
Subclass constructor
true
true
10
20

... because:

  • The first thing any constructor does is call either another constructor in the same class, or a superclass constructor. So we see "Superclass constructor" before "Subclass constructor" in the output.
  • The object we've created is (obviously) an instance of Subclass
  • The object we've created is also an instance of Superclass
  • The single object we've created has both fields (superclassField and subclassField). This would be true even if the fields were private (which they usually would be) - the code in Subclass wouldn't be able to access a private field declared in Superclass, but the field would still be there - and still accessible to the code within Superclass.

The fact that we've got a single object with all the state (both superclass and subclass) and all the behaviour (any methods declared within Superclass can still be used on an instance of Subclass, although some may be overridden with more specializd behaviour) is crucial to understanding Java's approach to polymorphism.

Upvotes: 16

evenprime
evenprime

Reputation: 109

Youre only creating one object when you create a subclass of another. It is an instance of both the subclass and all its parents. Example, I create a cat object. It is a cat, and at the same time a feline, mammal, and animal, and an Object.

Upvotes: 2

Related Questions