Java - Method implementation dependent from parameter value

Question

Consider a method

public void doSomething(String actionID){
switch (actionID){
    case "dance":
            System.out.print("I'm dancing");
            break;
    case "sleep":
            System.out.print("I'm sleeping");
            break;
    default: 
            System.out.print("I've no idea what I'm doing");
}

The implementation of the method depends on the value of the parameter. Is there a more elegant way to do this, or a different design pattern to replicate the behaviour?

Answer 1

If the caller decides what logic is executed by passing different strings, then why not just have them call different methods:

public void doSomething(String actionID) {...}
...
doSomething("dance");
doSomething("sleep");

VS.:

public void dance() {...}
public void sleep() {...}
...
dance();
sleep();

It seems like you're unnecessarily funnelling all the calls into doSomething

---

But the strings might not always be literals. What if you're taking them from the console?

You could provide static mappings from the strings to the corresponding functions:

class MyClass {
    private static final Map<String, Consumer<MyClass>> map = new HashMap<>();

    static {
        map.put("sleep", MyClass::sleep);
        map.put("dance", MyClass::dance);
    }

    public void doSomething(String actionID) {
        map.getOrDefault(actionID, MyClass::doNothing).accept(this);
    }

    public void dance() {
        System.out.print("I'm dancing");
    }

    public void sleep() {
        System.out.print("I'm sleeping");
    }

    private void doNothing() {
        System.out.println("I've no idea what I'm doing");
    }
}

This makes scenarios where you have a lot of switch cases a lot cleaner.

Answer 2

I'm not sure how the pattern is called, but it is very useful if you need to delegate the method call based on more than one parameter:

Create a lot of handlers where each one knows when it is responsible for handling a call. Then just loop through them and invoke the first one matching the parameter.

edit: I renamed the class from FancyParameterActionFactory to FancyParameterActionUtility: it is not a factory, the name was misleading

//Your method, but this time with a complex object, not with a simple string.
public void doSomething(FancyParameterObject fpo){
    FancyParameterActionUtility.invokeOn(fpo);
}


 //The utility which can handle the complex object and decides what to do.
public class FancyParameterActionUtility{
    public Interface FPAHandler{
        void invoke(FancyParameterObject fpo);
        boolean handles(FancyParameterObject fpo);
    }

    //Omitted: Different implementations of FPAHandler

    public static List<FPAHandler> handlers = new LinkedList<>();

    static{
        handlers.add(new DanceHandler());
        handlers.add(new SleepHandler());
        //Omitted: Different implementations of FPAHandler
    }

    public static void invokeOn(FancyParameterObject fpo){
        for(FPAHandler handler:handlers){
            if (handler.handles(fpo)){
                handler.invoke(fpo);
                return;
            }
        }
        //Default-Behavior
    }

}

Answer 3

Introduce an interface, e.g.

  public interface HumanState {

    public void tellMeWhatYouAreDoing();
  }

encapsulate the logic in different implementations

  public class DancingState implements HumanState {
    @Override
    public void tellMeWhatYouAreDoing() {
      System.out.println("I'm dancing");
    }
  }

  public class SleepingState implements HumanState {

    @Override
    public void tellMeWhatYouAreDoing() {
      System.out.println("I'm sleeping");
    }
  }

  public class UnknownState implements HumanState {

    @Override
    public void tellMeWhatYouAreDoing() {
      System.out.println("I've no idea what I'm doing");
    }
  }

and use a map. E.g.

public class HumanStateExample {

  public static void main(String[] args) {
    HumanStateExample humanStateExample = new HumanStateExample();

    humanStateExample.doSomething("dance");
    humanStateExample.doSomething("sleep");
    humanStateExample.doSomething("unknown");
  }

  private final HashMap<String, HumanState> humanStateMap;


  public HumanStateExample(){
    humanStateMap = new HashMap<String, HumanState>();
    humanStateMap.put("dance", new DancingState());
    humanStateMap.put("sleep", new SleepingState());

  }

  public void doSomething(String action) {
    HumanState humanState = humanStateMap.get(action);
    if(humanState == null){
      humanState = new UnknownState();
    }

    humanState.tellMeWhatYouAreDoing();
  }
}

Answer 4

Here is a simple implementation of the command pattern based your sample problem. I define a general AbstractCommand abstract class which contains two methods. The first method, createCommand(), instantiates a command class based on an input string name. This is how you can delegate your string input to create the right type of command. The second method is doAction(), and this is left undefined, to be implemented later on by specific concrete command classes.

public abstract class AbstractCommand {
    public static AbstractCommand createCommand(String name) {
        try {
            String clsName = name + "Command";
            Class<?> cls = Class.forName(clsName);
            AbstractCommand command = (AbstractCommand) cls.newInstance();

            return command;
        }
        catch (Exception e) {
            System.out.println("Something went wrong.");
        }
    }

    public abstract void doAction();
}

public class DanceCommand extends AbstractCommand {
    public void doAction() {
        System.out.println("I'm dancing");
    }
}

public class TestCommandPattern {
    public void doSomething(String actionID) {
        AbstractCommand cmd = AbstractCommand.createCommand(actionID);
        cmd.doAction();
    }

    public static void main(String[] args) {
        TestCommandPattern test = new TestCommandPattern();
        test.doSomething("Dance");  // should print "I'm dancing"
    }
}

Now that this framework has been setup, you could easily add other commands for the various types of actions in your original problem. For example, you could create a SleepCommand class which would output I'm sleeping, or do whatever action you wish.