How many objects are created due to inheritance in java?

Question

Let\'s say I have three classes:

class A {
    A() {
        // super(); 
        System.out.println(\"class A\");
    }
}
class B extends A {
    B() {
             


        

Answer 1

1. In your case only, 1 objects is getting created.
2. When subclasses constructor is called, it calls the constructor of super class internally to initailize super class's members.

Invoking constructor does not mean you are creating objects. Object is already created when invoking the constructor.The objects is created by the JVM first(i.e memory is allocated on heap and then constructor is called).

Constructor are meant for initializing the members of objects.

Answer 2

Steps of object creation when you call a constructor to create object:

1. Memory allocation using init is done. This init makes a system call to allocate memory for object creation.

2. Then your constructor is called to initialize the object's fields.

3. Then it calls super class constructor (If there's any super class) and Step 1 through 3 repeats.

What you see when you decompile a class file using javap shows different calls to be made. init makes system call to initialize memory allocation but object's field are initialized when constructor's code is run.

Answer 3

1. In your Case One object is created

2. while doing the following, this super() will provided by Compiler Implicitly

   class A {
   A() {
       System.out.println("class A");
   }
   }
   class B extends A {
   B() {
       System.out.println("class B");
   }
   }
   class C extends B {
   public static void main(String args[]) {
       C c = new C(); //
   }
   }
   

It is similar to calling a super() inside your methods

    B() {
        super();
        System.out.println("class B");
    }

The super keyword can also be used when a method is overridden in the current class, but you want to invoke the super class method.

super() will makes the all constructors reference to one class. (For easy understanding: Its like all the member functions are comes under a same class.) Its going to call all the constructor methods only.

So its done the work of calling constructor only, so super() will not done any object creation. Its just referring the member functions.

Answer 4

The super keyword enables a subclass to call the methods and fields of its superclass. It is not an instance of the superclass object but a way to tell the compiler which methods or fields to reference. The effect is the same as if the subclass is calling one of its own methods. Examples:

Consider a subclass Employee that extends its superclass Person:

public class Employee extends Person{

   public Employee()
   {
     //reference the superclass constructor 
     super(); 
   }

   public String getName()
   {
     //reference superclass behaviors
     return super.getFirstName() + " " + super.getLastName();
   }
 } 

The super keyword can be used to reference the constructer of the Person class or any of the behaviors or fields that it has access to (e.g., getFirstName() and getLastName()).

Answer 5

Your classes will be internally converted to something like this

class A
{
    A(){
        super(); 
        System.out.println("class A");
    }
}

class B extends A{
    B(){
        super(); 
        System.out.println("class B");
    }
}

public class C extends B
{
    public static void main(String args[])
    {
        C c  = new C(); //Parent constructor will get call 
    }
}

How many number of Object is created in this case.

Only one, which is instance of C, calling super() just invokes the constructor of parent class and doesn't create object

If one object is created then how internally Super() is calling Parent class Constructor . How Super is able to call parent class constructor.

When you create C's instance. C's constructor gets called, which first calls B's constructor, which in turn calls A's constructor

Answer 6

Great question. What you are probing is how Java initializes objects - and there are a number of steps involved.

i know is constructor is also a method (Maybe i am wrong).

Nearly right. The Constructor is a special method. If you decompile a class file, you'll see the constructors get renamed to <init>. <init> is treated differently from other methods and, for example, can't be called explicitly except through use of the keyword new or super. This is so fundamental that it is implemented in the JVM itself rather than being something defined in the Java language.

How many number of Object is created in this case.

One object is created - an instance of C.

C is additionally and simultaneously an instance of B and an instance of A and also Object.

If one object is created then how internally super() is calling Parent class Constructor . How Super is able to call parent class constructor.

This is where we get into initialization - initialization is how the JVM creates a new instance of an object and sets all the member values - those of the specific class and those of the superclasses. There are several stages involved:

• Load all the referenced classes and initialize those classes. Class initialization is itself non-trivial so I won't cover it here. It is well worth reading up.
• Allocate a chunk of memory for holding the members of the instance, which will include the all members of A, B and C. NOTE this explains one aspect of your question: how can the constructors of the base class and its subclasses update or refer to the same object - all the members of the instance from all classes are stored one after the other in the same chunk of memory.
• Initialize all the members to their default value. For example, int and float members will be set to 0 and 0.0f.

• Execute or calculate the member initializers, eg:

  private int a = 10;
  private int b = a * 5;
  private String c = Singleton.getInstance().getValue();
  

• Note (1) that member initialization occurs strictly in the order that members are declared in the class. This means that references to members later in the declaration are broken:

  private int a = b * 5; // Forward reference; won't compile
  private int b = 10;
  

• Note (2) that there is a under-used facility in Java to run arbitrary code to initialize values before the constructor is executed. These code blocks are executed at this time again strictly in order of declaration:

  private int a;
  private int b = 1;
  {
      // Initization occurs after b but before c.
      // c cannot be referenced here at all
      int i = SomeClass.getSomeStatic();
      a = i * 2;
  }
  private int c = 99;
  

• Execute the constructor of C. Constructors must either directly invoke a constructor from the superclass or the compiler will automatically add super() as the first line of the constructor. This means that the constructors are strictly executed in order:

  1. Object
  2. A
  3. B
  4. C

The object is now initialized and is ready for use. You can do some dangerous stuff if you initialize value using instance methods:

public class Wrong {
    int a = getB(); // Don't do this!
    int b = 10;
    public int getB() {
         return b;
    }
}

Here, a is initialized to 0. This is because, at the point getB() is invoked, Java has cleared the value of b to the default (0), but has not yet set it to 10 in the second phase of initialization.

In summary - there is only one object and it is created and initialized in a number in stages. During those stages, the object is, by definition, not completely defined.