Java: difference between A x = new A() and A x = new B() when B extends A [duplicate]

by

The most important difference is between the static and dynamic types of objects and references to objects.

Say B extends A and C extends B.

The dynamic type of an object (the type used in the new) is its actual runtime type: it defines the actual methods that are present for an object.

The static type of an object reference (a variable) is a compile-time type: it defines, or rather declares, which methods can be called on the object the variable references.

The static type of a variable should always be of the same type or a supertype of the dynamic type of the object it references.

So in our example, a variable with static type A can reference objects with dynamic types A, B and C.
A variable with static type B can reference objects with dynamic types B and C.
A variable with static type C can only reference objects with dynamic type C.

Finally, calling a method on an object reference is a subtle and complex interaction between static and dynamic types. (Read the Java Language Spec on method invocation if you don’t believe me.)

If both A and B implement a method f() for example, and the static type is A and the dynamic type involved is C for a method invocation, then B.f() will be invoked:

B extends A, C extends B
public A.f() {}
public B.f() {}
A x = new C(); // static type A, dynamic type C
x.f(); // B.f() invoked

Simplifying greatly: first the static types of both receiver (type A) and arguments (no args) are used to decide the best-matching (most specific) method signature for that particular invocation, and this is done at compile-time. Here, this is clearly A.f().

Then, in a second step at runtime, the dynamic type is used to locate the actual implementation of our method signature. We start with type C, but we don’t find an implementation of f(), so we move up to B, and there we have a method B.f() that matches the signature of A.f(). So B.f() is invoked.

In our example we say that method B.f() overrides method A.f(). The mechanism of overriding methods in a type hierarchy is called subtype polymorphism.

More Related Contents:

  1. Difference between Inheritance and Composition
  2. Do subclasses inherit private fields?
  3. Why is there no multiple inheritance in Java, but implementing multiple interfaces is allowed?
  4. How to determine an object’s class?
  5. What is an interface in Java?
  6. Explicitly calling a default method in Java
  7. Why is it not possible to extend annotations in Java?
  8. Why to use Interfaces, Multiple Inheritance vs Interfaces, Benefits of Interfaces?
  9. Is there a way to override class variables in Java?
  10. When do I use super()?
  11. Why do we assign a parent reference to the child object in Java?
  12. Why we can’t do List mylist = ArrayList(); [duplicate]
  13. Inheritance in Java – creating an object of the subclass invokes also the constructor of the superclass. Why exactly?
  14. Is polymorphism possible without inheritance?
  15. Calling super super class method
  16. What are the rules dictating the inheritance of static variables in Java?
  17. Can an interface extend multiple interfaces in Java?
  18. can’t cast to implemented interface
  19. How can a derived class invoke private method of base class?
  20. Builder Pattern and Inheritance
  21. Are static variables inherited
  22. Private methods in Inheritance
  23. Why does every object in Java implicitly extend java.lang.Object class?
  24. Java method overriding and variable shadowing
  25. Java generic method inheritance and override rules
  26. When do instance variables get initialized and values assigned?
  27. Does an instance of superclass get created when we instantiate an object?
  28. Initialize field before super constructor runs?
  29. Using a private variable in a inherited class – Java
  30. How to enable enum inheritance

Leave a Comment