设计模式

public static void operate() {
      double numberA = ...read from console;    
      double numberB = ...read from console;
      String operation = ...read from console;

      switch(operation) {
            case "+":...;
            case "-" :...;
            case "*" :...;
            case "/" :....; 
      }
}

public class Operation{
      public static double getResult(double numberA, double numberB, String operation) {
        double result = 0;
        switch(operation) {
            case "+":...;
            case "-" :...;
            case "*":...;
            case "/":...;
        }
        return result;
      }
}    

public static void main() {
      double NumberA = ...read from console;    
      double NumberB = ...read from console;
      String operation = ...read from console;
      double result = Opertion.getResult(numberA, numberB, operation)
}

public abstract class Operation {
    private double numberA;
    private double numberB;
    
    public abstract double getResult();
    //getters and setters...
}

public class OperationAdd extends Operation {
    public double getResult(){...}
}

public class OperationSub extends Operation {
    public double getResult(){...}
}

public class OperationMul extends Operation {
    public double getResult(){...}
}

public class OperationDiv extends Operation {
    public double getResult(){...}
}

public class OperationFactory{
    public static Operation createOperation(String operate) {
        Operation oper = null;
        switch(oper) {
            case "+":...;
            case "-" :...;
            case "*":...;
            case "/":...;
        }
        return oper;
    }
}        　　

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
<operation value="OperationAdd">
<numberA value="12">
<numberB value="13">
</configuration>

public static void main(String[] args) {
      String OperationStr = ...;
      Operation oper = Class.forName(OperationStr);
      NumberA = ...;
      NumberB = ...;
      oper.setNumberA();
      oper.setNumberB();
      oper.getResult();
}

class Prouct {
    List<String> parts = new  ArrayList<String>();
    public void add(String part) {
        parts.add(part);
    }
    public void show(){...}
}    

abstract class Builder{
    public abstract void buildPartA();
    public abstract void buildPartB();
    public abstract Product getResult();
}

class concreteBuilder1 extends Build {
    Product product = new Product();
    public void buildPartA() {product.add("部件A");}
    public void buildPartB() {product.add("部件B");}
    public void getResult() {return product;}
}

class concreteBuilder2 extends Build {
    Product product = new Product();
    public void buildPartA() {product.add("部件X");}
    public void buildPartB() {product.add("部件Y");}
    public void getResult() {return product;}
}

class Director{
    public void constructor(Builder builder) {
        builder.buildPartA();
        builder.buildPartB();
    }
}

class Main() {
    public static void main(String[] args) {
         Director director = new Director();
         Builder b1 = new ConcreteBuilder1();
         Builder b2 = new ConcreteBuilder2();
        
         director.construct(b1);
         Product p1 = b1.getResult();
         p1.show();

         director.construct(b2);
         Product p2 = b2.getResult();
         p2.show();
    }
}

public abstract class Operation {
    private double numberA;
    private double numberB;
    
    public abstract double getResult();
    //getters and setters...
}

public class OperationAdd extends Operation {
    public double getResult(){...}
}

public class OperationSub extends Operation {
    public double getResult(){...}
}

public class OperationMul extends Operation {
    public double getResult(){...}
}

public class OperationDiv extends Operation {
    public double getResult(){...}
}

interface IFactory{
    Operation createOperation();
}

class AddFactory implements IFactory {
    Operation createOperation(){
        return new OperationAdd();
    }
}
class SubFactory implements IFactory{...}
class MulFactory implements IFactory{...}
class DivFactory implements IFactory{...}

public abstract class AbstractRoad {
	protected AbstractCar car;
	public abstract void Run();
	public void setCar(AbstractCar car) {
		this.car = car;
	}
}
public class SpeedWay extends AbstractRoad {
	@Override
	public void Run() {
		car.Run();
		System.out.println("高速公路上行驶");
	}
}
public class Street extends AbstractRoad {
	@Override
	public void Run() {
		 car.Run();
		 System.out.println("市区街道上行驶");
	}
}


public abstract class AbstractCar {
	public abstract void Run();
}
public class Bus extends AbstractCar{
	@Override
	public void Run() {
		System.out.print("公共汽车在");
	}
}
public class Car extends AbstractCar{
	@Override
	public void Run() {
		System.out.print("小汽车在");
	}
}


public class Run {
	public static void main(String[] args) {
		// 小汽车在高速公路上行驶;
		AbstractRoad Road1 = new SpeedWay();
		Road1.car = new Car();
		Road1.Run();
		
		System.out.println("=========================");

		// 公共汽车在高速公路上行驶;
		AbstractRoad Road2 = new SpeedWay();
		Road2.car = new Bus();
		Road2.Run();
	}
}

public class User {
	public String name;

	public User(String name) {
		this.name = name;
	}
}

public abstract class WebSite {
	public abstract void use(User user);//use方法需要传递User对象，User对象就属于外部状态
}

public class ConcreteWebSite extends WebSite {
	private String name = "";

	public ConcreteWebSite(String name) {
		this.name = name;
	}

	public void use(User user){
		System.out.println("网站分类：" + name + "  用户：" + user.name);
	}
}

//工厂类，控制对象的创建
public class WebSiteFactory {
	private HashMap<String, WebSite> flyweights = new HashMap();

	public WebSite getWebSite(String key) {
		if (!flyweights.containsKey(key))
			flyweights.put(key, new ConcreteWebSite(key));
		return ((WebSite) flyweights.get(key));
	}

	public int getWebSiteCount() {
		return flyweights.size();
	}
}

public class Run {
	public static void main(String[] args) {
		WebSiteFactory wsf = new WebSiteFactory();

		WebSite ws1 = wsf.getWebSite("产品展示");
		ws1.use(new User("小菜"));

		WebSite ws2 = wsf.getWebSite("产品展示");
		ws2.use(new User("大鸟"));

		WebSite ws3 = wsf.getWebSite("产品展示");
		ws3.use(new User("娇娇"));

		WebSite ws4 = wsf.getWebSite("博客");
		ws4.use(new User("老顽童"));

		WebSite ws5 = wsf.getWebSite("博客");
		ws5.use(new User("南海鳄神"));

		WebSite ws6 = wsf.getWebSite("博客");
		ws6.use(new User("桃谷六仙"));

		System.out.println("得到网站分类总数为：" + wsf.getWebSiteCount());
	}
}

public class Request {
    public String requestType;  
    public String requestContent;  
    public int number;  
}

public abstract class Manager {
	protected String name;
	protected Manager superior;

	public Manager(String name) {
		this.name = name;
	}

	public void setSuperior(Manager superior) {
		this.superior = superior;
	}

	public abstract void requestApplication(Request request);
}

public class CommonManager extends Manager {
	public CommonManager(String name) {
		super(name);
	}

	public void requestApplication(Request request) {
		if (request.requestType == "请假" && request.number <= 2) {
			System.out.println(name + ":" + request.requestContent + ",数量:"
					+ request.number + "被批准。");
		} else if (superior != null) {
			superior.requestApplication(request);
		}
	}
}

public class MajorDomo extends Manager {
	public MajorDomo(String name) {
		super(name);
	}

	@Override
	public void requestApplication(Request request) {
		if (request.requestType == "请假" && request.number <= 5) {
			System.out.println(name + ":" + request.requestContent + ",数量:"
					+ request.number + "被批准。");
		} else if (superior != null) {
			superior.requestApplication(request);
		}
	}
}

public class GeneralManager extends Manager {
	public GeneralManager(String name) {
		super(name);
	}

	@Override
	public void requestApplication(Request request) {
		if (request.requestType == "请假") {
			System.out.println(name + ":" + request.requestContent + ",数量:"
					+ request.number + "被批准。");
		} else if (request.requestType == "加薪" && request.number <= 500) {
			System.out.println(name + ":" + request.requestContent + ",数量:"
					+ request.number + "被批准。");
		} else if (request.requestType == "加薪" && request.number > 500) {
			System.out.println(name + ":" + request.requestContent + ",数量:"
					+ request.number + "再说吧。");
		}
	}
}

public class Run {
	public static void main(String[] args) {
		CommonManager commonManager = new CommonManager("经理");
		MajorDomo majorDomo = new MajorDomo("总监");
		GeneralManager generalManager = new GeneralManager("总经理");

		commonManager.setSuperior(majorDomo);
		majorDomo.setSuperior(generalManager);

		Request request1 = new Request();
		request1.requestType = "请假";
		request1.requestContent = "小菜请假";
		request1.number = 1;

		commonManager.requestApplication(request1);

		Request request2 = new Request();
		request2.requestType = "请假";
		request2.requestContent = "小菜请假";
		request2.number = 3;

		commonManager.requestApplication(request2);

		Request request3 = new Request();
		request3.requestType = "请假";
		request3.requestContent = "小菜请假";
		request3.number = 6;

		commonManager.requestApplication(request3);

		Request request4 = new Request();
		request4.requestType = "加薪";
		request4.requestContent = "小菜请求加薪";
		request4.number = 300;

		commonManager.requestApplication(request4);

		Request request5 = new Request();
		request5.requestType = "加薪";
		request5.requestContent = "小菜请求加薪";
		request5.number = 1000;

		commonManager.requestApplication(request5);
	}
}

public class Barbecuer {/* 烤肉串者类 */
	public void BakeMutton() {
		System.out.println("烤羊肉串...");
	}

	public void BackChickenWing() {
		System.out.println("烤鸡翅...");
	}
}

public abstract class Command {
	protected Barbecuer receiver; // 命令接受者

	public Command(Barbecuer receiver) { // 抽象命令类，只需要确定“烤肉串者”是谁
		this.receiver = receiver;
	}
	
	public abstract void ExcuteCommand();// 执行命令
}

public class BakeMuttonCommand extends Command {
	public BakeMuttonCommand(Barbecuer receiver) {
		super(receiver);
	}

	@Override
	public void ExcuteCommand() {
		receiver.BakeMutton();
	}
}

public class BackChickenWingCommand extends Command {
	public BackChickenWingCommand(Barbecuer receiver) {
		super(receiver);
	}

	@Override
	public void ExcuteCommand() {
		this.receiver.BackChickenWing();
	}
}

public class Waiter {
	private List<Command> orders = new ArrayList<Command>();

	public void SetOrder(Command command) {// 设置订单
		if (command.getClass().toString().equals("class command.BackChickenWingCommand")) {
			System.out.println("服务员：鸡翅没有了，请点别的烧烤...");
		} else {
			orders.add(command);
			System.out.println("增加订单：" + command.getClass().toString() + "时间："
					+ new Date().toString());
		}
	}

	public void CancelOrder(Command command) {// 取消订单
		orders.remove(command);
		System.out.println("取消订单：" + command.getClass().toString() + "时间："
				+ new Date().toString());
	}

	public void Notify() {// 通知全部执行
		for (Command c : orders) {
			c.ExcuteCommand();
		}
	}
}

public class Run {
	public static void main(String[] args) {
		// 开店前的准备
		Barbecuer boy = new Barbecuer();
		Command bakeMuttonCommand = new BakeMuttonCommand(boy);
		Command bakeChickenCommand = new BackChickenWingCommand(boy);

		Waiter girl = new Waiter();

		// 开门营业 顾客点菜
		girl.SetOrder(bakeMuttonCommand);
		girl.SetOrder(bakeMuttonCommand);
		girl.SetOrder(bakeChickenCommand);

		// 订单下好后，一次性通知厨房
		girl.Notify();
	}
}

public class GameRole {
	public int vit;// 生命力
	public int atk;// 攻击力
	public int def;// 防御力

	public void InitState() {/* 设置初始状态 */
		this.vit = 100;
		this.atk = 100;
		this.def = 100;
	}

	public void ShowState() {/* 当前状态显示 */
		System.out.println("角色当前状态：");
		System.out.println("生命力：" + this.vit);
		System.out.println("攻击力：" + this.atk);
		System.out.println("防御力：" + this.def);
	}

	public void Fight() {/* 战斗 */
		this.vit = 0;
		this.atk = 0;
		this.def = 0;
	}

	public RoleStateMemento SaveRoleState() {/* 保存角色状态 */
		return new RoleStateMemento(this.vit, this.atk, this.def);
	}

	public void RecoveryState(RoleStateMemento rsm) {/* 恢复角色状态 */
		this.vit = rsm.vit;
		this.atk = rsm.atk;
		this.def = rsm.def;
	}
}

public class RoleStateMemento {
	public int vit;// 生命力
	public int atk;// 攻击力
	public int def;// 防御力

	public RoleStateMemento(int vit, int atk, int def) {
		this.vit = vit;
		this.atk = atk;
		this.def = def;
	}
}

public class RoleStateCaretaker {
	public RoleStateMemento rsm;

	public RoleStateMemento getRsm() {
		return this.rsm;
	}
}

public class Run {
	public static void main(String[] args) {
		// 大战boss前
		System.out.println("大战boss前...");
		GameRole gr = new GameRole();
		gr.InitState();
		gr.ShowState();

		// 保存进度
		RoleStateCaretaker rsc = new RoleStateCaretaker();
		rsc.rsm = gr.SaveRoleState();

		// 大战boss，损耗严重
		System.out.println("大战boss，损耗严重...");
		gr.Fight();
		gr.ShowState();

		// 恢复进度
		System.out.println("恢复进度...");
		gr.RecoveryState(rsc.getRsm());
		gr.ShowState();
	}
}

/* 
 * Observer类，抽象观察者，为所有的具体观察者定义一个接口，在得到主题的通知时，更新自己 
 * 这个接口叫做更新接口。抽象观察者一般用一个抽象类或者一个接口实现。更新接口通常包含一个 
 * Update方法，这个方法叫做更新方法。 
 */ 
public abstract class Observer {
	public abstract void Update();
}

/* 
 * Subject类，可翻译为主题或者抽象通知者，一般用一个抽象类或者一个接口实现。 
 * 它把所有对观察者对象的引用，保存在一个聚集里，每个主题都可以有任意数量的观察者。 
 * 抽象主题提供一个接口，可以增加和删除观察者对象。 
 */
public abstract class Subject {
	private List<Observer> observers = new ArrayList<Observer>();

	// 增加观察者
	public void Attach(Observer observer) {
		observers.add(observer);
	}

	// 移除观察者
	public void Detach(Observer observer) {
		observers.remove(observer);
	}

	// 通知
	public void Notify() {
		for (Observer o : observers) {
			o.Update();// 通知到每一个观察者，使得每一个观察者修改自身状态
		}
	}
}

/* 
 * ConcreteObserver类，具体观察者，实现抽象观察者角色所要求的更新接口。以便使本身 
 * 的状态与主题的状态相协调。具体观察者角色可以保存一个指向具体主题对象的引用，具体 
 * 观察者角色通常由一个具体子类实现。 
 */ 
public class ConcreteObserver extends Observer {
	private String name;
	private String observerState;
	private ConcreteSubject cSubject;

	public ConcreteObserver(ConcreteSubject cSubject, String name) {
		this.cSubject = cSubject;
		this.name = name;
	}

	public ConcreteSubject getCSubject() {
		return this.cSubject;
	}

	public void setCSubject(ConcreteSubject cSubject) {
		this.cSubject = cSubject;
	}

	public void Update() {
		this.observerState = this.cSubject.getSubjectState();
		System.out.println("观察者" + this.name + "的状态是" + this.observerState);
	}
}

/* 
 * ConcreteSubject类叫做具体主题或者具体通知者，将有关状态存入具体观察者对象： 
 * 在具体主题的内部状态得到改变时，给所有登记过的观察者发出通知。具体主题通常 
 * 用一个具体子类实现。 
 */
public class ConcreteSubject extends Subject {
	private String subjectState;

	public String getSubjectState() {
		return this.subjectState;
	}

	public void setSubjectState(String state) {
		this.subjectState = state;
	}
}

public class Run {
	public static void main(String[] args) {
		ConcreteSubject cSubject = new ConcreteSubject();

		cSubject.Attach(new ConcreteObserver(cSubject, "X"));
		cSubject.Attach(new ConcreteObserver(cSubject, "Y"));
		cSubject.Attach(new ConcreteObserver(cSubject, "Z"));

		cSubject.setSubjectState("ABC");
		cSubject.Notify();
	}
}

public abstract class State {
	public abstract void writeProgram(Work work);
}

public class ForenoonState extends State {
	public void writeProgram(Work work) {
		if (work.hour < 12) {
			System.out.println("当前时间" + work.hour + "，上午状态，精神百倍！");
		} else {
			work.state = new NoonState();
			work.writeProgram();
		}
	}
}

public class NoonState extends State {
	public void writeProgram(Work work) {
		if (work.hour < 13) {
			System.out.println("当前时间" +  work.hour + "，午饭时间！");
		} else {
			work.state = new AfterNoonState();
			work.writeProgram();
		}
	}
}

public class AfterNoonState extends State {
	public void writeProgram(Work work) {
		if (work.hour < 17) {
			System.out.println("当前时间" + work.hour + "，下午状态，继续工作！");
		} else {
			work.state = new EveningState();
			work.writeProgram();
		}
	}
}

public class EveningState extends State {
	public void writeProgram(Work work) {
		if (work.isFinish) {
			work.state = new RestState();
			work.writeProgram();
		} else {
			if (work.hour < 21) {
				System.out.println("当前时间" + work.hour + ",加班状态，疲惫！");
			} else {
				work.state = new SleepState();
				work.writeProgram();
			}
		}
	}
}

public class RestState extends State {
	public void writeProgram(Work work) {
		System.out.println("当前时间" + work.hour + ",完成工作，下班回家！");
	}
}

public class SleepState extends State {
	public void writeProgram(Work work) {
		System.out.println("当前时间" + work.hour + ",睡觉状态！");
	}
}

public class Work {
	public double hour;
	public State state;
	public boolean isFinish;

	public Work(State state) {
		this.state = state;
	}

	public void writeProgram() {
		this.state.writeProgram(this);
	}
}

public class Run {
	public static void main(String[] args) {
		Work work = new Work(new ForenoonState());
		work.hour = 9;
		work.writeProgram();
		work.hour = 10;
		work.writeProgram();
		work.hour = 12;
		work.writeProgram();
		work.hour = 13;
		work.writeProgram();
		work.hour = 15;
		work.writeProgram();
		work.hour = 17;
		work.writeProgram();

		work.isFinish = false;
		work.hour = 19;
		work.writeProgram();
		work.hour = 21;
		work.writeProgram();
		work.hour = 22;
		work.writeProgram();
	}
}

public abstract class CashSuper {//促销策略基类
	public abstract double acceptCash(double money);
}

public class CashNormal extends CashSuper{//无促销策略
	public double acceptCash(double money) {
		return money;
	}
}

public class CashRebate extends CashSuper {//打折促销
    private double rebate = 1;
    
	public CashRebate(double rebate) {
		super();
		this.rebate = rebate;
	}

	@Override
	public double acceptCash(double money) {
		return money * rebate;
	}
}

public class CashReturn extends CashSuper {// 满300返100
	private double c = 0;
	private double r = 0;

	public CashReturn(double c, double r) {
		this.c = c;
		this.r = r;
	}

	@Override
	public double acceptCash(double money) {
		double result = money;
		if (money > c)
			result = money - Math.floor(money / c) * r;
		return result;
	}
}

public class CashContext {
	public CashSuper cs;

	public CashContext(CashSuper cs) {// 通过构造函数，传入具体的收费策略
		this.cs = cs;
	}

	public double getResult(double money) {
		return cs.acceptCash(money);
	}
}

public class Run {
	public static void main(String[] args) {
		CashContext cc = new CashContext(new CashReturn(300, 100));
		System.out.println(cc.getResult(400));
	}
}

public abstract class Person {
	// 用来获得状态对象
	public abstract void Accept(Action action);
}

public class Man extends Person {
	@Override
	public void Accept(Action action) {
		action.GetManConclusion(this);
	}
}

public class Woman extends Person {
	@Override
	public void Accept(Action action) {
		action.GetWomamConclusion(this);
	}
}

/*状态的抽象类*/
public abstract class Action {
	// 得到男人结论或反应
	public abstract void GetManConclusion(Man m);

	// 得到女人结论或反应
	public abstract void GetWomamConclusion(Woman w);
}

public class Fail extends Action {
	@Override
	public void GetManConclusion(Man m) {
		System.out.println("man fail时，闷头喝酒谁也不用劝");
	}

	@Override
	public void GetWomamConclusion(Woman w) {
		System.out.println("woman fail时，眼泪汪汪，谁也劝不了");
	}
}

public class Love extends Action {
	@Override
	public void GetManConclusion(Man m) {
		System.out.println("man success时，凡事不懂也要装懂");
	}

	@Override
	public void GetWomamConclusion(Woman w) {
		System.out.println("woman success时，遇事懂也装不懂");
	}
}

public class Success extends Action{
	@Override
	public void GetManConclusion(Man m) {
		System.out.println("man success时，背后多半有一个成功的女人");
	}

	@Override
	public void GetWomamConclusion(Woman w) {
		System.out.println("woman success时，背后多半有一个不成功的男人");
	}
}

public class ObjectStructure {
	private List<Person> persons = new ArrayList<Person>();

	// 增加
	public void Attach(Person p) {
		persons.add(p);
	}

	// 移除
	public void Detach(Person p) {
		persons.remove(p);
	}

	// 查看显示
	public void Display(Action a) {
		for (Person p : persons) {
			p.Accept(a);
		}
	}
}

public class Run {
	public static void main(String[] args) {
		ObjectStructure os = new ObjectStructure();
		os.Attach(new Man());
		os.Attach(new Woman());

		// 成功时的反应
		Success s = new Success();
		os.Display(s);

		// 失败时反应
		Fail f = new Fail();
		os.Display(f);

		// 恋爱时的反应
		Love l = new Love();
		os.Display(l);
	}
}