策略模式+职责链模+享元模式 实现坦克大战

 需求：坦克大战

创建两种坦克

坦克类型	射程	速度
b70	70米	时/70公里
b50	50米	时/70公里

类图

代码

import java.util.HashMap;
//--接口层---------------------------------------------------
//基本功能基类
class Function{
	public String mStr;
	public String mUnit;
	Function(String str,String unit){
		mStr = str;
		mUnit = unit;
	}
	public void exe(int specification) {
		System.out.println(mStr+specification+mUnit);
	}
};
// Strategy Pattern
// 功能执行接口
interface IFun{
	void exe();
}
//命令模式-用于创建坦克
interface IHandler{
	void create(Tank t);
}
//抽象坦克接口定义
interface IStrategy{
	//algorithm
	void create();
	void update(Tank t);
}
//功能规格控制接口
interface ISpecificationOfTank{
	int getSpecification();
}

// 功能接口抽象-和功能规格控制接口 绑定
abstract class ConcreteFun implements IFun{
	public ConcreteFun(ISpecificationOfTank s) {
		mSpecificationOfTank = s;
	}
	protected ISpecificationOfTank mSpecificationOfTank;
}

//Concrete
//--实现层-----------------------------------------------------------
//规格获取类实现
class ConcreteSpecification implements ISpecificationOfTank{
	int mSpecification;
	public ConcreteSpecification(int value) {
		mSpecification = value;
	}
	public int getSpecification() {
		return mSpecification;
	}
}
//基本功能实现-设计
class ShotFlyweight extends Function{
	public ShotFlyweight() {
		super("发射距离","米");
	}
}
//基本功能实现-跑
class RunFlyweight extends Function{
	public RunFlyweight() {
		super("速度","公里");
	}
}

//享元模式-管理功能类，使功能对象享元
class FlyweightFactory{
	static FlyweightFactory mFlyweightFactory = new FlyweightFactory();
	static FlyweightFactory get() {
		return mFlyweightFactory;
	}
	HashMap<String,Function> mMaps = new HashMap<String,Function>();
	public Function GetFlyweitht(String key) {
		Function f = mMaps.get(key);
		if(f == null) {
			return createFlyweight(key);
		}else
		{
			return f;
		}
	} 
	public Function createFlyweight(String key) {
		Function f = null;
		if(key == "shot") {
			f = new ShotFlyweight();
		}else {
			f = new RunFlyweight();
		}
		mMaps.put(key, f);
		return f;
	}
}
//功能执行类实现-射击
class Shot extends ConcreteFun{
	public Shot(ISpecificationOfTank s) {
		super(s);
	}
	public void exe() {
        //享元模式
		Function f = FlyweightFactory.get().GetFlyweitht("shot");
		f.exe(mSpecificationOfTank.getSpecification());
	}
}
//功能执行类实现-跑
class Run extends ConcreteFun{
	public Run(ISpecificationOfTank s) {
		super(s);
	}
	public void exe() {
		Function f = FlyweightFactory.get().GetFlyweitht("run");
		f.exe(mSpecificationOfTank.getSpecification());
	}
}

//坦克定义
class Tank{
	Shot mShot;
	Run mRun;
	public void exe() {
		mShot.exe();
		mRun.exe();
	}
}

//功能抽象类-命令模式
abstract class Handler implements IHandler{
	protected ISpecificationOfTank mSpecificationOfTank;
	public Handler(ISpecificationOfTank s) {
		mSpecificationOfTank = s;
	}
}
//跑功能-命令模式
class HandlerRun extends Handler{
	IStrategy mStrategy;
	public HandlerRun(IStrategy stragegy,ISpecificationOfTank s) {
		super(s);
		mStrategy = stragegy;
	}
	public void create(Tank t) {
		t.mRun = new Run(mSpecificationOfTank);
		mStrategy.update(t);
	}
}
//射击-命令模式
class HandlerSort extends Handler{
	HandlerRun mNextHandler;
	public HandlerSort(HandlerRun h,ISpecificationOfTank s){
		super(s);
		mNextHandler = h;
	}
	public void create(Tank t) {
		t.mShot = new Shot(mSpecificationOfTank);
		mNextHandler.create(t);
	}
}

//抽象坦克-策略模式
class Strategy implements IStrategy{
	HandlerSort mStartChain;
	ISpecificationOfTank mSpecificationOfTank;
	Client mClient;
	public Strategy(Client c) {
		mClient = c;
	}
	protected void myinit() {
		HandlerRun endChain  = new HandlerRun(this,mSpecificationOfTank);
		mStartChain = new HandlerSort(endChain,mSpecificationOfTank);
	}
	public void create() {
		Tank t = new Tank();
		mStartChain.create(t);
	} 
	public void update(Tank t) {
		mClient.ceateTankFinish(t);
	}
}
//坦克70
class B70Strategy extends Strategy{
	public B70Strategy(Client c) {
		super(c);
		mSpecificationOfTank = new ConcreteSpecification(70);
		myinit();
	}
}
//坦克50
class B50Strategy extends Strategy{
	public B50Strategy(Client c) {
		super(c);
		mSpecificationOfTank = new ConcreteSpecification(50);
		myinit();
	}
}
//--用户调用层-------------------------------------------------
public class Client {
	public static void main(String[] args) {
		System.out.println("hello world !");
		Client c = new Client();
		IStrategy strategy = new B70Strategy(c);
		strategy.create();
	}
	public void ceateTankFinish(Tank t) {
		System.out.println("ceateTankFinish");
		t.exe();
	}
}

运行结果