Question

I have code that when given a thing it needs to sort out what specific kind of thing it is and then take special actions based on that. The possible classes it could be are all desc

public void doSomething(BaseThing genericThing) 
{
  if (genericThing instanceof SpecificThing)
  {
    SpecificThingProcessor stp = new SpecificThingProcessor((SpecificThing) genericThing);
  }
  else if (genericThing instanceof DifferentThing)
  {
    DifferentThingProcessor dtp = new DifferentThingProcessor((DifferentThing) genericThing);
  }
  else if (genericThing instanceof AnotherThing){
    AnotherThingProcessor atp = new AnotherThingProcessor((AnotherThing) genericThing);
  }
  else
  {
    throw new IllegalArgumentException("Can't handle thing!");
  }
}

Is there a pattern or better way of handling this? Unfortunately the operations being performed do not lend themselves to generalization around the BaseThing, they have to be done for each specific class of thing.

Answer 1

The best option I can think of is to abstract the functionality in to an Interface and have each type implement that Interface.

If you add a little more detail about what you’re trying to do based on the types, I could make a better suggestion (possibly with some sample code).

EDIT

After the edit, there is definitely a clear way to do this. Each Processor will implement a specific Interface:

public interface IProcessor
{
    void Process();
}

public class SpecificThingProcessor : IProcessor
{
    public void Process() { /* Implementation */ }    
}

public class DifferentThingProcessor : IProcessor
{
    public void Process() { /* Implementation */ }
}

public class AnotherThingProcessor : IProcessor
{
    public void Process() { /* Implementation */ }
}

Each BaseThing must implement a method to return the specific processor:

public abstract class BaseThing
{
    public abstract IProcessor GetProcessor();
}

public class SpecificThing : BaseThing
{
    public override IProcessor GetProcessor()
    {
        return new SpecificThingProcessor();
    }
}

public class DifferentThing : BaseThing
{
    public override IProcessor GetProcessor()
    {
        return new DifferentThingProcessor();
    }
}

And then your method will simply be:

public void doSomething(BaseThing genericThing)
{
    IProcessor processor = genericThing.GetProcessor();
    processor.Process();
}