hjr-设计模式：策略模式

六大原则：

单、开、里、接、依、依

• 单一职责原则(SRP)：每个对象只应该为一个元素而改变而且只有一个职责关注点
• 开放封闭原则(OCP)：加新功能时，新建一个类添加该功能，而不是直接在现有类里修改添加。
• 里氏替换原则(LSP)：这个原则帮助我们判断两个类是否可以确定继承关系，我们为什么要创造继承，就是为了利用多态性用子类拓展父类的功能，因为**“拓展”**，所以父类能做的事子类必须也能做，这样的两个类可以确定继承关系，而为了满足lsp，父类尽量不要用私有方法。
• 接口分离原则(ISP)：接口A有两个契约（1）（2），a类调用接口A实现（1）（2），现在有类b调用接口A，但是只需要实现（1）不需要实现（2），那么我们就需要把接口A分离成A和B，A有契约（1），B有契约（2），然后a同时调用接口A和B，b类调用接口A，就是为了让接口的契约匹配调用的类可能要拆分接口。
• 依赖倒置原则(DIP)：当你想要做一个功能，先建一个抽象类或接口规定那个功能，再写继承抽象或接口的类去实现接口或抽象类规定的功能，而不是直接在类里写实现该功能的算法。
• 依赖注入(DI)和控制反转(IOC)原则：见下面加粗

空对象

顾名思义，就是你建一个啥也不干保持原状的类。那为什么不直接让类等于NULL？答：见下面加粗。

枚举类型

枚举类型是服务方法的参数的集合

策略模式

1. 先建一个接口指定要干的事，建很多引用该接口的类（都引用该接口是为了确保这些类都是干的指定的事），也可以说为了完成一件事，建立了很多策略。
2. 然后用接口 obj = new 策略(); 这种形式例化obj，再用obj.Fun()进行实现。
3. 这样new不同的策略类后再obj.Fun()就会实现不同的功能了

用策略类代替if,switch等分支判断，写新策略时不添加分枝，直接新建类继承接口，然后new注入，满足开放封闭原则。

这里的类也可以叫算法或策略，也可以把每个策略叫做依赖，然后当我们’new不同策略时就叫做依赖注入

具体注入有很多办法，比如

先 接口 obj = new 空对象 然互在后面对obj注入新策略：

这里的空对象不是NULL，是上面的一个啥也不干的类，为什么不用NULL，比如你的策略是各种打折算法，传入原价返回值为打折后的价格，那如果我什么折都不打，就需要一个返回原价的策略，这里称这类的策略为 “空对象”。

• 你可以建立一个带参（参数就是上面的接口类型）的方法SetFun，然后传入不同的策略对象，就注入了不同策略，这样即使你的对象已经建好了，也可以通过SetFun方法随时改变策略。

• 还可以使用类构造方法直接注入，这种缺点是new对象后不能改变策略

• 有很多依赖注入方法，可以根据情况自行选用

结合简单工厂

依赖注入的手段有了，接下来需要明确注入什么，即不同情况下new不同的策略，这里可以结合上一篇的简单工厂，建一个工厂类，里面用switch根据不同字符串，然后选择一个依赖注入手段，构造器（构造方法传参new）、注入方法，及时更改对象引用等手段注入。 这里的Default分支可以用上文的空对象注入

策略模式与简单工厂模式的区别

策略模式把实现同一功能的不同算法分别封装成类（策略），然后new不同的策略，使用时直接把策略对象传入，而简单工厂模式是，根据不同字符串new不同对象。

所以策略模式是行为模式，简单工厂模式是创造模式，一个是传入不同对象，一个是创建不同对象。简单工厂用（客户端）

switch(str)
{
	工厂抽象父类 obj = 静态工厂类.根据swicth分支new不同类的方法(str);
}
obj.fun();

其中根据swicth分支new不同类的方法(str);形如：（服务器）

static class Factory
{
	工厂抽象父类 obj;
	public fun()
	{
		switch(str)
		{
			case a : obj = new 类a();
			case b : obj = new 类b();
		}
	}
}

而策略模式用：（客户端）

switch(str)
{
	case a : Context context = new Context(new 策略a());
	case b : Context context = new Context(new 策略b());
}
context.fun();

所以策略模式一般有一个Context类辅助，负责接收注入的策略，再通过context.fun()使用该策略的实现，该辅助类形如：（服务器）

class Context
{
	策略接口 obj;//这里的接口和简单工厂的抽象父类一样，也可以用抽象父类
	public context(策略接口 obj)
	{
		obj = this.obj;
	}
	public fun()
	{
		obj.策略实现();
	}
}

一般把这两个模式结合起来使用比较好，也就是先根据字符串new对象，再直接把这个对象作为策略对象传入（这里的传入就是之前说的依赖注入，也可以简单理解为赋值）。

结合使用：（结合后的新版策略模式服务器）

//其实就是把根据字符串`new`策略移到Context类
	class Context
	{
		策略接口 obj;
		public context(str)
		{
			case a : obj = new 策略a();
			case a : obj = new 策略b();
		}
		public fun()
		{
			obj.策略实现();
		}
	}
	

反射

无论是策略模式还是简单工厂模式还是结合使用，他们的服务器端都会有一个形如下：

	public fun(str)
	{
		case a : obj = new a();
		case a : obj = new b();
	}

这样每当我们新建一个产品类或策略类就需要改动这个switch，违反了开闭原则。

现在我们使用反射，反射就是可以在程序运行过程中动态的new对象，动态的注入对象，你只要写一句包含一个字符串（这个字符串就是你要new的类的名字）的程序，然后对象就动态创建了，避免了很多分之判断，形如：

switch(str)
{
	obj = 反射（“类名”）;
}

注意类名是字符串，所以str传入不同类名的字符传，obj就被注入了不同的实例。