设计模式（三）：结构型 - 代理模式、门面模式 | 行为型 - 观察者模式、策略模式

1. 代理模式

/**
 * @Desc 1、公司接口
 */
public interface Company {

	void developSoftware();
}

/**
 * @Desc 2、产品公司
 */
public class ProductCompany implements Company {

	private Company compay;

	public ProductCompany(Company company) {
		this.compay = company;
	}

	@Override
	public void developSoftware() {
		this.compay.developSoftware();
	}
}

/**
 * @Desc 3、软件公司
 */
public class SoftwareCompany implements Company {

	@Override
	public void developSoftware() {
		System.out.println("软件公司开发软件。。。");
	}

}

/**
 * @Desc 4、客户
 *
 * 模拟逻辑：客户找软件公司（SoftwareCompany）开发软件，但软件公司不会设计，需要产品公司（ProductCompany）代理。
 */
public class Customer {

	public static void main(String[] args) {
		ProductCompany productCompany = new ProductCompany(new SoftwareCompany());
		productCompany.developSoftware(); // 软件公司开发软件。。。
	}
}

2. 门面模式

/**
 * @Desc 1、研究员
 */
public class Researcher {
	/**
	 * 写论文
	 */
	public void writeThesis() {
		System.out.println("写论文......");
	}
	/**
	 * 发表论文
	 */
	public void publishThesis() {
		System.out.println("发表论文......");
	}
}

/**
 * @Desc 2、指导老师
 */
public class Supervisor {
	/**
	 * 指导写论文
	 */
	public void guideThesis() {
		System.out.println("指导写论文......");
	}
	/**
	 * 检查论文
	 */
	public void checkThesis() {
		System.out.println("检查论文......");
	}
}

/**
 * @Desc 3、将论文发表过程封装
 */
public class ThesisProcess {

	private Researcher researcher = new Researcher();
	
	private Supervisor supervisor = new Supervisor();
	
	public void publishThesis() {
		// 研究员写论文
		researcher.writeThesis();
		// 指导老师指导写论文
		supervisor.guideThesis();
		// 指导老师指检查论文
		supervisor.checkThesis();
		// 研究员发表论文
		researcher.publishThesis();
	}
}

/**
 * @Desc 4、学院发表论文
 *
 *  模拟逻辑：论文发表过程。学院发表论文有4个步骤，还要知道这四个步骤的顺序，整个过程比较复杂。
 *  将发布论文的过程封装，新增了一个门面，直接调用门面的方法就可以，不用了解具体的实现方法以及相关的业务顺序。
 */
public class College {

	public static void main(String[] args) {
		ThesisProcess thesisProcess = new ThesisProcess();
		thesisProcess.publishThesis(); 
		// 写论文......
		// 指导写论文......
		// 检查论文......
		// 发表论文......
	}
}

3. 观察者模式

/**
 * @Desc 1、李斯，观察者
 */
public class LiSi implements Observer {

	@Override
	public void update(Observable o, Object arg) {
		System.out.println("LiSi汇报：" + arg);
	}
}

/**
 * @Desc 2、赵高，观察者
 */
public class ZhaoGao implements Observer {

	@Override
	public void update(Observable o, Object arg) {
		System.out.println("ZhaoGao报告：" + arg);
	}
}

/**
 * @Desc 3、韩非子，被观察者
 */
public class HanFeiZi extends Observable {

	public void activity(String name) {
		super.setChanged();
		super.notifyObservers("HanFeiZi去了" + name + "！");
	}
}

/**
 * @Desc 4、观察者模式
 */
public class Client {

	public static void main(String[] args) {
		HanFeiZi hfz = new HanFeiZi();

		hfz.addObserver(new LiSi());
		hfz.addObserver(new ZhaoGao());

		hfz.activity("紫兰轩");
		// ZhaoGao报告：HanFeiZi去了紫兰轩！
		// LiSi汇报：HanFeiZi去了紫兰轩！
	}
}

4. 策略模式

/**
 * @Desc 1、妙计接口
 */
public interface IStrategy {
	
	void operate();
}

/**
 * @Desc 2、第一个锦囊妙计
 */
public class FirstStrategy implements IStrategy{

	@Override
	public void operate() {
		System.out.println("打开第一个锦囊妙计");
	}
}

/**
 * @Desc 3、第二个锦囊妙计
 */
public class SecondStrategy implements IStrategy{

	@Override
	public void operate() {
		System.out.println("打开第二个锦囊妙计");
	}
}

/**
 * @Desc 4、第三个锦囊妙计
 */
public class ThirdStrategy implements IStrategy{
	
	@Override
	public void operate() {
		System.out.println("打开第三个锦囊妙计");
	}
}

/**
 * @Desc 5、锦囊
 */
public class Context {
	
	private IStrategy strategy;
	
	public Context(IStrategy strategy) {
		this.strategy = strategy;
	}
	
	public void operate() {
		strategy.operate();
	}
}

/**
 * @Desc 6、执行者
 *
 * 模拟逻辑： 锦囊装有妙计，执行人执行妙计
 */
public class Executor {

	public static void main(String[] args) {
		Context context = null;

		context = new Context(new FirstStrategy());
		context.operate(); // 打开第一个锦囊妙计

		context = new Context(new SecondStrategy());
		context.operate(); // 打开第二个锦囊妙计

		context = new Context(new ThirdStrategy());
		context.operate(); // 打开第三个锦囊妙计
	}
}