Factory methods and downcasting

Question

I am having a class hierarchy and a factory method that creates the classes from this hierarchy. The factory method returns the root class of this hierarchy and every time I want to use a class specific method of one of the sub classes I will have to check the type of this class and cast to this class type. My question is now if there is a possibility to avoid the type checking and casting or if this is one of the few situations where type checking and casting is approriate. To illustrate the problem here is some code:
class Factory {
  public static A create() {
    if (//someCondition)
       return new B();
    else
      return new C();
abstract class A {
  public void commonMethod() {
    // do stuff
  public void polymorphicMethod();
class B extends A {
  public void polymorphicMethod() {
    // do something
  public void specificBMethod() {
    // do stuff that only B can do
class C extends A {
  public void polymorphicMethod() {
    // do some other thing
  public void specificCMethod() {
    // do stuff that only C can do
}Now I run into a situation where I have to downcast to the correct type.
class Worker {
  public void work() {
    A a = Factory.create();
    if (a instanceof B) {
      ( (B) a).specificBMethod();
    } else if (a instanceof C) {
      ( (C) a).specificCMethod();
    } else {
      // Error
}I think this problem always arises if you have a factory method that returns a class at the top of the hierarchy or a interface but you can not put all the methods that a client wants to call in this common class or interface. Is there a better a way to do this or is this already a good solution?

Answer 1

In my particular case I have an XML parser that
parses messages. I implemented each different message
type as a different class and the parser uses the
factory to create new message objects. The parser
then uses methods that are defined in the topmost
Message class and in an interface to set the
attributes of the object. Each message class
overrides a "handleXMLElement" method defining how to
deal with the message specific XML elements. So this
is fine the parser is the client of the factory and
he uses only methods that are defined in a common
class and an interface.
After a message has been read the message object is
forwarded to a hierarchy of message handlers. Of
course the message handlers know of the message class
hierarchy and want to access all methods of each
message object. But since the parser only knows about
the interface and the common class, the message
handlers will have to cast the message objects to the
concrete types.If the message type that's passed in has its behavior in the common interface, why is there a need to cast?
So the parser-factory relationship works well but the
(nasty) casting arises due to the later message
handling. Maybe your message handling needs redesign. Or perhaps a hierarchy of callback objects that let you customize that part that changes for each message.
I also remembered why I implemented it this
way. In the Desing Patterns book of Gamma et. al.
the Chain of Responsibility pattern can be
implemented this way using casts. So the solution
can't be that bad at all, I guess.Don't take that as gospel. GoF isn't perfection. Patterns can be misapplied.
@stefan: I can't pull all my methods from the
subclasses in one upper class, because the methods
are different and specialised for each sub class. I
don't think that it is good when one sub class knows
all the methods of all other sub classes.Maybe a callback object can help sort this out. I think you need a redesign to eliminate the casts. More thinking is required.
%