Head first笔记一：策略模式

好处：可复用

          可扩展

          可维护

如果使用继承，父类添加方法，将对所有的子类产生影响，如果有子类需要此方法，另外子类不需要此方法，影响面广，违背开闭原则，

如果使用组合，可以实现对修改开放。

headfirst Java例子：

public abstract class Duck {
	FlyBehavior flyBehavior;
	QuackBehavior quackBehavior;
	public Duck() {
	}
	public abstract void display();
	public void performFly() {
		flyBehavior.fly();
	}
	public void performQuack() {
		quackBehavior.quack();
	}
	public void swim() {
		System.out.println(“All ducks float, even decoys!”);
	}
}

public interface FlyBehavior {
	public void fly();
}
public class FlyWithWings implements FlyBehavior {
	public void fly() {
		System.out.println(“I’m flying!!”);
	}
}
public class FlyNoWay implements FlyBehavior {
	public void fly() {
		System.out.println(“I can’t fly”);
	}
}
public class FlyNoWay implements FlyBehavior {
	public void fly() {
		System.out.println(“I can’t fly”);
	}
}


public interface QuackBehavior {
	public void quack();
}
public class Quack implements QuackBehavior {
	public void quack() {
		System.out.println(“Quack”);
	}
}
public class MuteQuack implements QuackBehavior {
	public void quack() {
		System.out.println(“<< Silence >>”);
	}
}

public class MiniDuckSimulator {
	public static void main(String[] args) {
		Duck mallard = new MallardDuck();
		mallard.performQuack();
		mallard.performFly();
	}
}

Java 添加动态行为：

public void setFlyBehavior(FlyBehavior fb) {
	fl yBehavior = fb;
}
public void setQuackBehavior(QuackBehavior qb) {
	quackBehavior = qb;
}

public class ModelDuck extends Duck {
	public ModelDuck() {
		fl yBehavior = new FlyNoWay();
		quackBehavior = new Quack();
	}
	public void display() {
		System.out.println(“I’m a model duck”);
	}
}

public class FlyRocketPowered implements FlyBehavior {
	public void fl y() {
		System.out.println(“I’m fl ying with a rocket!”);
	}
}

public class MiniDuckSimulator {
	public static void main(String[] args) {
		Duck mallard = new MallardDuck();
		mallard.performQuack();
		mallard.performFly();
		Duck model = new ModelDuck();
		model.performFly();
		model.setFlyBehavior(new FlyRocketPowered());
		model.performFly();
	}
}

C++例子：

#include <iostream>
#include <string>
#include <memory>
using namespace std;

//strategy抽象类，用作接口
class Strategy
{
public:
	virtual string substitute(string str)=0;
	virtual ~Strategy()
	{
		cout<<" in the destructor of Strategy"<<endl;
	}
};

class ChineseStrategy:public Strategy
{
public:
	string substitute(string str)
	{
		int index=str.find("520");
		string tempstr=str.replace(index,3,"我爱你");
		return tempstr;
	}
	~ChineseStrategy()
	{
		cout<<"in the destructor of ChineseStrategy"<<endl;
	}
};

class EnglishStrategy:public Strategy
{
public:
	string substitute(string str)
	{
		int index=str.find("520");
		string tempstr=str.replace(index,3,"i love ou");
		return tempstr;
	}
	~EnglishStrategy()
	{
		cout<<" in the destructor of ChineseStrategy"<<endl;
	}
};

//Context类

class Translator
{
private:
	auto_ptr<Strategy> strategy;
public:
	~Translator()
	{
		cout<<" in the destructor of Translator"<<endl;
	}
	void set_strategy(auto_ptr<Strategy> strategy)
	{
		this->strategy=strategy;
	}
	string translate(string str)
	{
		if(0==strategy.get())
			return "";
		return strategy->substitute(str);
	}
};

#include "Strategy.h"

int main(int argc, char *argv)
{
	string str("321520");
	Translator *translator=new Translator;
	cout<<"No Strategy"<<endl;
	translator->translate(str);
	cout<<"---------------"<<endl;
	
	auto_ptr<Strategy> s1(new ChineseStrategy);
	translator->set_strategy(s1);
	cout<<"Chinese Strategy"<<endl;
	cout<<translator->translate(str)<<endl;
	cout<<"---------------"<<endl;

	auto_ptr<Strategy> s2(new EnglishStrategy);
	translator->set_strategy(s2);
	cout<<"English Strategy"<<endl;
	cout<<translator->translate(str)<<endl;
	cout<<"----------------"<<endl;

	delete translator;
	return 0;

}

PS:

Java 不同C++ 特点

Java：类不可多继承(关键字：abstract / extends)

  接口可以多继承(关键字：interface / implements)