（十三）策略模式

策略图案限定了多个封装算法，该算法可以相互替换包。法的客户。借用还有一位大神的样例。

interface ICalculator{

	public int calculate(String exp);

}

abstract class AbstractCalculator{

	public int[] split(String exp,String opt){

		String array[] = exp.split(opt);

		int arrayInt[] = new int[2];

		arrayInt[0] = Integer.parseInt(array[0]);

		arrayInt[1] = Integer.parseInt(array[1]);

		return arrayInt;

	}

}

class Plus extends AbstractCalculator implements ICalculator{

	public int calculate(String exp){

		int arrayInt[] = split(exp, "\\+");

		return arrayInt[0]+arrayInt[1];

	}

}

class Minus extends AbstractCalculator implements ICalculator{

	public int calculate(String exp){

		int arrayInt[] = split(exp,"-");

		return arrayInt[0] = arrayInt[1];

	}

}

class Multiply extends AbstractCalculator implements ICalculator{

	public int calculate(String exp){

		int arrayInt[] = split(exp,"\\*");

		return arrayInt[0] * arrayInt[1];

	}

}

public class Strategy {

	public static void main(String[] args){

		String exp = "2*8";

		ICalculator cal = new Multiply();

		System.out.println(cal.calculate(exp));

	}

}

系统提供不同算法的实现。对于各种算法封装好，用户决定使用哪个算法。策略模式多使用在算法决策系统中。比如电子商务价格算法。跟抽象类非常相似，我感觉。

（十四）模板方法模式

模板方法的意义是一个父类方法提供大部分的算法，子类完毕剩余的算法。父类调用子类的实现。

abstract class TemplateCalc{

	//主方法

	public final int calculate(String exp,String opt){

		int array[] = split(exp,opt);

		return calculate(array[0],array[1]);

	}

	public int[] split(String exp,String opt){

		String array[] = exp.split(opt);

		int arrayInt[] = new int[2];

		arrayInt[0] = Integer.parseInt(array[0]);

		arrayInt[1] = Integer.parseInt(array[1]);

		return arrayInt;

	}

	abstract public int calculate(int num1,int num2);

}

class PlusTemp extends TemplateCalc{

	public int calculate(int num1,int num2){

		return num1 + num2;

	}

}

public class Template{

	public static void main(String[] args){

		TemplateCalc tem = new PlusTemp();

		System.out.println(tem.calculate("12*23", "\\*"));

	}

}

将一个子类初始化，调用父类的 calculate 方法。父类运行完分解，调用子类的相加，事实上 * 这并不意味着乘法，只是一个象征分裂。