6

I have the following if-else branch in java.

    if (str.equals("a")) { A;}
else if (str.equals("b")) { B;}
else if (str.equals("c")) { C;}
else if (str.length == 5) { D;}
else { E;}

how to modify this code into strategy pattern ?

sam
  • 651
  • 3
  • 9
  • 16
  • 1
    May be instead you can consider using Enums and Switch statements? The strategy pattern would make sense if you need to swap out the underlying implementation. Classic example would be different sorting algorithms. – CoolBeans Jun 30 '11 at 04:16

2 Answers2

12

Here an example of a strategy pattern using a factory:

public interface Strategy {
    public Object[] execute(Object[] args);
}

public class StrategyFactory {

    public enum Name {
        REVERSE, STRINGIFY, DUPLICATE;
    }

    private StrategyFactory() {
        // never instantiate; only use static factory methods
    }

    public static Strategy getStrategyReverse() {
        return new Strategy() {
            public Object[] execute(Object[] args) {
                Object[] reversed = new Object[args.length];
                for (int i = 0; i < args.length; i++) {
                    reversed[i] = args[args.length - i - 1];
                }
                return reversed;
            }
        };
    }

    public static Strategy getStrategyStringify() {
        return new Strategy() {
            public Object[] execute(Object[] args) {
                String[] stringified = new String[args.length];
                for (int i = 0; i < args.length; i++) {
                    stringified[i] = String.valueOf(args[i]);
                }
                return stringified;
            }
        };
    }

    public static Strategy getStrategyDuplicate() {
        return new Strategy() {
            public Object[] execute(Object[] args) {
                Object[] duplicated = new Object[2 * args.length];
                for (int i = 0; i < args.length; i++) {
                    duplicated[i * 2] = args[i];
                    duplicated[i * 2 + 1] = args[i];
                }
                return duplicated;
            }
        };
    }

    public static Strategy getStrategy(String name) {
        return getStrategy(Name.valueOf(name));
    }

    public static Strategy getStrategy(Name name) {
        switch (name) {
            case REVERSE:
                return getStrategyReverse();
            case STRINGIFY:
                return getStrategyStringify();
            case DUPLICATE:
                return getStrategyDuplicate();
            default:
                throw new IllegalStateException("No strategy known with name " + name);
        }
    }
}

public class Main {
    public static void main(String[] args) {

        Strategy strategy = StrategyFactory.getStrategy("DUPLICATE");
        System.out.println(Arrays.toString(strategy.execute(args)));
    }
}
Adriaan Koster
  • 15,870
  • 5
  • 45
  • 60
0

You have to think in terms of object-oriented programming. Use Polymorphism. For strategy pattern, Define an interface and provide different implementations to classes which implements the interface. Choose context and decide the class ploymorphically. http://en.wikipedia.org/wiki/Strategy_pattern

However for your if-else the correct pattern corresponds to 'Factory Pattern'. http://en.wikipedia.org/wiki/Factory_method_pattern

Prathab K
  • 89
  • 5