设计模式3-韩

1、模板方法模式（Template Method Pattern）

1、介绍

（1）概述

模板方法模式（Template Method Pattern），又叫模板模式(Template Pattern)，在一个抽象类公开定义了执行它的方法的模板。它的子类可以按需要重写方法实现，但调用将以抽象类中定义的方式进行。

简单说，模板方法模式定义一个操作中的算法的骨架，而将一些步骤延迟到子类中，使得子类可以不改变一个算法的结构，就可以重定义该算法的某些特定步骤

（2）原理图

（1）AbstractClass抽象类：类中实现了模板方法(template)，定义了算法的骨架，具体子类需要去实现。

（2） ConcreteClass：实现抽象方法operationr, 以完成算法中子类的步骤。

2、案例

1、需求

制作豆浆的流程选材—>添加配料—>浸泡—>放到豆浆机打碎，但是这几个步骤对于制作每种口味的豆浆都是一样的。

通过添加不同的配料，可以制作出不同口味的豆浆。

2、代码

（1）抽象类

扫描二维码关注公众号，回复： 12960884 查看本文章

//表示豆浆
public abstract class SoyaMilk {
    
    
      //模板方法, make , 模板方法可以做成final , 不让子类去覆盖.
      final void make() {
    
    
         select();
         addCondiments();
         soak();
         beat();
      }

   //选材料
   void select() {
    
    
      System.out.println("第一步：选择好的新鲜黄豆  ");
   }

   //添加不同的配料， 抽象方法, 子类具体实现
   abstract void addCondiments();

   //浸泡
   void soak() {
    
    
      System.out.println("第三步， 黄豆和配料开始浸泡， 需要3小时 ");
   }

   void beat() {
    
    
      System.out.println("第四步：黄豆和配料放到豆浆机去打碎  ");
   }
}

（2）子类-PeanutSoyaMilk

public class PeanutSoyaMilk extends SoyaMilk {
    
    
	@Override
	void addCondiments() {
    
    
		System.out.println(" 加入上好的花生 ");
	}
}

（3）客户端

public class Client {
    
    
   public static void main(String[] args) {
    
    
      //制作红豆豆浆
      System.out.println("----制作红豆豆浆----");
      SoyaMilk redBeanSoyaMilk = new RedBeanSoyaMilk();
      redBeanSoyaMilk.make();
      
      System.out.println("----制作花生豆浆----");
      SoyaMilk peanutSoyaMilk = new PeanutSoyaMilk();
      peanutSoyaMilk.make();
   }
}

3、钩子方法

1、介绍

在模板方法模式的父类中，我们可以定义一个方法，它默认不做任何事，子类可以视情况要不要覆盖它，该方法称为“钩子”。

做豆浆的例子来讲解，比如，我们还希望制作纯豆浆，不添加任何的配料，请使用钩子方法对前面的模板方法进行改造。

（1）抽象类改造

//抽象类，表示豆浆
public abstract class SoyaMilk {
    
    

   //模板方法, make , 模板方法可以做成final , 不让子类去覆盖.
   final void make() {
    
    
      select();
      if (customerWantCondiments()) {
    
    
         addCondiments();
      }
      soak();
      beat();

   }

   //选材料
   void select() {
    
    
      System.out.println("第一步：选择好的新鲜黄豆  ");
   }

   //添加不同的配料， 抽象方法, 子类具体实现
   abstract void addCondiments();

   //浸泡
   void soak() {
    
    
      System.out.println("第三步， 黄豆和配料开始浸泡， 需要3小时 ");
   }

   void beat() {
    
    
      System.out.println("第四步：黄豆和配料放到豆浆机去打碎  ");
   }

   //钩子方法，决定是否需要添加配料
   boolean customerWantCondiments() {
    
    
      return true;
   }
}

（2）添加纯豆浆类

//纯豆浆
public class PureSoyaMilk extends SoyaMilk {
    
    

   @Override
   void addCondiments() {
    
    
      //空实现，不叫任何调料
   }

   //钩子方法，覆盖掉父类中的方法
   @Override
   boolean customerWantCondiments() {
    
    
      return false;
   }
}

（3）客户端调用

public class Client {
    
    
   public static void main(String[] args) {
    
    
      System.out.println("----制作花生豆浆----");
      SoyaMilk peanutSoyaMilk = new PeanutSoyaMilk();
      peanutSoyaMilk.make();
      
      System.out.println("----制作纯豆浆----");
      SoyaMilk pureSoyaMilk = new PureSoyaMilk();
      pureSoyaMilk.make();
   }
}

4、细节

（1）基本思想是：算法只存在于一个地方，也就是在父类中，容易修改。需要修改算法时，只要修改父类的模板方法或者已经实现的某些步骤，子类就会继承这些修改

（2）实现了最大化代码复用。父类的模板方法和已实现的某些步骤会被子类继承而直接使用。

（3）既统一了算法，也提供了很大的灵活性。父类的模板方法确保了算法的结构保持不变，同时由子类提供部分步骤的实现。

（4）该模式的不足之处：每一个不同的实现都需要一个子类实现，导致类的个数增加，使得系统更加庞大

（5）一般模板方法都加上final关键字，防止子类重写模板方法。

（6）模板方法模式使用场景：当要完成在某个过程，该过程要执行一系列步骤，这一系列的步骤基本相同，但其个别步骤在实现时可能不同，通常考虑用模板方法模式来处理。

2、命令模式（Command Pattern）

1、介绍

（1）概述

在软件设计中，我们经常需要向某些对象发送请求，但是并不知道请求的接收者是谁，也不知道被请求的操作是哪个，我们只需在程序运行时指定具体的请求接收者即可。

命名模式使得请求发送者与请求接收者消除彼此之间的耦合，让对象之间的调用关系更加灵活，实现解耦。

比如：我们希望只要一个app就可以控制全部智能家电。要实现一个app控制所有智能家电的需要，则每个智能家电厂家都要提供一个统一的接口给app调用，这时就可以考虑使用命令模式。

（2）原理类图

通俗易懂的理解：将军发布命令，士兵去执行。

其中有几个角色：将军（命令发布者）、士兵（命令的具体执行者）、命令(连接将军和士兵)。

Invoker是调用者（将军），Receiver是被调用者（士兵）， MyCommand是命令，实现了Command接口，持有接收对象。

（1）Invoker：调用者角色。

（2）Command: 命令角色，需要执行的所有命令都在这里，可以是接口或抽象类。

（3）Receiver: 接受者角色，知道如何实施和执行一个请求相关的操作。

（4）ConcreteCommand: 将一个接受者对象与一个动作绑定，调用接受者相应的操作，实现execute。

2、案例

1、需求

使用命令模式完成前面的智能家电项目

2、代码

（1）创建命令接口-Command

public interface Command {
    
    
   //执行动作(操作)
   public void execute();
   //撤销动作(操作)
   public void undo();
}

（2）创建具体执行者-ConcreteCommand

public class LightOnCommand implements Command {
    
    
	//聚合LightReceiver
	LightReceiver light;

	//构造器
	public LightOnCommand(LightReceiver light) {
    
    
		super();
		this.light = light;
	}

	@Override
	public void execute() {
    
    
		//调用接收者的方法
		light.on();
	}

	@Override
	public void undo() {
    
    
		//调用接收者的方法
		light.off();
	}
}

public class LightOffCommand implements Command {
    
    
   // 聚合LightReceiver
   LightReceiver light;

   // 构造器
   public LightOffCommand(LightReceiver light) {
    
    
      super();
      this.light = light;
   }

   @Override
   public void execute() {
    
    
      // 调用接收者的方法
      light.off();
   }

   @Override
   public void undo() {
    
    
      // 调用接收者的方法
      light.on();
   }
}

（3）创建接收者-Receiver

public class LightReceiver {
    
    
   public void on() {
    
    
      System.out.println(" 电灯打开了.. ");
   }
   
   public void off() {
    
    
      System.out.println(" 电灯关闭了.. ");
   }
}

（4）创建遥控器-invoke

//遥控器 一个按钮就代表一个命令
public class RemoteController {
    
    

   // 开 按钮的命令数组
   Command[] onCommands;
   Command[] offCommands;

   // 执行撤销的命令
   Command undoCommand;

   // 构造器，完成对按钮初始化
   public RemoteController() {
    
    
      onCommands = new Command[5];
      offCommands = new Command[5];

      //遥控器上有五排按钮
      for (int i = 0; i < 5; i++) {
    
    
         //使用到了空命令
         onCommands[i] = new NoCommand();
         offCommands[i] = new NoCommand();
      }
   }

   // 给我们的按钮设置你需要的命令
   public void setCommand(int no, Command onCommand, Command offCommand) {
    
    
      onCommands[no] = onCommand;
      offCommands[no] = offCommand;
   }

   // 按下开按钮
   public void onButtonWasPushed(int no) {
    
     // no 0
      // 找到你按下的开的按钮， 并调用对应方法
      onCommands[no].execute();
      // 记录这次的操作，用于撤销
      undoCommand = onCommands[no];
   }

   // 按下开按钮
   public void offButtonWasPushed(int no) {
    
     // no 0
      // 找到你按下的关的按钮， 并调用对应方法
      offCommands[no].execute();
      // 记录这次的操作，用于撤销
      undoCommand = offCommands[no];
   }

   // 按下撤销按钮
   public void undoButtonWasPushed() {
    
    
      undoCommand.undo();
   }
}

（5）客户端测试

public class Client {
    
    
   public static void main(String[] args) {
    
    
      //使用命令设计模式，完成通过遥控器，对电灯的操作

      //创建电灯的对象(接受者)
      LightReceiver lightReceiver = new LightReceiver();

      //创建电灯相关的开关命令
      LightOnCommand lightOnCommand = new LightOnCommand(lightReceiver);
      LightOffCommand lightOffCommand = new LightOffCommand(lightReceiver);

      //需要一个遥控器
      RemoteController remoteController = new RemoteController();

      //给我们的遥控器设置命令, 比如 no = 0 是电灯的开和关的操作
      remoteController.setCommand(0, lightOnCommand, lightOffCommand);

      System.out.println("--------按下灯的开按钮-----------");
      remoteController.onButtonWasPushed(0);
      System.out.println("--------按下灯的关按钮-----------");
      remoteController.offButtonWasPushed(0);
      System.out.println("--------按下撤销按钮-----------");
      remoteController.undoButtonWasPushed();
   }
}

3、细节

1、将发起请求的对象与执行请求的对象解耦。发起请求的对象是调用者，调用者只要调用命令对象的execute()方法就可以让接收者工作，而不必知道具体的接收者对象是谁、是如何实现的，命令对象会负责让接收者执行请求的动作，也就是说：” 请求发起者”和“请求执行者”之间的解耦是通过命令对象实现的，命令对象起到了纽带桥梁的作用。

2、容易实现对请求的撤销和重做。

3、空命令也是一种设计模式，它为我们省去了判空的操作。在上面的实例中，如果没有用空命令，我们每按下一个按键都要判空，这给我们编码带来一定的麻烦。

4、缺点：可能导致某些系统有过多的具体命令类，增加了系统的复杂度，这点在在使用的时候要注意。

3、访问者模式（Visitor Pattern）

1、介绍

1、概述

访问者模式封装一些作用于某种数据结构的各元素的操作，它可以在不改变数据结构的前提下定义作用于这些元素的新的操作。

主要将数据结构与数据操作分离，解决数据结构和操作耦合性问题。

访问者模式的基本工作原理是：在被访问的类里面加一个对外提供接待访问者的接口。

2、应用场景

需要对一个对象结构中的对象进行很多不同操作 (这些操作彼此没有关联)，同时需要避免让这些操作"污染"这些对象的类，可以选用访问者模式解决。

3、原理类图

（1）Visitor 是抽象访问者，为该对象结构中的ConcreteElement的每一个类声明一个visit操作。

（2）ConcreteVisitor ：是一个具体的访问者，实现每个有Visitor 声明的操作，是每个操作实现的部分。

（3）ObjectStructure 能枚举它的元素，可以提供一个高层的接口，用来允许访问者访问元素。

（4）Element 定义一个accept 方法，接收一个访问者对象。

（5）ConcreteElement 为具体元素，实现了accept 方法。

2、案例

1、需求

将人分为男人和女人，对歌手进行测评，当看完某个歌手表演后，得到他们对该歌手不同的评价(评价有不同的种类，比如成功、失败等)。

2、代码

（1）创建抽象访问者

public abstract class Action {
    
    
	//得到男性 的测评 Action依赖Man
	public abstract void getManResult(Man man);
	
	//得到女的 测评
	public abstract void getWomanResult(Woman woman);
}

（2）创建Element

public abstract class Person {
    
    
	//提供一个方法，让访问者可以访问
	public abstract void accept(Action action);
}

（3）创建ConcreteElement

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

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

（4）创建ConcreteVisitor

public class Success extends Action {
    
    
	@Override
	public void getManResult(Man man) {
    
    
		System.out.println(" 男人给的评价该歌手很成功 !");
	}

	@Override
	public void getWomanResult(Woman woman) {
    
    
		System.out.println(" 女人给的评价该歌手很成功 !");
	}
}

public class Fail extends Action {
    
    
	@Override
	public void getManResult(Man man) {
    
    
		System.out.println(" 男人给的评价该歌手失败 !");
	}

	@Override
	public void getWomanResult(Woman woman) {
    
    
		System.out.println(" 女人给的评价该歌手失败 !");
	}
}

（5）创建ObjectStructure

import java.util.LinkedList;
import java.util.List;

//数据结构，管理很多人（Man , Woman）
public class ObjectStructure {
    
    
	//维护了一个集合 Person 就是element
	private List<Person> persons = new LinkedList<>();

	//增加到list
	public void attach(Person p) {
    
    
		persons.add(p);
	}

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

	//显示测评情况
	public void display(Action action) {
    
    
		for (Person p : persons) {
    
    
			p.accept(action);
		}
	}
}

（6）客户端

public class Client {
    
    
   public static void main(String[] args) {
    
    
      //创建ObjectStructure
      ObjectStructure objectStructure = new ObjectStructure();

      objectStructure.attach(new Man());
      objectStructure.attach(new Woman());

      //成功
      Success success = new Success();
      /**
       *  男人给的评价该歌手很成功 !
       *  女人给的评价该歌手很成功 !
       */
      objectStructure.display(success);
   }
}

3、细节

1、具体元素对访问者公布细节，也就是说访问者关注了其他类的内部细节，这是迪米特法则所不建议的, 这样造成了具体元素变更比较困难。

2、违背了依赖倒转原则。访问者依赖的是具体元素，而不是抽象元素。

3、因此，如果一个系统有比较稳定的数据结构，又有经常变化的功能需求，那么访问者模式就是比较合适的。

4、迭代器模式（Iterator Pattern）

1、介绍

1、概述

如果我们的集合元素是用不同的方式实现的，有数组，还有java的集合类，或者还有其他方式，当客户端要遍历这些集合元素的时候就要使用多种遍历方式，而且还会暴露元素的内部结构，可以考虑使用迭代器模式解决。

迭代器模式，提供一种遍历集合元素的统一接口，用一致的方法遍历集合元素，不需要知道集合对象的底层表示，即：不暴露其内部的结构。

2、原理图类图

（1）Iterator ：迭代器接口，是系统提供，含义 hasNext, next, remove。

（2）ConcreteIterator : 具体的迭代器类，管理迭代。

（3）Aggregate :一个统一的聚合接口，将客户端和具体聚合解耦。

（4）ConcreteAggreage：具体的聚合持有对象集合，并提供一个方法，返回一个迭代器，该迭代器能够正确遍历集合。

（5）client：客户端，通过Iterator和Aggregate依赖子类。

2、案例

1、需求

要在一个页面中展示出学校的院系组成，一个学校有多个学院，一个学院有多个系。

2、代码

（1）创建系

public class Department {
    
    
   private String name;
   private String desc;

   public Department(String name, String desc) {
    
    
      super();
      this.name = name;
      this.desc = desc;
   }

   public String getName() {
    
    
      return name;
   }

   public void setName(String name) {
    
    
      this.name = name;
   }

   public String getDesc() {
    
    
      return desc;
   }

   public void setDesc(String desc) {
    
    
      this.desc = desc;
   }
}

（2）创建具体的迭代器-concreteIterator

import java.util.Iterator;

public class ComputerCollegeIterator implements Iterator {
    
    
   //这里我们需要Department 是以怎样的方式存放=>数组
   Department[] departments;
   int position = 0; //遍历的位置

   //构造器 将departments传进来
   public ComputerCollegeIterator(Department[] departments) {
    
    
      this.departments = departments;
   }

   //判断是否还有下一个元素
   @Override
   public boolean hasNext() {
    
    
      //数组的方式判断有没有下一个
      if (position >= departments.length || departments[position] == null) {
    
    
         return false;
      } else {
    
    
         return true;
      }
   }

   @Override
   public Object next() {
    
    
      Department department = departments[position];
      position += 1;
      return department;
   }

   //删除的方法（暂时不需要），默认空实现
   public void remove() {
    
    
   }
}

import java.util.Iterator;
import java.util.List;

public class InfoColleageIterator implements Iterator {
    
    
   List<Department> departmentList; // 信息工程学院是以List方式存放系
   int index = -1;//索引

   //构造器
   public InfoColleageIterator(List<Department> departmentList) {
    
    
      this.departmentList = departmentList;
   }

   //判断list中还有没有下一个元素
   @Override
   public boolean hasNext() {
    
    
      //list的方式判断有没有下一个
      if (index >= departmentList.size() - 1) {
    
    
         return false;
      } else {
    
    
         index += 1;
         return true;
      }
   }

   @Override
   public Object next() {
    
    
      return departmentList.get(index);
   }

   //空实现remove
   public void remove() {
    
    
   }
}

（3）创建统一接口-Aggregate

import java.util.Iterator;

public interface College {
    
    
   String getName();

   //增加系的方法
   void addDepartment(String name, String desc);

   //核心方法是要返回一个迭代器,遍历
   Iterator createIterator();
}

（4）创建具体接口实现类

import java.util.Iterator;

public class ComputerCollege implements College {
    
    
   Department[] departments;
   int numOfDepartment = 0;// 保存当前数组的对象个数

   public ComputerCollege() {
    
    
      departments = new Department[5];
      addDepartment("Java专业", " Java专业 ");
      addDepartment("PHP专业", " PHP专业 ");
      addDepartment("大数据专业", " 大数据专业 ");
   }

   @Override
   public String getName() {
    
    
      return "计算机学院";
   }

   @Override
   public void addDepartment(String name, String desc) {
    
    
      Department department = new Department(name, desc);
      departments[numOfDepartment] = department;
      numOfDepartment += 1;
   }

   @Override
   public Iterator createIterator() {
    
    
      return new ComputerCollegeIterator(departments);
   }
}

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class InfoCollege implements College {
    
    
   List<Department> departmentList;

   public InfoCollege() {
    
    
      departmentList = new ArrayList<Department>();
      addDepartment("信息安全专业", " 信息安全专业 ");
      addDepartment("网络安全专业", " 网络安全专业 ");
      addDepartment("服务器安全专业", " 服务器安全专业 ");
   }

   @Override
   public String getName() {
    
    
      return "信息工程学院";
   }

   @Override
   public void addDepartment(String name, String desc) {
    
    
      Department department = new Department(name, desc);
      departmentList.add(department);
   }

   @Override
   public Iterator createIterator() {
    
    
      return new InfoColleageIterator(departmentList);
   }
}

（5）创建统一输出类

import java.util.Iterator;
import java.util.List;

//将所有学院输出出来
public class OutPutImpl {
    
    
   //学院集合
   List<College> collegeList;

   //将collegeList传进来
   public OutPutImpl(List<College> collegeList) {
    
    
      this.collegeList = collegeList;
   }

   //遍历所有学院,然后调用printDepartment 输出各个学院的系
   public void printCollege() {
    
    
      //从collegeList 取出所有学院, Java 中的 List 已经实现Iterator
      Iterator<College> iterator = collegeList.iterator();

      while (iterator.hasNext()) {
    
    
         //取出一个学院
         College college = iterator.next();
         System.out.println("=== " + college.getName() + "=====");
         printDepartment(college.createIterator()); //得到对应迭代器
      }
   }

   //输出学院的系
   public void printDepartment(Iterator iterator) {
    
    
      while (iterator.hasNext()) {
    
    
         Department d = (Department) iterator.next();
         System.out.println(d.getName());
      }
   }
}

（6）客户端

import java.util.ArrayList;
import java.util.List;

public class Client {
    
    
   public static void main(String[] args) {
    
    
      //创建学院
      List<College> collegeList = new ArrayList<College>();
      //有下面两个学院
      ComputerCollege computerCollege = new ComputerCollege();
      InfoCollege infoCollege = new InfoCollege();

      collegeList.add(computerCollege);
      collegeList.add(infoCollege);

      OutPutImpl outPutImpl = new OutPutImpl(collegeList);
      outPutImpl.printCollege();
   }
}

3、细节

1、优点

（1）提供一个统一的方法遍历对象，客户不用再考虑聚合的类型，使用一种方法就可以遍历对象了。

（2）隐藏了聚合的内部结构，客户端要遍历聚合的时候只能取到迭代器，而不会知道聚合的具体组成。

（3）提供了一种设计思想，就是一个类应该只有一个引起变化的原因（叫做单一责任原则）。在聚合类中，我们把迭代器分开，就是要把管理对象集合和遍历对象集合的责任分开，这样一来集合改变的话，只影响到聚合对象。而如果遍历方式改变的话，只影响到了迭代器。

（4）当要展示一组相似对象，或者遍历一组相同对象时使用, 适合使用迭代器模式。

2、缺点

每个聚合对象都要一个迭代器，会生成多个迭代器不好管理类。

5、观察者模式（Observer）

1、介绍

1、概述

观察者模式：对象之间多对一依赖的一种设计方案，被依赖的对象为Subject，依赖的对象为Observer，Subject通知Observer变化，比如这里的奶站是 Subject，是1的一方。用户为Observer，是多的一方。

2、原理类图

观察者模式类似订牛奶业务：

（1）奶站/气象站：Subject

（2）用户/第三方网站：Observer

Subject的行为有登记注册、移除和通知。比如notifyObservers() 就是通知所有的注册的用户，根据不同需求，可以是更新数据，让用户来取，也可能是实施推送，看具体需求定。

3、优点

（1）观察者模式设计后，会以集合的方式来管理用户(Observer)，包括注册，移除和通知。

（2）我们增加观察者(这里可以理解成一个新的公告板)，就不需要去修改核心类WeatherData代码，遵守了ocp原则。

2、案例-传统方法

1、需求

气象站可以将每天测量到的温度，湿度，气压等等以公告的形式发布出去(比如：发布到自己的网站或第三方)。

2、代码

（1）网站类

/**
 * 显示当前天气情况（可以理解成是气象站自己的网站）
 */
public class CurrentConditions {
    
    
   // 温度，气压，湿度
   private float temperature;
   private float pressure;
   private float humidity;

   //更新 天气情况，是由 WeatherData 来调用，我使用推送模式
   public void update(float temperature, float pressure, float humidity) {
    
    
      this.temperature = temperature;
      this.pressure = pressure;
      this.humidity = humidity;
      display(); //更新到自己的网站中。
   }

   //显示
   public void display() {
    
    
      System.out.println("***Today mTemperature: " + temperature + "***");
      System.out.println("***Today mPressure: " + pressure + "***");
      System.out.println("***Today mHumidity: " + humidity + "***");
   }
}

（2）气象站的数据-核心类

/**
 * 类是核心
 * 1. 包含最新的天气情况信息
 * 2. 含有 CurrentConditions 对象
 * 3. 当数据有更新时，就主动的调用 CurrentConditions对象update方法(含display), 这样他们（接入方）就看到最新的信息
 */
public class WeatherData {
    
    
	private float temperatrue;
	private float pressure;
	private float humidity;
	private CurrentConditions currentConditions; //加入新的第三方

	public WeatherData(CurrentConditions currentConditions) {
    
    
		this.currentConditions = currentConditions;
	}

	public float getTemperature() {
    
    
		return temperatrue;
	}

	public float getPressure() {
    
    
		return pressure;
	}

	public float getHumidity() {
    
    
		return humidity;
	}

	public void dataChange() {
    
    
		//第三方接口，然后调用接入方的update方法
		currentConditions.update(getTemperature(), getPressure(), getHumidity());
	}

	//当数据有更新时，就调用 setData
	public void setData(float temperature, float pressure, float humidity) {
    
    
		this.temperatrue = temperature;
		this.pressure = pressure;
		this.humidity = humidity;
		//调用dataChange， 将最新的信息 推送给 接入方 currentConditions
		dataChange();
	}
}

（3）客户端

public class Client {
    
    
   public static void main(String[] args) {
    
    
      //创建接入方 currentConditions
      CurrentConditions currentConditions = new CurrentConditions();
      //创建 WeatherData 并将接入方 currentConditions 传递到 WeatherData中
      WeatherData weatherData = new WeatherData(currentConditions);

      //更新天气情况
      weatherData.setData(30, 150, 40);

      //天气情况变化
      System.out.println("============天气情况变化=============");
      weatherData.setData(40, 160, 20);
   }
}

当在WeatherData中增加一个第三方时，不利于维护。

3、案例-观察者模式

1、代码

（1）创建Subject接口

//接口, 让WeatherData 来实现 
public interface Subject {
    
    
   public void registerObserver(Observer o);

   public void removeObserver(Observer o);

   public void notifyObservers();
}

（2）创建观察者接口

//观察者接口，有观察者来实现
public interface Observer {
    
    
   public void update(float temperature, float pressure, float humidity);
}

（3）创建核心类

package com.atguigu.observer.improve;

import java.util.ArrayList;

/**
 * 类是核心
 * 1. 包含最新的天气情况信息
 * 2. 含有 观察者集合，使用ArrayList管理
 * 3. 当数据有更新时，就主动的调用   ArrayList, 通知所有的（接入方）就看到最新的信息
 */
public class WeatherData implements Subject {
    
    
   private float temperatrue;
   private float pressure;
   private float humidity;
   //观察者集合
   private ArrayList<Observer> observers;

   //加入新的第三方,对集合进行处理
   public WeatherData() {
    
    
      observers = new ArrayList<Observer>();
   }

   public float getTemperature() {
    
    
      return temperatrue;
   }

   public float getPressure() {
    
    
      return pressure;
   }

   public float getHumidity() {
    
    
      return humidity;
   }

   public void dataChange() {
    
    
      //调用 接入方的 update
      notifyObservers();
   }

   //当数据有更新时，就调用 setData
   public void setData(float temperature, float pressure, float humidity) {
    
    
      this.temperatrue = temperature;
      this.pressure = pressure;
      this.humidity = humidity;
      //调用dataChange， 将最新的信息 推送给 接入方 currentConditions
      dataChange();
   }

   //注册一个观察者
   @Override
   public void registerObserver(Observer o) {
    
    
      observers.add(o);
   }

   //移除一个观察者
   @Override
   public void removeObserver(Observer o) {
    
    
      if (observers.contains(o)) {
    
    
         observers.remove(o);
      }
   }

   //遍历所有的观察者，并通知
   @Override
   public void notifyObservers() {
    
    
      for (int i = 0; i < observers.size(); i++) {
    
    
         observers.get(i).update(this.temperatrue, this.pressure, this.humidity);
      }
   }
}

（4）创建我的气象站-CurrentConditions

代码不变。

（5）引入第三方

//同CurrentConditions
public class BaiduSite implements Observer {
    
    

   // 温度，气压，湿度
   private float temperature;
   private float pressure;
   private float humidity;

   // 更新 天气情况，是由 WeatherData 来调用，我使用推送模式
   public void update(float temperature, float pressure, float humidity) {
    
    
      this.temperature = temperature;
      this.pressure = pressure;
      this.humidity = humidity;
      display();
   }

   // 显示
   public void display() {
    
    
      System.out.println("===百度网站====");
      System.out.println("***百度网站 气温 : " + temperature + "***");
      System.out.println("***百度网站 气压: " + pressure + "***");
      System.out.println("***百度网站 湿度: " + humidity + "***");
   }
}

（5）测试类

public class Client {
    
    
   public static void main(String[] args) {
    
    
      //创建一个WeatherData
      WeatherData weatherData = new WeatherData();

      //创建观察者
      CurrentConditions currentConditions = new CurrentConditions();
      BaiduSite baiduSite = new BaiduSite();

      //注册到weatherData
    weatherData.registerObserver(currentConditions);
      weatherData.registerObserver(baiduSite);

      //测试
      System.out.println("通知各个注册的观察者, 看看信息");
      weatherData.setData(10f, 100f, 30.3f);

      System.out.println("----------------------------------");
      weatherData.removeObserver(currentConditions);
      //测试
      System.out.println();
      System.out.println("通知各个注册的观察者, 看看信息");
      weatherData.setData(10f, 100f, 30.3f);
   }
}

6、中介者模式（Mediator Pattern）

1、介绍

1、概述

中介者模式是用一个中介对象来封装一系列的对象交互。中介者使各个对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。

2、原理类图

2、案例

1、需求

主人要看电视时，各个设备可以协同工作，自动完成看电视的准备工作，比如流程为：闹铃响起->咖啡机开始做咖啡->窗帘自动落下->电视机开始播放。这里不使用外观模式。

2、代码

操作流程：

1、创建ConcreteMediator对象
2、创建各个同事类，比如Alarm，Tv等
3、在创建同时类对象的时候，就直接通过构造器，加入到colleagueMap
4、同时类对象可以调用sendMessage,最终会调用concreteMediator的getMessage方法
5、getMessage方法会直接根据接收到的同事对象发出的信息来协调调用其他的同事对象

（1）创建Mediator

public abstract class Mediator {
    
    
   //将给中介者对象colleague，加入到集合中
   public abstract void Register(String colleagueName, Colleague colleague);

   //接收消息, 具体的同事对象发出
   public abstract void GetMessage(int stateChange, String colleagueName);

   public abstract void SendMessage();
}

（2）创建同事抽象类

//同事抽象类
public abstract class Colleague {
    
    
   private Mediator mediator;
   public String name;

   public Colleague(Mediator mediator, String name) {
    
    
      this.mediator = mediator;
      this.name = name;
   }

   public Mediator getMediator() {
    
    
      return this.mediator;
   }

   public abstract void SendMessage(int stateChange);
}

（3）创建中介类-ConcreteMediator

import java.util.HashMap;

//具体的中介者类-核心类
public class ConcreteMediator extends Mediator {
    
    
   //集合，放入所有的同事对象
   private HashMap<String, Colleague> colleagueMap;
   private HashMap<String, String> interMap;

   public ConcreteMediator() {
    
    
      colleagueMap = new HashMap<String, Colleague>();
      interMap = new HashMap<String, String>();
   }

   //将给中介者对象colleague，加入到集合中
   @Override
   public void Register(String colleagueName, Colleague colleague) {
    
    
      colleagueMap.put(colleagueName, colleague);
      if (colleague instanceof Alarm) {
    
    
         interMap.put("Alarm", colleagueName);
      } else if (colleague instanceof CoffeeMachine) {
    
    
         interMap.put("CoffeeMachine", colleagueName);
      } else if (colleague instanceof TV) {
    
    
         interMap.put("TV", colleagueName);
      } else if (colleague instanceof Curtains) {
    
    
         interMap.put("Curtains", colleagueName);
      }
   }

   //具体中介者的核心方法
   //1. 根据得到消息，完成对应任务
   //2. 中介者在这个方法，协调各个具体的同事对象，完成任务
   //接收消息, 具体的同事对象发出
   @Override
   public void GetMessage(int stateChange, String colleagueName) {
    
    
      //处理闹钟发出的消息
      if (colleagueMap.get(colleagueName) instanceof Alarm) {
    
    
         if (stateChange == 0) {
    
    
            ((CoffeeMachine) (colleagueMap.get(interMap.get("CoffeeMachine")))).StartCoffee();
            ((TV) (colleagueMap.get(interMap.get("TV")))).StartTv();
         } else if (stateChange == 1) {
    
    
            ((TV) (colleagueMap.get(interMap.get("TV")))).StopTv();
         }
      } else if (colleagueMap.get(colleagueName) instanceof CoffeeMachine) {
    
    
         ((Curtains) (colleagueMap.get(interMap.get("Curtains")))).UpCurtains();

      } else if (colleagueMap.get(colleagueName) instanceof Curtains) {
    
    
         //如果是以窗帘发出的消息，这里处理...
      }
   }

   @Override
   public void SendMessage() {
    
    
   }
}

（4）创建具体同事类

//具体的同事类
public class Alarm extends Colleague {
    
    
   //构造器
   public Alarm(Mediator mediator, String name) {
    
    
      super(mediator, name);
      //在创建Alarm 同事对象时，将自己放入到ConcreteMediator 对象中[集合]
      mediator.Register(name, this);
   }

   public void SendAlarm(int stateChange) {
    
    
      SendMessage(stateChange);
   }

   @Override
   public void SendMessage(int stateChange) {
    
    
      //调用的中介者对象的getMessage
      this.getMediator().GetMessage(stateChange, this.name);
   }
}

public class CoffeeMachine extends Colleague {
    
    
   public CoffeeMachine(Mediator mediator, String name) {
    
    
      super(mediator, name);
      mediator.Register(name, this);
   }

   @Override
   public void SendMessage(int stateChange) {
    
    
      this.getMediator().GetMessage(stateChange, this.name);
   }

   public void StartCoffee() {
    
    
      System.out.println("It's time to startcoffee!");
   }

   public void FinishCoffee() {
    
    

      System.out.println("After 5 minutes!");
      System.out.println("Coffee is ok!");
      SendMessage(0);
   }
}

（5）测试类

public class ClientTest {
    
    
   public static void main(String[] args) {
    
    
      //创建一个中介者对象
      Mediator mediator = new ConcreteMediator();

      //创建Alarm 并且加入到  ConcreteMediator 对象的HashMap
      Alarm alarm = new Alarm(mediator, "alarm");

      //创建了CoffeeMachine 对象，并且加入到  ConcreteMediator 对象的HashMap
      CoffeeMachine coffeeMachine = new CoffeeMachine(mediator, "coffeeMachine");

      //让闹钟发出消息
      alarm.SendAlarm(0);
      coffeeMachine.FinishCoffee();
      alarm.SendAlarm(1);
   }
}

rm(int stateChange) {
SendMessage(stateChange);
}

@Override
public void SendMessage(int stateChange) {
//调用的中介者对象的getMessage
this.getMediator().GetMessage(stateChange, this.name);
}
}


```java
public class CoffeeMachine extends Colleague {
   public CoffeeMachine(Mediator mediator, String name) {
      super(mediator, name);
      mediator.Register(name, this);
   }

   @Override
   public void SendMessage(int stateChange) {
      this.getMediator().GetMessage(stateChange, this.name);
   }

   public void StartCoffee() {
      System.out.println("It's time to startcoffee!");
   }

   public void FinishCoffee() {

      System.out.println("After 5 minutes!");
      System.out.println("Coffee is ok!");
      SendMessage(0);
   }
}

（5）测试类

public class ClientTest {
    
    
   public static void main(String[] args) {
    
    
      //创建一个中介者对象
      Mediator mediator = new ConcreteMediator();

      //创建Alarm 并且加入到  ConcreteMediator 对象的HashMap
      Alarm alarm = new Alarm(mediator, "alarm");

      //创建了CoffeeMachine 对象，并且加入到  ConcreteMediator 对象的HashMap
      CoffeeMachine coffeeMachine = new CoffeeMachine(mediator, "coffeeMachine");

      //让闹钟发出消息
      alarm.SendAlarm(0);
      coffeeMachine.FinishCoffee();
      alarm.SendAlarm(1);
   }
}

1、模板方法模式（Template Method Pattern）

1、介绍

2、案例

3、钩子方法

4、细节

2、命令模式（Command Pattern）

1、介绍

2、案例

3、细节

3、访问者模式（Visitor Pattern）

1、介绍

2、案例

3、细节

4、迭代器模式（Iterator Pattern）

1、介绍

2、案例

3、细节

5、观察者模式（Observer）

1、介绍

2、案例-传统方法

3、案例-观察者模式

6、中介者模式（Mediator Pattern）

1、介绍

2、案例

猜你喜欢