//部门对象
public class Dept {
	private String name;

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

	public String getName(){
		return this.name;
	}
}

//北京分公司
public class BJBranch {
	ArrayList<Dept> depts;

	public BJBranch(){
		depts = new ArrayList<Dept>();
		//添加部门
		depts.add(new Dept("北京-财务部"));
		depts.add(new Dept("北京-研发部"));
		depts.add(new Dept("北京-开发部"));
	}

	public ArrayList<Dept> getDepts(){
		return depts;
	}
}

//上海分公司
public class SHBranch {
	Dept[] depts;

	public SHBranch(){
		depts = new Dept[3];
		//添加部门
		depts[0] = new Dept("上海-财务部");
		depts[1] = new Dept("上海-研发部");
		depts[2] = new Dept("上海-开发部");
	}

	public Dept[] getDepts(){
		return depts;
	}
}

public class TestOld {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		BJBranch BJ 			= new BJBranch();
		ArrayList<Dept> BJDepts = BJ.getDepts();
		SHBranch SH 	= new SHBranch();
		Dept[] SHDepts 	= SH.getDepts();
		//遍历两家子公司的所有部门
		/** 由于类型不同，需要两次循环 **/
		for(int i=0;i<BJDepts.size();i++){
			System.out.println(BJDepts.get(i).getName());
		}
		for(int i=0;i<SHDepts.length;i++){
			System.out.println(SHDepts[0].getName());
		}
	}
}

//迭代器接口
public interface Iterator {
	boolean hasNext();
	Object next();
}

//北京分公司的部门迭代器
public class BJBranchIterator implements Iterator{
	ArrayList<Dept> depts;
	int position	= 0;
	public BJBranchIterator(ArrayList<Dept> depts){
		this.depts = depts;
	}
	@Override
	public boolean hasNext() {
		if(position>=depts.size() || depts.get(position)==null){
			return false;
		}else{
			return true;
		}
	}

	@Override
	public Object next() {
		Dept dept = depts.get(position);
		position  = position + 1;
		return dept;
	}

}

//改造后的北京分公司
public class BJBranch {
	ArrayList<Dept> depts;

	public BJBranch(){
		depts = new ArrayList<Dept>();
		//添加部门
		depts.add(new Dept("北京-财务部"));
		depts.add(new Dept("北京-研发部"));
		depts.add(new Dept("北京-开发部"));
	}

	/*public ArrayList<Dept> getDepts(){
		return depts;
	}*/

	//改造为返回Iterator对象，而不是ArrayList
	public Iterator createrIterator(){
		return new BJBranchIterator(depts);
	}
}

//上海分公司的部门迭代器
public class SHBranchIterator implements Iterator{
	Dept[] depts;
	int position	= 0;
	public SHBranchIterator(Dept[] depts){
		this.depts = depts;
	}
	@Override
	public boolean hasNext() {
		if(position>=depts.length|| depts[position]==null){
			return false;
		}else{
			return true;
		}
	}

	@Override
	public Object next() {
		Dept dept = depts[position];
		position  = position + 1;
		return dept;
	}

}

//改造后的上海分公司
public class SHBranch {
	Dept[] depts;

	public SHBranch(){
		depts = new Dept[3];
		//添加部门
		depts[0] = new Dept("上海-财务部");
		depts[1] = new Dept("上海-研发部");
		depts[2] = new Dept("上海-开发部");
	}

	/*public Dept[] getDepts(){
		return depts;
	}*/

	//改造为返回Iterator对象，而不是数组
	public Iterator createrIterator(){
		return new SHBranchIterator(depts);
	}
}

//使用迭代器模式后的代码实现
public class TestNew {

	public static void main(String[] args) {
		Iterator BJ = new BJBranch().createrIterator();
		Iterator SH = new SHBranch().createrIterator();

		printDeptName(BJ);
		printDeptName(SH);
	}

	private static void printDeptName(Iterator iterator){
		while(iterator.hasNext()){
			Dept dept = (Dept) iterator.next();
			System.out.println(dept.getName());
		}
	}
}

public class Tea {
	//泡茶流程
	void process() {
		boilWater();
		steepTeaBag();
		pourInCup();
		addLemon();
	}

	public void boilWater() {
		System.out.println("烧水");
	}

	public void steepTeaBag() {
		System.out.println("泡茶");
	}

	public void pourInCup() {
		System.out.println("倒进杯子");
	}

	public void addLemon() {
		System.out.println("加柠檬");
	}
}

public class Coffee {
	//冲咖啡流程
	void process() {
		boilWater();
		brewCoffeeGrinds();
		pourInCup();
		addSugarAndMilk();
	}

	public void boilWater() {
		System.out.println("烧水");
	}

	public void brewCoffeeGrinds() {
		System.out.println("冲咖啡");
	}

	public void pourInCup() {
		System.out.println("倒进杯子");
	}

	public void addSugarAndMilk() {
		System.out.println("加牛奶和糖");
	}
}

//定义模板方法
public abstract class TemplateMethod {
	//冲咖啡和泡茶的模板，注意这里的final,意味着该方法不可修改，即模板中方法的先后顺序被固定
	final void template() {
		//烧水
		boilWater();
		//冲泡：用沸水"浸泡"茶叶/用沸水"冲泡"咖啡
		brew();
		//把泡好的饮料倒进杯子
		pourInCup();
		//加调料
		addCondiments();
	}
	/**这两个方法交给子类去实现**/
	//茶应该"浸泡"，咖啡应该"冲泡"
	abstract void brew();
	//茶加柠檬，咖啡加牛奶和糖
	abstract void addCondiments();

	/**这两个方法属于公用方法**/
	void boilWater() {
		System.out.println("烧水");
	}
	void pourInCup() {
		System.out.println("倒进杯子");
	}
}

public class Tea extends TemplateMethod {
	public void brew() {
		System.out.println("浸泡");
	}
	public void addCondiments() {
		System.out.println("加柠檬");
	}
}

public class Coffee extends TemplateMethod {
	public void brew() {
		System.out.println("冲泡");
	}
	public void addCondiments() {
		System.out.println("加糖和牛奶");
	}
}

public class Test {
	public static void main(String[] args) {
		Tea tea = new Tea();
		Coffee coffee = new Coffee();
		//泡茶
		tea.template();
		//冲咖啡
		coffee.template();
	}
}

//定义模板方法
public abstract class TemplateMethodWithHook {
	//冲咖啡和泡茶的模板，注意这里的final,意味着该方法不可修改，即模板中方法的先后顺序被固定
	final void template() {
		//烧水
		boilWater();
		//冲泡：用沸水"浸泡"茶叶/用沸水"冲泡"咖啡
		brew();
		//把泡好的饮料倒进杯子
		pourInCup();
		//加调料
		if (customerWantsCondiments()) {
			addCondiments();
		}
	}
	/**这两个方法交给子类去实现**/
	//茶应该"浸泡"，咖啡应该"冲泡"
	abstract void brew();
	//茶加柠檬，咖啡加牛奶和糖
	abstract void addCondiments();

	/**这两个方法属于公用方法**/
	void boilWater() {
		System.out.println("烧水");
	}
	void pourInCup() {
		System.out.println("倒进杯子");
	}

	//这里是个钩子，子类可决定是否需要加调料。也就是说子类可通过这个hook控制模板定义的逻辑
	boolean customerWantsCondiments() {
		return true;
	}
}

public class TeaWithHook extends TemplateMethod {

	public void brew() {
		System.out.println("浸泡");
	}
	public void addCondiments() {
		System.out.println("加柠檬");
	}

	public boolean customerWantsCondiments() {
		//不需要加柠檬
		return false;
	}
}

public class CoffeeWithHook extends TemplateMethod {

	public void brew() {
		System.out.println("冲泡");
	}
	public void addCondiments() {
		System.out.println("加糖和牛奶");
	}

	public boolean customerWantsCondiments() {
		//需要加糖和牛奶
		return true;
	}
}

public class TestHook {
	public static void main(String[] args) {
		TeaWithHook teaHook = new TeaWithHook();
		CoffeeWithHook coffeeHook = new CoffeeWithHook();
		//泡茶，不加柠檬
		teaHook.template();
		//冲咖啡，加糖和牛奶
		coffeeHook.template();
	}
}

public class Door {
	//开门
	public void open(){

	}
	//关门
	public void close(){

	}
}

public class Light {
	//开灯
	public void on(){

	}
	//关灯
	public void off(){

	}
}

public class TV {
	//开电视
	public void on(){

	}
	//关电视
	public void off(){

	}
}

public class TestOld {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Light light = new Light();
		Door door 	= new Door();
		TV tv 		= new TV();
		//回家的业务逻辑
		door.open();
		light.on();
		tv.on();
		//出门的业务逻辑
		tv.off();
		light.off();
		door.close();
	}
}

//外观模式的实现
public class Facade {
	TV tv;
	Light light;
	Door door;
	public Facade(Door door,Light light,TV tv){
		this.tv	= tv;
		this.light = light;
		this.door = door;
	}
	//封装回家的业务逻辑
	public void goHome(){
		door.open();
		light.on();
		tv.on();
	}
	//封装出门的业务逻辑
	public void goOut(){
		tv.off();
		light.off();
		door.close();
	}
}

public class TestNew {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Light light = new Light();
		Door door 	= new Door();
		TV tv 		= new TV();
		Facade facade = new Facade(door,light,tv);
		/* 1.对于后期的运维人员，只需要知道这两个方法要干的事情即可，而不需要点开看里面的具体实现逻辑
		 * 2.如果是流水线的写法，则需要完完整整的把所有逻辑从头看到尾
		 * 3.这样的写法让代码结构更清晰
		 * 4.如果业务逻辑有变更，只需要修改对应的封装即可，而不需要去修改散落着各处的代码
		 * */
		//回家逻辑
		facade.goHome();
		//出门逻辑
		facade.goOut();
	}
}

//原始接口
public interface OldInterface {
	//原始方法
	public void oldWay();
}

public class OldWay implements OldInterface{
	@Override
	public void oldWay() {
		// TODO Auto-generated method stub
		System.out.println("This is old way.");
	}
}

//目前的新接口
public interface NewInterface {
	//以新方法去干一件事情
	public void newWay();
}

//通过适配器，使用新接口去调用老接口的方法
public class Adapter implements NewInterface{
	OldInterface old;
	public Adapter(OldInterface old){
		this.old = old;
	}
	@Override
	public void newWay() {
		// TODO Auto-generated method stub
		old.oldWay();
	}
}

public class Test {
	public static void main(String[] args) {
		OldWay old = new OldWay();
		//通过适配，使用新接口去调用老接口
		Adapter adapter = new Adapter(old);
		//打印：This is old way.
		adapter.newWay();
	}
}

public class Light {
	String location = "";

	public Light(String location) {
		this.location = location;
	}

	public void on() {
		System.out.println("打开"+location+"的灯");
	}

	public void off() {
		System.out.println("关闭"+location+"的灯");
	}
}

public class Television {

	public void open() {
		System.out.println("打开电视");
	}

	public void close() {
		System.out.println("关闭电视");
	}
}

//开关控制器
public class SwitchControlOld {
	Light light = new Light("客厅");
	Television television = new Television();

	public void onButtonWasPressed(int solt) {
		//打开第一个开关
		if(solt==0){
			light.on();
		}else if(solt==1){
			television.open();
		}
	}

	public void offButtonWasPressed(int solt) {
		//关闭第一个开关
		if(solt==0){
			light.off();
		}else if(solt==1){
			television.close();
		}
	}
}

//可以理解为这里为转接口的定义
public interface Command {
	//运行
	public void execute();
	//回退
	public void undo();
}

//开灯命令
public class LightOnCommand implements Command {
	Light light;

	public LightOnCommand(Light light) {
		this.light = light;
	}

	public void execute() {
		light.on();
	}

	@Override
	public void undo() {
		// TODO Auto-generated method stub
		light.off();
	}
}

//关灯命令
public class LightOffCommand implements Command {
	Light light;

	public LightOffCommand(Light light) {
		this.light = light;
	}

	public void execute() {
		light.off();
	}

	@Override
	public void undo() {
		// TODO Auto-generated method stub
		light.on();
	}
}

//打开电视
public class TelevisionOnCommand implements Command {
	Television television;

	public TelevisionOnCommand(Television television) {
		this.television = television;
	}
	@Override
	public void execute() {
		television.open();
	}
	@Override
	public void undo() {
		television.close();
	}
}

//关闭电视
public class TelevisionOffCommand implements Command {
	Television television;

	public TelevisionOffCommand(Television television) {
		this.television = television;
	}
	@Override
	public void execute() {
		television.close();
	}
	@Override
	public void undo() {
		television.open();
	}
}

//开关控制器
public class SwitchControl {
	Command[] onCommands = new Command[2];
	Command[] offCommands = new Command[2];
	//把开关与具体要干的事情关联起来
	public void setCommand(int solt,Command onCommand,Command offCommand) {
		onCommands[solt] = onCommand;
		offCommands[solt] = offCommand;
	}
	//按下开关
	public void onButtonWasPressed(int solt) {
		onCommands[solt].execute();
	}
	//回退
	public void offButtonWasPressed(int solt) {
		onCommands[solt].undo();
	}
}

public class Test {
	public static void main(String[] args) {
		//有两个开关的开关控制器
		SwitchControl control = new SwitchControl();
		//把电灯逻辑绑定到第一个开关上
		Light light = new Light("客厅");
		control.setCommand(0,new LightOnCommand(light),new LightOffCommand(light));
		control.onButtonWasPressed(0);		//- 打印：打开客厅的灯

		//把电视逻辑绑定到第二个开关上
		Television television = new Television();
		control.setCommand(1,new TelevisionOnCommand(television),new TelevisionOffCommand(television));
		control.onButtonWasPressed(1);		//- 打印：打开电视
	}
}