Command Interface
=================
public interface Command {
    public void execute();
}

Implementations
===============
public class HirePerson implements Command {
/* Other code */
    public void execute() {
        System.out.println("You're HIRED!");
    }
}

public class FirePerson implements Command {
/* Other code */
    public void execute() {
        System.out.println("You're FIRED!");
    }
}

Typesafe Enum
=============
public final class CommandType {
    private Command command = null;
    private CommandType(Command _command) {
        command = _command;
    }
    public void execute() {
        command.execute();
    }
    public static final CommandType HIRE = new CommandType(new HirePerson());
    public static final CommandType FIRE = new CommandType(new FirePerson());
}

Usage
=====

public class Test {
    public static void main(String[] data) {
        doThing(CommandType.HIRE);
        doThing(CommandType.FIRE);
    }

    public static void doThing(CommandType type) {
        type.execute();
    }
}

Of course this example is extremely trivial. In fact, the whole typesafe enum can be completely omitted in favor of just interfaces. But in complex examples, the typesafe enum can perform more logic than this trivial example. The downside of this approach is that it creates many class files and is not the simplest to debug.

Can you show us some more concrete code?

Your code would go something like this.

   public interface GoLeftYoungMan{
      boolean goLeft(int distance);
   }

   public class Car implements GoLeftYoungMan{
      ...... bunches of Car code....

      public boolean goLeft(int distance){
         boolean madeIt = false;
         /// code to turn the wheel
         /// code to turn the car
         /// code to move the car so much "distance"
         return madeIt;
      }
   }

   public class Dog implements GoLeftYoungMan{
     ..... bunches of Dog code .....
  
     public boolean goLeft(int distance){
         boolean madeIt = false;
         /// Code to look both ways.
         /// Code to see the nearest fire hydrant
         /// Code to move the the back end around.
         /// Code to change to front end direction
         /// Code to go the distance
         madeIt = true;


         return madeIt;
     }

   }

   public class TeenAger implements GoLeftYoungMan{
      .... small amount of teenager code ....

     public boolean goLeft(int distance){
        boolean madeIt = false;
        // Code to turn to the right.....

        return madeIt;
     }




   public class MoverClass{


      public boolean negotiatePath(GoLeftYoungMan negotiate){
      .... Code to calculate distance...

      return negotiate.goLeft(distance);


      }




   }

So, you see that you pass in the Implementing class by casting to the interface.... Then, all you do is execute the over-ridden method. The concrete implementation of the method or methods is what determines which "Strategy" is being used.

Hope this helps.

Stephen McConnell