策略模式和职责链模式实现坦克大战

目录：一个实例讲完23种设计模式

当前：策略模式 职责链 观察者

上一篇 《命令模式坦克大战简单实现(java实现)》

需求：坦克大战

创建两种坦克

简单说明一下：

这任然用坦克大战的需求，实现了如下3种模式

1. 策略
2. 职责链
3. 观察者（这里的观察者就一个，没有体现被观察者和观察者1对多的关系，但是观察者的价值在于被观察者发现自己有变化的时候，对观察者自动的通知，至于多少个观察者个人认为不是重点）
4. 其实也用到了命令模式（因为将机能都封装成了对象，但我在类图中没画）
5. 这篇文章的主要意图：策略+职责链的运用
6. 我尽量都用坦克大战实现所有的模式就是希望对需求的理解别影响对模式的学习。（理解需求消耗的时间尽可能的少）

类图

代码

js实现

c++实现

jav实现

//--接口层----------------------------------------
//机能运行类
class Function{
	public String mStr;
	Function(String str){
		mStr = str;
		exe();
	}
	public void exe() {
		System.out.println(mStr);
	}
};
// Strategy Pattern
//射击接口
interface IShot{
	void exe();
}
// 跑接口
interface IRun{
	void exe();
}
//坦克
class Tank{
	IShot mShot;
	IRun mRun;
	public void exe() {
		mShot.exe();
		mRun.exe();
	}
}

//
interface IHandler{
	void create(Tank t);
}
//策略接口
interface IStrategy{
	//algorithm
	void create();
	void update(Tank t);
}

//--功能实现层--------------------------------------------------
//Concrete
//射击实现-50
class B50Shot implements IShot{
	public void exe() {
		Function f = new Function("发射距离50米");
	}
}
//射击实现-70
class B70Shot implements IShot{
	public void exe() {
		Function f = new Function("发射距离70米");
	}
}
//跑实现-50
class B50Run implements IRun{
	public void exe() {
		Function f = new Function("速度50公里");
	}
}
//跑实现-70
class B70Run implements IRun{
	public void exe() {
		Function f = new Function("速度70公里");
	}
}

//--观察者层------------------------------------------
class HandlerRunB70 implements IHandler{
	IStrategy mStrategy;
	public HandlerRunB70(IStrategy stragegy) {
		mStrategy = stragegy;
	}
	public void create(Tank t) {
		t.mRun = new B70Run();
		mStrategy.update(t);
	}
}
class HandlerSortB70 implements IHandler{
    //射击功能包含跑的功能
	HandlerRunB70 mNextHandler;
	public HandlerSortB70(HandlerRunB70 h){
		mNextHandler = h;
	}
	public void create(Tank t) {
		t.mShot = new B70Shot();
        //这里创建设计功能的时候，一定同时创建跑的功能
		mNextHandler.create(t);
	}
}

class HandlerRunB50 implements IHandler{
	IStrategy mStrategy;
	public HandlerRunB50(IStrategy stragegy) {
		mStrategy = stragegy;
	}
	public void create(Tank t) {
		t.mRun = new B70Run();
		mStrategy.update(t);
	}
}

class HandlerSortB50 implements IHandler{
    //射击功能包含跑的功能
	HandlerRunB50 mNextHandler;
	public HandlerSortB50(HandlerRunB50 h){
		mNextHandler = h;
	}
	public void create(Tank t) {
		t.mShot = new B70Shot();
        //这里创建设计功能的时候，一定同时创建跑的功能
		mNextHandler.create(t);
	}
}
//--策略层------------------------------------------
//--策略-b70
class B70Strategy implements IStrategy{
	HandlerSortB70 mStartChain;
	Client mClient;
	public B70Strategy(Client c) {
		HandlerRunB70 endChain  = new HandlerRunB70(this);
		mStartChain = new HandlerSortB70(endChain);
		mClient = c;
	}
	public void create() {
		Tank t = new Tank();
		mStartChain.create(t);
	} 
	public void update(Tank t) {
        //创建完成通知
		mClient.ceateTankFinish(t);
	}
}
//--策略-b50
class B50Strategy implements IStrategy{
	HandlerSortB50 mStartChain;
	Client mClient;
	public B50Strategy(Client c) {
		HandlerRunB50 endChain  = new HandlerRunB50(this);
		mStartChain = new HandlerSortB50(endChain);
		mClient = c;
	}
	public void create() {
		Tank t = new Tank();
		mStartChain.create(t);
	} 
	public void update(Tank t) {
		mClient.ceateTankFinish(t);
	}
}
//--客户端调用------------------------------------------------------------------
public class Client {
	public static void main(String[] args) {
		System.out.println("hello worldff !");
		Client c = new Client();
		IStrategy strategy = new B70Strategy(c);
		strategy.create();
	}
	public void ceateTankFinish(Tank t) {
		System.out.println("ceateTankFinish");
		t.exe();
	}
}

运行结果

后记：

其实细心的读者能发现，这里对坦克型号和机能的结合方式有点混乱，这里是明显需要用桥接的方式来处理的。

我稍后会在做些优化，这里主要体现“策略+职责链”的运用。

设计模式这东西，本质还是面向对象的特性。

无论用什么样的需求解释设计模式，最本质的东西和是面向对象的特性在模式里的体现。