策略模式(Strategy Pattern)的介绍

In computer programming, the strategy pattern (also known as the policy pattern) is a particular software design pattern, whereby algorithms can be selected at runtime.

In some programming languages, such as those without polymorphism, the issues addressed by this pattern are handled through forms of reflection, such as the native function pointer or function delegate syntax.

This pattern is invisible in languages with first-class functions. See the Python, Scala or Perl implementations for examples.

The strategy pattern is useful for situations where it is necessary to dynamically swap the algorithms used in an application. The strategy pattern is intended to provide a means to define a family of algorithms, encapsulate each one as an object, and make them interchangeable. The strategy pattern lets the algorithms vary independently from clients that use them.

 

C# Strategy Pattern Example Code:

using System; namespace Wikipedia.Patterns.Strategy { // MainApp test application class MainApp { static void Main() { Context anObject; // Three contexts following different strategies anObject= new Context(new ConcreteStrategyA()); anObject.Execute(); anObject.UpdateContext(new ConcreteStrategyB()); anObject.Execute(); anObject.UpdateContext(new ConcreteStrategyC()); anObject.Execute(); } } // The classes that implement a concrete strategy must implement this Execute function. // The context class uses this to call the concrete strategy interface IStrategy { void Execute(); } // Implements the algorithm using the strategy interface class ConcreteStrategyA : IStrategy { public void Execute() { Console.WriteLine( "Called ConcreteStrategyA.Execute()" ); } } class ConcreteStrategyB : IStrategy { public void Execute() { Console.WriteLine( "Called ConcreteStrategyB.Execute()" ); } } class ConcreteStrategyC : IStrategy { public void Execute() { Console.WriteLine( "Called ConcreteStrategyC.Execute()" ); } } // Configured with a ConcreteStrategy object and maintains a reference to a Strategy object class Context { IStrategy strategy; // Constructor public Context(IStrategy strategy) { this.strategy = strategy; } public void UpdateContext(IStrategy strategy) { this.strategy = strategy; } public void Execute() { strategy.Execute(); } } }

 

java Strategy Pattern Example Code:

//StrategyExample test application class StrategyExample { public static void main(String[] args) { Context context; // Three contexts following different strategies context = new Context(new ConcreteStrategyAdd()); int resultA = context.executeStrategy(3,4); context = new Context(new ConcreteStrategySubtract()); int resultB = context.executeStrategy(3,4); context = new Context(new ConcreteStrategyMultiply()); int resultC = context.executeStrategy(3,4); } } // The classes that implement a concrete strategy should implement this // The context class uses this to call the concrete strategy interface Strategy { int execute(int a, int b); } // Implements the algorithm using the strategy interface class ConcreteStrategyAdd implements Strategy { public int execute(int a, int b) { System.out.println("Called ConcreteStrategyA's execute()"); return a + b; // Do an addition with a and b } } class ConcreteStrategySubtract implements Strategy { public int execute(int a, int b) { System.out.println("Called ConcreteStrategyB's execute()"); return a - b; // Do a subtraction with a and b } } class ConcreteStrategyMultiply implements Strategy { public int execute(int a, int b) { System.out.println("Called ConcreteStrategyC's execute()"); return a * b; // Do a multiplication with a and b } } // Configured with a ConcreteStrategy object and maintains a reference to a Strategy object class Context { private Strategy strategy; // Constructor public Context(Strategy strategy) { this.strategy = strategy; } public int executeStrategy(int a, int b) { return strategy.execute(a, b); } }

 

c Strategy Pattern Example Code:

#include <stdio.h> void print_sum(int n, int *array) { int total = 0; for (int i=0; i<n; i++) total += array[i]; printf("%d", total); } void print_array(int n, int *array) { for (int i=0; i<n; i++) printf("%d ", array[i]); } int main(void) { typedef struct { void (*submit_func)(int n, int *array); char *label; } Button; // Create two instances with different strategies Button button1 = {print_sum, "Add 'em"}; Button button2 = {print_array, "List 'em"}; int n = 10, numbers[n]; for (int i=0; i<n; i++) numbers[i] = i; button1.submit_func(n, numbers); button2.submit_func(n, numbers); return 0; }

php Strategy Pattern Example Code:

<?php class StrategyExample { public function __construct() { $context = new Context(new ConcreteStrategyA()); $context->execute(); $context = new Context(new ConcreteStrategyB()); $context->execute(); $context = new Context(new ConcreteStrategyC()); $context->execute(); } } interface IStrategy { public function execute(); } class ConcreteStrategyA implements IStrategy { public function execute() { echo "Called ConcreteStrategyA execute method/n"; } } class ConcreteStrategyB implements IStrategy { public function execute() { echo "Called ConcreteStrategyB execute method/n"; } } class ConcreteStrategyC implements IStrategy { public function execute() { echo "Called ConcreteStrategyC execute method/n"; } } class Context { private $strategy; public function __construct(IStrategy $strategy) { $this->strategy = $strategy; } public function execute() { $this->strategy->execute(); } } new StrategyExample(); ?>