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

Answer 1

1. In

A x = new A();

x is an instantiation of A and of type A.

whereas in

A x = new B();

x is an instantiation of B and of type A.

---

2. The important thing to note here is that (in the second case) if you call x.someMethod(), the method of B will be called, not the method of A (this is called dynamic binding, as opposed to static binding). Furthermore, casting changes only the type, so

A x = new B();
((A)x).run_function();  // Need extra parenthesis!

will still call B's method.

---

As I said above, you need to include those extra parenthesis since

(A)x.run_function();

is equivalent to

(A)(x.run_function());

Answer 2

1. There is no real difference. Actually for the second case A olds a B object, but B is an A so thats no problem. B in this case behaves like A.

2. It will call B's run_function()

Answer 3

1.What is the difference between: A x = new A();and A x = new B();

The difference is that in the first case, you are instantiating a class of type A. So you will only be able to call methods defined in A. IN the second case, if the same name method exists in both A and B, then the B implementation will be invoked at runtime.

However, in the second case, using reflection, it will also be possible to invoke methods that are defined in Class B and not in Class A.

A x = new B(); (A)x.run_function();Let's say that both A and B have the function run_function, which one will be executed ?

Remember - Overriding is decided at runtime whereas overloading is decided at compile time.

So the method in class B will be invoked at runtime based on Dynamic Binding.

Answer 4

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.

Answer 5

Case 1:

You will see difference when you have a method in B which is NOT in A.

When you try to call that method using reference 'x' it won't be visible.

Case 2:

All method calls will be based on object type not reference type due to polymorphism (except static methods)

A x = new B();

In this case B class run_function will be executed.

A x = new A();

In this case A class run_function will be executed.

Answer 6

Furthermore with:

A x = new B()

You will not be able to execute methods that are defined in B and that are not defined in A. However as indicated previously because of polymorphism in Java if you do execute any methods and B' has overridden these methods then it will use B's implementation.