(Java) Difference ways of instantiating subclasses

Question

I have these two classes:

public class A {}
public class B extends A {}

In the main class, I would declare:

A a = new B();
B b = new B();

What is the difference between a and b ? Is this what we called a subtyping in java?

Answer 1

The difference between a and b is that with a you can only use the public API that the A class provides even though its really a B type object, but with b, you can use both the A's public API as well as B's public API.

For example:

Suppose A and B are defined as follows:

// A.java
public class A
{
  public void x()
  {
    z("X");
  }

  public void y()
  {
    z("Y");
  }

  protected void z(String message)
  {
    System.out.println(message);
  }
}

// B.java
public class B extends A
{
  public void a()
  {
    z("A");
  }

  public void b()
  {
    z("B");
  }
}

And here's a demo:

// Demo.java
public class Demo
{
  public static void main(String[] args)
  {
    A a = new B();
    B b = new B();

    // Can only call A's public methods
    a.x();
    a.y();
    // a.a(); Can't use
    // a.b(); Can't use

    // Can call all public methods
    b.a();
    b.b();
    b.x();
    b.y();
  }
}

Answer 2

Yes, there is difference between them. Accssibility of methods are different depends on what kind of reference you use.

Answer 3

A a = new B(); B b = new B();

a is a reference of Class A and b is a reference of class B. super class always can be used to point subclass object.

reference a able to access only super class method and properties

reference b able to access super class and it's own method and properties

one important thing is, ability of accessibility of function and properties will decided at runtime.

Answer 4

In below two cases

A a = new B();

a is an instantiation of B and of type A.

whereas in

B a = new B();

a is an instantiation of B and of type B.

The important thing to note here is that (in the first case) if you call a.someMethod(), the method of B will be called, not the method of A (this is called dynamic binding, as opposed to static binding).

Answer 5

This is basic inheritance. In the B b = ... case you can access all methods and variables provided from A and B but in the A case you can only use the methods and variables in the A case.

B gets typecasted into A when it is created, but that information is not required by the compiler.

public class A {
    int x;
}

public class B extends A {
    int y;
}

A a = new B();
B b = new B();

int c = a.x; //works
int c = a.y; //doesn't work
int c = b.y; //works
int c = b.x; //works

Remember, that you can always cast an object "downwards" in the inheritance chain. But you should not cast a object upwards because the variables for the subclass might be used even though they dont exist, for exmaple B b = new A(); So b.y is dangerous since the B object doesn't have an y variable defined.