《Design Patterns》Strategy.积跬步系列

Strategy：策略模式

先代码

父类或接口类：

package h.l.demo.simplefactory;
/**
 * 
 * @author: Is-Me-Hl
 * @date: 2020年1月31日
 * @Description: Demo--简单工厂模式
 * SuperClassOrInterface：表示父类或者接口都行，此处两者代码都会给出，大同小异
 */
/*public abstract class SuperClassOrInterface {
	// 抽象方法
	public abstract void doSomeThings();
	// 非抽象方法
	public void doThings(){
		System.out.println("SuperClassOrInterface：doThings...");
	}
}*/
public interface SuperClassOrInterface{
	public void doSomeThings();
}

子类或实现类（两个）：

package h.l.demo.simplefactory;
/**
 * 
 * @author: Is-Me-Hl
 * @date: 2020年1月31日
 * @Description: 子类1：继承或实现
 */
/*public class SubClassOrImplClass1 extends SuperClassOrInterface {

	*//**
	 * 实现抽象方法
	 *//*
	@Override
	public void doSomeThings() {
		// TODO Auto-generated method stub
		System.out.println("SubClassOrImplClass1：doSomeThings...");
	}
	*//**
	 * 子类重写父类方法
	 * @Override 可以校验该方法是不是在父类（超类）中存在
	 *//*
	@Override
	public void doThings(){
		System.out.println("SubClassOrImplClass1：doThings...");
	}
}*/
public class SubClassOrImplClass1 implements SuperClassOrInterface {

	/**
	 * 实现接口中指定的行为
	 */
	@Override
	public void doSomeThings() {
		// TODO Auto-generated method stub
		System.out.println("SubClassOrImplClass1：doSomeThings...");
	}
}

package h.l.demo.simplefactory;
/**
 * 
 * @author: Is-Me-Hl
 * @date: 2020年1月31日
 * @Description: 子类2：继承或实现
 */
/*public class SubClassOrImplClass2 extends SuperClassOrInterface {
	*//**
	 * 实现抽象方法
	 *//*
	@Override
	public void doSomeThings() {
		// TODO Auto-generated method stub
		System.out.println("SubClassOrImplClass2：doSomeThings...");
	}
	*//**
	 * 子类重写父类方法
	 * @Override 可以校验该方法是不是在父类（超类）中存在
	 *//*
	@Override
	public void doThings(){
		System.out.println("SubClassOrImplClass2：doThings...");
	}
}*/
public class SubClassOrImplClass2 implements SuperClassOrInterface {

	/**
	 * 实现接口中指定的行为
	 */
	@Override
	public void doSomeThings() {
		// TODO Auto-generated method stub
		System.out.println("SubClassOrImplClass2：doSomeThings...");
	}
}

简单工厂和策略模式的结合，Context上下文类：

package h.l.demo.strategy;

/**
 * 
 * @author: Is-Me-Hl
 * @date: 2020年2月3日
 * @Description: 简单工厂和策略模式的结合 Context上下文类
 */
public class Context {
	SuperClassOrInterface si = null;
	/**
	 * 通过工厂获取实例
	 * @param subType 子类型
	 * @return
	 */
	public Context(String subType) {
		switch (subType) {
		case "SubClassOrImplClass1":
			si = new SubClassOrImplClass1();
			break;
		case "SubClassOrImplClass2":
			si = new SubClassOrImplClass2();
			break;
		}
	}
	
	public void doSomeThings(){
		si.doSomeThings();
	}
}

测试类：

package h.l.demo.strategy;
/**
 * 
 * @author: Is-Me-Hl
 * @date: 2020年2月3日
 * @Description: 测试
 */
public class TestMainEnter {

	public static void main(String[] args) {
		Context context = new Context("SubClassOrImplClass1");
		context.doSomeThings();
		System.out.println("-----------------------");
		context = new Context("SubClassOrImplClass2");
		context.doSomeThings();
	}

}

测试结果：

后分析

• 个人建议：写代码是件幸福的事，So,do it

策略模式：课本上的解释–是一种定义一系列算法的方法，从概念上来看，所有这些算法完成的都是相同的工作，只是实现不同，它可以以相同的方式调用所有的算法，减少了各种算法类与使用算法类之间的耦合。

一开始看到这句话是懵的，太干，直到看了其UML图，及相关Demo的实现，也就明白了。实际上，策略模式和简单工厂是很类似的。简单工厂是将类的实例化全权交由一个工厂类实现，而策略模式则是将功能类似的一组算法（“算法”这术语感觉太专业，就说成是方法或者行为）统一交给一个类去调用，由此降低耦合。
也许读者看到这已经发现，上面的代码几乎和简单工厂《Design Patterns》SimpleFactory.积跬步系列类似，的确就将简单工厂类那部分换成了本文的上下文Context类，当然测试类稍作改动。

那么接下来到了联系生活实际的段落了。联系生活实际，可以类比于现实中的大米加工厂各种节假日活动的促销。元旦，新的一年且是1月1号，那就买一送一吧；五一劳动节，为了庆祝劳动者节日，买一送五吧；对于不同的促销活动，调用的方法却是一样的，准确来说是算法的入口一般是一致的。这个时候就是策略模式的体现。相比于简单工厂，其更为“细粒度”，该算法可能是所有算法类供的方法名相同的某一个方法或行为。

---

注：以上文章仅是个人总结，若有不当之处，望不吝赐教