Call a method of subclass in Java

Question

If I have a base class Base thing = null; of which there is a subclass class Subclass extends Base and I instigate it as thing = new Subclass how would I call a method that is specifically in Subclass, but not in Base? ex. Base has only method() Subclass has method() and specialMethod() the method specialMethod() is the one I want to call.

Answer 1

If you know that thing contains a Subclass, you can do:

((Subclass) thing).specialMethod()

Answer 2

The others have already mentioned how to cast objects to get an answer to your question, but asking that question in the first place points to a possible design problem. Some possible reasons:

• The method is in the wrong place.
• The code which calls the method is in the wrong place.
• The subclass should not extend the other class. It's best to prefer composition over inheritance. And when inheriting, the code should follow the Liskov substitution principle.
• The classes are non-cohesive, they have more than one responsibility, and they should be split into multiple classes.

Answer 3

You have to cast it to be able to invoke the method:

Base thing = new SubClass();

((SubClass) thing ).specialMethod();

If you face this situation, most likely you don't have the right interface ( the right set of methods )

Before going deep into the stage where you start validating everything to know if you can invoke a method or not like in:

 public void x ( Base thing ) {
     if( thing.instanceof Subclass ) {
         ((SubClass)thing).specialMethod();
     }
 }

Consider if you don't need to move the specialMethod up in the hierarchy so it belongs to the base.

If you definitely don't need it in the base, but you need it in the subclass at least consider use the correct type:

 SubClass thing = ... 
 // no need to cast
 thing.specialMethod();

But as always, this depends on what are you trying to do.

Answer 4

When dealing with inheritance/polymorphism in Java there are basically two types of casts that you see:

Upcasting:

Superclass x = new Subclass();

This is implicit and does not need a hard cast because Java knows that everything the Superclass can do, the Subclass can do as well.

Downcasting

Superclass x = new Subclass();

Subclass y = (Subclass) x;

In this case you need to do a hard cast because Java isn't quite sure if this will work or not. You have to comfort it by telling it that you know what you're doing. The reason for this is because the subclass could have some weird methods that the superclass doesn't have.

In general, if you want to instantiate a class to call something in its subclass, you should probably just instantiate the subclass to begin with -- or determine if the method should be in the superclass as well.

Answer 5

You have to type, or cast thing to the subclass. So:

      Subclass thing = new Subclass();

or:

     ((Subclass) thing).specialMethod();

Answer 6

Another approach might be to do the following:

public abstract class Base {

    //method() not implemented

    public abstract void specialMethod();
}

public class Subclass extends Base {

    //method() not implemented

    @Override
    public void specialMethod() {
       //put your code here
       System.out.println("specialMethod from Subclass");
    }
}

So you can do:

thing.specialMethod();

and it will give you: "specialMethod from Subclass".

Answer 7

You could make the method you would like to call being an abstract method and have it implemented in the subclass. Then in your superclass, just call it as usual this.someMethod(). At runtime, it will go to someMethod() and run the code that is implemented from the subclass.