Type variable vs instanceof for identification

Question

I have two classes that are subclasses of an abstract class A:

class X extends A {}
class Y extends A {}

I would like to identify the subclass of an A object passed to a function. I can see two alternatives:

void myfunction(A myobj) {
    if(myobj instanceof X)
        doXStuff((X) myobj);
    if(myobj instanceof Y)
        doYStuff((Y) myobj);
}

or add an enum to A with the different types:

abstract class A {
    enum Type { X, Y };
    Type type;
    ...
}

class X extends A {
    type = Type.X;
    ...
}
class Y extends A {
    type = Type.Y;
    ...
}

void myfunction(A myobj) {
    if(myobj.type == Type.X)
        doXStuff((X) myobj);
    if(myobj.type == Type.Y)
        doYStuff((Y) myobj);
}

Which is better? I am leaning towards the second, because instanceof doesn't feel right for a production application. Is there another, best way? If the second is better, is there a better place to put the enum?

Answer 1

Both are bad.

Define the method in A, override the method in X and Y and call that method on the object passed in. You're throwing away polymorphism, a cornerstone of object oriented programming.

abstract class A {
    void doStuff();
}

class Y extends A {
    @Override
    void doStuff() {
        // Y specific implementation
    }
}

class X extends A {
    @Override
    void doStuff() {
        // X specific implementation
    }
}

Call it using

void myfunction(A myobj) {
    myobj.doStuff();
}