How can I invoke a method on a subclass based on the runtime type?

Question

Hi all,
I have defined a base class OrderDetail, and 2 subclasses which extend it: OrderDetailSingleReservation and OrderDetailMonthReservation. Furthermore, I have a method:
    public Order order_generate(OrderDetail orderDetail) {
        if (orderDetail instanceof OrderDetailSingleReservation) {
            return order_generate((OrderDetailSingleReservation) orderDetail);
        }  else if (orderDetail instanceof OrderDetailMonthReservation) {
            return order_generate((OrderDetailMonthReservation) orderDetail);
        } else {
            Misc.alert("orderAndInvoice_Generate(GENERIC): unsupported type.");
            return null;
    }The type of this method's parameter is OrderDetail, as you can see. (This particular method only serves as a kind of dispatcher and is therefore not very interesting in itself, but the same pattern using 'instanceof' occurs in a codebase I am working on several times, and I would like to factor it out if possible.)
My question: it seems that the invocation of order_generate() from within this method requires an explicit downcast to one of the two subclasses. If not, java invokes the method on the superclass. But at runtime, the JVM knows what type of object it is dealing with, right? So is there no way to do this without the explicit downcast?
A similar problem occurs when trying to invoke a method on an object whose type is one of the subclasses; the method on superclass is called, instead of the one in the appropriate subclass that overrides it.
Any help would be greatly appreciated!
Thanks,
Erik

Answer 1

Thanks for your replies! I was editing my post last night to clarify it, but my connection went down and the edit was lost :(
Anyway, yes, it should be done with polymorphism. I was constructing an example using the famous Animal, Cat and Dog classes to demonstrate my question more clearly, and to my surprise the problem does not occur in my example code.
LRMK: Invoking a method such as in your example, where the method is inside the class itself, works fine. However for MVC's sake, I have a separate class called Invoicing with methods as below:
class invoicing
  // the method for the superclass
  public Invoice invoice_create(OrderDetail orderDetail) {
     System.out.println("type: " + orderDetail.getClass());
     return null;
  // the method for one of the subclasses (this method is being not invoked)
  public Invoice invoice_create(OrderDetailSingleReservation orderDetail) {
     return null;
  // ...nor is this one.
  public Invoice invoice_create(OrderDetailMonthReservation od) {
     return null;
}Now I attempt to invoke these methods:
// create example objects
OrderDetailSingleReservation odSingle = new OrderDetailSingleReservation();
OrderDetailMonthReservation odMonth = new OrderDetailMonthReservation();
// this call displays "odSingle type: OrderDetailSingleReservation"
System.out.println("odSingle type: " + odSingle.getClass());
// this call displays "odMonth type: OrderDetailMonthReservation"
System.out.println("odMonth type: " + odMonth.getClass());
// this call invokes Invoicing.invoice_create(OrderDetail)
// instead of Invoicing.invoice_create(OrderDetailSingleReservation)
Invoicing.invoice_create(odSingle);
// this call invokes Invoicing.invoice_create(OrderDetail)
// instead of Invoicing.invoice_create(OrderDetailMonthReservation)
Invoicing.invoice_create(odMonth);So these calls will invoke the method for the superclass, i.e. Invoicing.invoice_create(OrderDetail od). That method then then executes the System.out.println() call which displays the class type of its parameter as one of { OrderDetailSingleReservation | OrderDetailMonthReservation }, that is, the expected subclass types!
So the dynamic dispatch isn't working the way I would expect it to. If I do the explicit if-else checking using instanceof, as described in my first post, the correct methods are called.
I hope the problem is somewhat clearer now. I am a bit lost as to what might be causing this, or how to monitor what's going on inside the jvm. Any ideas? BTW, the OrderDetail class and its subclasses are JPA entities (though I don't think it should matter).
Thanks!
Erik