Question

The following code:

class Base{}

class Agg extends Base{

   public String getFields(){
    String name="Agg";
    return name;
   }
}

public class Avf{
   public static void main(String args[]){
   Base a=new Agg();
   //please take a look here
   System.out.println(((Agg)a).getFields());  // why a needs cast to Agg? 

  }
}

My question is: why we can’t replace ((Agg)a).getFields() to a.getFields()? Why we need to type cast on a？ And I mention that getFields() is not defined in class Base, thus class Agg does not extend this method from its base class. But if I defined method getFields() in class Base,
like:

class Base{
    public String getFields(){
        String name="This is from base getFields()";
        return name;
    }
}

everything would be all right. Then
((Agg)a).getFields() is equivalent to a.getFields()

In the code

Base a=new Agg();    

Does this line means a has the reference of Agg() and a can invoke directly the method of class Agg. But why is there difference if I do not define the method getFields() in class Base? Can any one explain this to me?

Answer 1

System.out.println(((Agg)a).getFields()); // why a needs cast to Agg?

Because Base doesn’t have a method called getFields.

The declaration

Base a;

…tells the compiler the interface you’re going to use when using a. It doesn’t matter that you then assign new Agg(); to it, the interface you have to a is still Base. And since Base doesn’t have getFields, trying to use getFields is a compilation error.

Base a=new Agg();

Does this line means a has the reference of Agg() and a can invoke directly the method of class Agg.

It means a contains a reference to an Agg object, but the interface to that object is defined by Base, not Agg, and so you can’t call Agg methods on it if they’re not defined by Base (without a cast, and casts are dangerous and should be avoided where possible).

If your code needs access to methods or fields defined by Agg, then the variable (or argument, in my example) should be declared Agg a, not Base a.

This is a fundamental thing about OOP in general and the OOP implementation in Java in particular: There’s a big difference between the interface to an object and the implementation of the object. In your example, you know Base a is really an Agg, but consider this:

void foo(Base a) {
    // Use `a` here...
}

// A long time later in a class far, far away...
xyz.foo(new Agg());

Clearly here the compiler shouldn’t allow you to use methods or fields on a that aren’t defined by Base. It’s the same situation in your code, just less obvious.