CSC/ECE 517 Fall 2010/ch3 3h PW

The Strategy pattern in static and dynamic languages

What is the Strategy Pattern

The main purpose of the strategy pattern is to separate out an object and how it behaves into two different classes. The first advantage for doing this is so that if an object can have different behaviors then it is easy to manage them in their own classes. Secondly, if a certain type of behavior need to be changed, it only need to be changed in that behavior class rather than in multiple classes if there were multiple objects that had this behavior.

How to Implement in a Static Language

The static languages implement the Strategy Pattern by creating a class and inside of that class is a reference to an action class. This action class is usually a Superclass, that way one of the actual types of actions to be perform can be assigned. These actions are essentially subclasses of the action class. In java, we can use the abstract type interface[1] which means any class that implements it must define each of the abstract functions.

Example

Java Code

interface Action {
    void perform();
}
 
// Implements the algorithm using the strategy interface
class Dribble implements Action {
 
    public void perform() {
        System.out.println("Player is dribbling");
    }
}
 
class Pass implements Action {
 
     public void perform() {
        System.out.println("Player is passing");
    }
}
 
class Shoot implements Action {
 
    public void perform() {
        System.out.println("Player is shooting");
    }    
}
 
// Configured with a ConcreteStrategy object and maintains a reference to a Strategy object
class BasketBallPlayer {
 
    private Action action;
 
    // Constructor
    public BasketBallPlayer(Action action) {
        this.action = action;
    }
 
    public void perform() {
        action.perform();
    }
}
//BasketBallPlayerExample test application
 
class BasketBallPlayerExample {
 
    public static void main(String[] args) {
 
        BasketBallPlayer bballPlayer;
 
        // Three contexts following different strategies
        bballPlayer = new BasketBallPlayer(new Dribble());
        bballPlayer.perform();
 
        bballPlayer = new BasketBallPlayer(new Pass());
        bballPlayer.perform();
 
        bballPlayer = new BasketBallPlayer(new Shoot());
        bballPlayer.perform();
    }
}

How to Implement in a Dynamic Language

Examples

Ruby code

class BasketballPlayer
 def initialize(&action)
  @action = action
 end
 def perform 
  @move.call
 end
 def method_missing(method_name)
  puts "#{action} is not a known b-ball play"
 end
end

module Pass
 def pass
  puts"Player is passing!"
 end
end

module Dribble
 def dribble
  puts "Player is dribbling!"
 end
end

module Shoot
 def shoot
  puts "Player is shooting!"
 end 
end

bballPlayer = BasketballPlayer.new(dribble)
offense.perform #=>Player is dribbling!

bballPlayer = BasketballPlayer.new(pass)
defense.perform #=>Player is passing!

bballPlayer = BasketballPlayer.new(shoot)
offense.perform #=>Player is passing!
...