<s id="mvh2b"><strike id="mvh2b"><u id="mvh2b"></u></strike></s>
    1. <rp id="mvh2b"></rp>

      当前位置:首页 > IT教程

      head first 设计模式

      时间:2021-08-08 14:53:09来源:金橙教程网 作者:admin8 阅读:56次 [手机版]
       

      headfirst设计模式

      一、概述

      设计模式不是代码,而是解决问题的方案,学习现有的设计模式可以做到经验复用。

      拥有设计模式词汇,在沟通时就能用更少的词汇来讨论,并且不需要了解底层细节。

      源码以及 uml

      二、创建型

      1. 单例(Singleton)

      意图

      确保一个类只有一个实例,并提供该实例的全局访问点。

      类图

      使用一个私有构造函数、一个私有静态变量以及一个公有静态函数来实现。

      私有构造函数保证了不能通过构造函数来创建对象实例,只能通过公有静态函数返回唯一的私有静态变量。

      实现

      (一)懒汉式-线程不安全

      以下实现中,私有静态变量 uniqueInstance 被延迟化实例化,这样做的好处是,如果没有用到该类,那么就不会实例化 uniqueInstance,从而节约资源。

      这个实现在多线程环境下是不安全的,如果多个线程能够同时进入 if (uniqueInstance == null) ,并且此时 uniqueInstance 为 null,那么多个线程会执行 uniqueInstance = new Singleton(); 语句,这将导致实例化多次 uniqueInstance。

      public class Singleton {
      
          private static Singleton uniqueInstance;
      
          private Singleton() {
          }
      
          public static Singleton getUniqueInstance() {
              if (uniqueInstance == null) {
                  uniqueInstance = new Singleton();
              }
              return uniqueInstance;
          }
      }

      (二)懒汉式-线程安全

      只需要对 getUniqueInstance() 方法加锁,那么在一个时间点只能有一个线程能够进入该方法,从而避免了对 uniqueInstance 进行多次实例化的问题。

      但是这样有一个问题,就是当一个线程进入该方法之后,其它线程试图进入该方法都必须等待,因此性能上有一定的损耗。

      public static synchronized Singleton getUniqueInstance() {
          if (uniqueInstance == null) {
              uniqueInstance = new Singleton();
          }
          return uniqueInstance;
      }

      (三)饿汉式-线程安全

      线程不安全问题主要是由于 uniqueInstance 被实例化了多次,如果 uniqueInstance 采用直接实例化的话,就不会被实例化多次,也就不会产生线程不安全问题。但是直接实例化的方式也丢失了延迟实例化带来的节约资源的优势。

      private static Singleton uniqueInstance = new Singleton();

      (四)双重校验锁-线程安全

      uniqueInstance 只需要被实例化一次,之后就可以直接使用了。加锁操作只需要对实例化那部分的代码进行。也就是说,只有当 uniqueInstance 没有被实例化时,才需要进行加锁。

      双重校验锁先判断 uniqueInstance 是否已经被实例化,如果没有被实例化,那么才对实例化语句进行加锁。

      public class Singleton {
      
          private volatile static Singleton uniqueInstance;
      
          private Singleton() {
          }
      
          public static Singleton getUniqueInstance() {
              if (uniqueInstance == null) {
                  synchronized (Singleton.class) {
                      if (uniqueInstance == null) {
                          uniqueInstance = new Singleton();
                      }
                  }
              }
              return uniqueInstance;
          }
      }

      考虑下面的实现,也就是只使用了一个 if 语句。在 uniqueInstance == null 的情况下,如果两个线程同时执行 if 语句,那么两个线程就会同时进入 if 语句块内。虽然在 if 语句块内有加锁操作,但是两个线程都会执行 uniqueInstance = new Singleton(); 这条语句,只是先后的问题,也就是说会进行两次实例化,从而产生了两个实例。因此必须使用双重校验锁,也就是需要使用两个 if 判断。

      if (uniqueInstance == null) {
          synchronized (Singleton.class) {
              uniqueInstance = new Singleton();
          }
      }

      uniqueInstance 采用 volatile 关键字修饰也是很有必要的。uniqueInstance = new Singleton(); 这段代码其实是分为三步执行。

      1. 分配内存空间。
      2. 初始化对象。
      3. 将 uniqueInstance 指向分配的内存地址。

      但是由于 JVM 具有指令重排的特性,有可能执行顺序变为了 1>3>2,这在单线程情况下自然是没有问题。但如果是多线程下,有可能获得是一个还没有被初始化的实例,以致于程序出错。

      使用 volatile 可以禁止 JVM 的指令重排,保证在多线程环境下也能正常运行。

      (五)枚举实现

      这是单例模式的最佳实践,它实现简单,并且在复杂的序列化或者反射攻击的时候,能够防止实例化多次。

      public enum Singleton {
          uniqueInstance;
      }

      考虑以下单例模式的实现,该 Singleton 在每次序列化的时候都会创建一个新的实例,为了保证只创建一个实例,必须声明所有字段都是 transient,并且提供一个 readResolve() 方法。

      public class Singleton implements Serializable{
      
          private static Singleton uniqueInstance;
      
          private Singleton() {
          }
      
          public static synchronized Singleton getUniqueInstance() {
              if (uniqueInstance == null) {
                  uniqueInstance = new Singleton();
              }
              return uniqueInstance;
          }
      }

      如果不使用枚举来实现单例模式,会出现反射攻击,因为通过 setAccessible() 方法可以将私有构造函数的访问级别设置为 public,然后调用构造函数从而实例化对象。如果要防止这种攻击,需要在构造函数中添加防止实例化第二个对象的代码。

      从上面的讨论可以看出,解决序列化和反射攻击很麻烦,而枚举实现不会出现这两种问题,所以说枚举实现单例模式是最佳实践。

      使用场景

      • Logger Classes
      • Configuration Classes
      • Accesing resources in shared mode
      • Factories implemented as Singletons

      jdk

      • java.lang.Runtime#getRuntime()
      • java.awt.Desktop#getDesktop()
      • java.lang.System#getSecurityManager()

      2. 简单工厂(Simple Factory)

      意图

      在创建一个对象时不向客户暴露内部细节,并提供一个创建对象的通用接口

      类图

      简单工厂不是设计模式,更像是一种编程习惯。它把实例化的操作单独放到一个类中,这个类就成为简单工厂类,让简单工厂类来决定应该用哪个子类来实例化。

      这样做能把客户类和具体子类的实现解耦,客户类不再需要知道有哪些子类以及应当实例化哪个子类。因为客户类往往有多个,如果不使用简单工厂,所有的客户类都要知道所有子类的细节。而且一旦子类发生改变,例如增加子类,那么所有的客户类都要进行修改。

      如果存在下面这种代码,就需要使用简单工厂将对象实例化的部分放到简单工厂中。

      public class Client {
          public static void main(String[] args) {
              int type = 1;
              Product product;
              if (type == 1) {
                  product = new ConcreteProduct1();
              } else if (type == 2) {
                  product = new ConcreteProduct2();
              } else {
                  product = new ConcreteProduct();
              }
          }
      }

      实现

      public interface Product {
      }

      public class ConcreteProduct implements Product {
      }

      public class ConcreteProduct1 implements Product {
      }

      public class ConcreteProduct2 implements Product {
      }

      public class SimpleFactory {
          public Product createProduct(int type) {
              if (type == 1) {
                  return new ConcreteProduct1();
              } else if (type == 2) {
                  return new ConcreteProduct2();
              }
              return new ConcreteProduct();
          }
      }

      public class Client {
          public static void main(String[] args) {
              SimpleFactory simpleFactory = new SimpleFactory();
              Product product = simpleFactory.createProduct(1);
          }
      }

      3. 工厂方法(Factory Method)

      意图

      定义了一个创建对象的接口,但由子类决定要实例化哪个类。工厂方法把实例化推迟到子类。

      类图

      在简单工厂中,创建对象的是另一个类,而在工厂方法中,是由子类来创建对象。

      下图中,Factory 有一个 DOSomethind() 方法,这个方法需要用到一组产品对象,这组产品对象由 factoryMethod() 方法创建。该方法是抽象的,需要由子类去实现。

      实现

      public abstract class Factory {
          abstract public Product factoryMethod();
          public void doSomething() {
              Product product = factoryMethod();
              // do something with the product
          }
      }

      public class ConcreteFactory extends Factory {
          public Product factoryMethod() {
              return new ConcreteProduct();
          }
      }

      public class ConcreteFactory1 extends Factory {
          public Product factoryMethod() {
              return new ConcreteProduct1();
          }
      }

      public class ConcreteFactory2 extends Factory {
          public Product factoryMethod() {
              return new ConcreteProduct2();
          }
      }

      JDK

      • java.util.Calendar
      • java.util.ResourceBundle
      • java.text.Numberformat
      • java.nio.charset.Charset
      • java.net.URLStreamHandlerFactory
      • java.util.EnumSet
      • javax.xml.bind.JAXBContext

      4. 抽象工厂(Abstract Factory)

      意图

      提供一个接口,用于创建 相关的对象家族

      类图

      抽象工厂模式创建的是对象家族,也就是很多对象而不是一个对象,并且这些对象是相关的,也就是说必须一起创建出来。而工厂模式只是用于创建一个对象,这和抽象工厂模式有很大不同。

      抽象工厂模式用到了工厂模式来创建单一对象,AbstractFactory 中的 createProductA() 和 createProductB() 方法都是让子类来实现,这两个方法单独来看就是在创建一个对象,这符合工厂模式的定义。

      至于创建对象的家族这一概念是在 Client 体现,Client 要通过 AbstractFactory 同时调用两个方法来创建出两个对象,在这里这两个对象就有很大的相关性,Client 需要同时创建出这两个对象。

      从高层次来看,抽象工厂使用了组合,即 Cilent 组合了 AbstractFactory,而工厂模式使用了继承。

      代码实现

      public class AbstractProductA {
      }

      public class AbstractProductB {
      }

      public class ProductA1 extends AbstractProductA {
      }

      public class ProductA2 extends AbstractProductA {
      }

      public class ProductB1 extends AbstractProductB {
      }

      public class ProductB2 extends AbstractProductB {
      }

      public abstract class AbstractFactory {
          abstract AbstractProductA createProductA();
          abstract AbstractProductB createProductB();
      }

      public class ConcreteFactory1 extends AbstractFactory {
          AbstractProductA createProductA() {
              return new ProductA1();
          }
      
          AbstractProductB createProductB() {
              return new ProductB1();
          }
      }

      public class ConcreteFactory2 extends AbstractFactory {
          AbstractProductA createProductA() {
              return new ProductA2();
          }
      
          AbstractProductB createProductB() {
              return new ProductB2();
          }
      }

      public class Client {
          public static void main(String[] args) {
              AbstractFactory abstractFactory = new ConcreteFactory1();
              AbstractProductA productA = abstractFactory.createProductA();
              AbstractProductB productB = abstractFactory.createProductB();
              // do something with productA and productB
          }
      }

      JDK

      • javax.xml.parsers.documentBuilderFactory
      • javax.xml.transform.TransformerFactory
      • javax.xml.xpath.XPathFactory

      5. 生成器(Builder)

      意图

      封装一个对象的构造过程,并允许按步骤构造。

      类图

      实现

      以下是一个简易的 StringBuilder 实现,参考了 JDK 1.8 源码。

      public class AbstractStringBuilder {
          protected char[] value;
      
          protected int count;
      
          public AbstractStringBuilder(int capacity) {
              count = 0;
              value = new char[capacity];
          }
      
          public AbstractStringBuilder append(char c) {
              ensureCapacityINTERNAL(count + 1);
              value[count++] = c;
              return this;
          }
      
          private void ensureCapacityInternal(int MinimumCapacity) {
              // overflow-conscious code
              if (minimumCapacity - value.length > 0)
                  expandCapacity(minimumCapacity);
          }
      
          void expandCapacity(int minimumCapacity) {
              int newCapacity = value.length * 2 + 2;
              if (newCapacity - minimumCapacity < 0)
                  newCapacity = minimumCapacity;
              if (newCapacity < 0) {
                  if (minimumCapacity < 0) // overflow
                      throw new OutOfMemoryERROR();
                  newCapacity = Integer.MAX_VALUE;
              }
              value = Arrays.copyOf(value, newCapacity);
          }
      }

      public class StringBuilder extends AbstractStringBuilder {
          public StringBuilder() {
              super(16);
          }
      
          @Override
          public String toString() {
              // Create a copy, don't share the array
              return new String(value, 0, count);
          }
      }

      public class Client {
          public static void main(String[] args) {
              StringBuilder sb = new StringBuilder();
              final int count = 26;
              for (int i = 0; i < count; i++) {
                  sb.append((char) ('a' + i));
              }
              System.out.println(sb.toString());
          }
      }

      abcdefghijklmnopqrstuvwxyz

      JDK

      • java.lang.StringBuilder
      • java.nio.ByteBuffer
      • java.lang.StringBuffer
      • java.lang.Appendable
      • Apache Camel builders

      6. 原型模式(Prototype)

      意图

      使用原型实例指定要创建对象的类型,通过复制这个原型来创建新对象。

      类图

      实现

      public abstract class Prototype {
          abstract Prototype myClone();
      }

      public class ConcretePrototype extends Prototype {
      
          private String filed;
      
          public ConcretePrototype(String filed) {
              this.filed = filed;
          }
      
          @Override
          Prototype myClone() {
              return new ConcretePrototype(filed);
          }
      
          @Override
          public String toString() {
              return filed;
          }
      }

      public class Client {
          public static void main(String[] args) {
              Prototype prototype = new ConcretePrototype("abc");
              Prototype clone = prototype.myClone();
              System.out.println(clone.toString());
          }
      }

      abc

      JDK

      • java.lang.Object#clone()

      三、行为型

      1. 责任链(Chain Of Responsibility)

      意图

      使多个对象都有机会处理请求,从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链,并沿着这条链传递该请求,直到有一个对象处理它为止。

      类图

      • Handler:定义处理请求的接口,并且实现后继链(successor)

      实现

      public abstract class Handler {
          protected Handler successor;
      
          public Handler(Handler successor) {
              this.successor = successor;
          }
      
          protected abstract void handleRequest(Request request);
      }

      public class ConcreteHandler1 extends Handler {
          public ConcreteHandler1(Handler successor) {
              super(successor);
          }
      
          @Override
          protected void handleRequest(Request request) {
              if (request.getType() == RequestType.type1) {
                  System.out.println(request.getName() + " is handle by ConcreteHandler1");
                  return;
              }
              if (successor != null) {
                  successor.handleRequest(request);
              }
          }
      }

      public class ConcreteHandler2 extends Handler{
          public ConcreteHandler2(Handler successor) {
              super(successor);
          }
      
          @Override
          protected void handleRequest(Request request) {
              if (request.getType() == RequestType.type2) {
                  System.out.println(request.getName() + " is handle by ConcreteHandler2");
                  return;
              }
              if (successor != null) {
                  successor.handleRequest(request);
              }
          }
      }

      public class Request {
          private RequestType type;
          private String name;
      
          public Request(RequestType type, String name) {
              this.type = type;
              this.name = name;
          }
      
          public RequestType getType() {
              return type;
          }
      
          public String getName() {
              return name;
          }
      }

      public enum RequestType {
          type1, type2
      }

      public class Client {
          public static void main(String[] args) {
              Handler handler1 = new ConcreteHandler1(null);
              Handler handler2 = new ConcreteHandler2(handler1);
              Request request1 = new Request(RequestType.type1, "request1");
              handler2.handleRequest(request1);
              Request request2 = new Request(RequestType.type2, "request2");
              handler2.handleRequest(request2);
          }
      }

      request1 is handle by ConcreteHandler1
      request2 is handle by ConcreteHandler2

      JDK

      • java.util.logging.Logger#log()
      • Apache Commons Chain
      • javax.servlet.Filter#doFilter()

      2. 命令(Command)

      意图

      将命令封装成对象中,以便使用命令来参数化其它对象,或者将命令对象放入队列中进行排队,或者将命令对象的操作记录到日志中,以及支持可撤销的操作。

      类图

      • Command:命令
      • Receiver:命令接收者,也就是命令真正的执行者
      • Invoker:通过它来调用命令
      • Client:可以设置命令与命令的接收者

      实现

      设计一个遥控器,可以控制电灯开关。

      public interface Command {
          void execute();
      }

      public class LightOnCommand implements Command {
          Light light;
      
          public LightOnCommand(Light light) {
              this.light = light;
          }
      
          @Override
          public void execute() {
              light.on();
          }
      }

      public class LightOffCommand implements Command {
          Light light;
      
          public LightOffCommand(Light light) {
              this.light = light;
          }
      
          @Override
          public void execute() {
              light.off();
          }
      }

      public class Light {
      
          public void on() {
              System.out.println("Light is on!");
          }
      
          public void off() {
              System.out.println("Light is off!");
          }
      }

      /**
       * 遥控器
       */
      public class Invoker {
          private Command[] onCommands;
          private Command[] offCommands;
          private final int slotNum = 7;
      
          public Invoker() {
              this.onCommands = new Command[slotNum];
              this.offCommands = new Command[slotNum];
          }
      
          public void setOnCommand(Command command, int slot) {
              onCommands[slot] = command;
          }
      
          public void setOffCommand(Command command, int slot) {
              offCommands[slot] = command;
          }
      
          public void onButtonWaspushed(int slot) {
              onCommands[slot].execute();
          }
      
          public void offButtonWasPushed(int slot) {
              offCommands[slot].execute();
          }
      }

      public class Client {
          public static void main(String[] args) {
              Invoker invoker = new Invoker();
              Light light = new Light();
              Command lightOnCommand = new LightOnCommand(light);
              Command lightOffCommand = new LightOffCommand(light);
              invoker.setOnCommand(lightOnCommand, 0);
              invoker.setOffCommand(lightOffCommand, 0);
              invoker.onButtonWasPushed(0);
              invoker.offButtonWasPushed(0);
          }
      }

      JDK

      • java.lang.Runnable
      • Netflix Hystrix
      • javax.swing.Action

      3. 解释器(Interpreter)

      意图

      为语言创建解释器,通常由语言的语法和语法分析来定义。

      类图

      • TerminalExpression:终结符表达式,每个终结符都需要一个 TerminalExpression
      • Context:上下文,包含解释器之外的一些全局信息

      实现

      以下是一个规则检验器实现,具有 and 和 or 规则,通过规则可以构建一颗解析树,用来检验一个文本是否满足解析树定义的规则。

      例如一颗解析树为 D And (A Or (B C)),文本 "D A" 满足该解析树定义的规则。

      这里的 Context 指的是 String。

      public abstract class Expression {
          public abstract boolean interpret(String str);
      }

      public class TerminalExpression extends Expression {
      
          private String literal = null;
      
          public TerminalExpression(String str) {
              literal = str;
          }
      
          public boolean interpret(String str) {
              StringTokenizer st = new StringTokenizer(str);
              while (st.hasMoreTokens()) {
                  String test = st.nextToken();
                  if (test.equals(literal)) {
                      return true;
                  }
              }
              return false;
          }
      }

      public class AndExpression extends Expression {
      
          private Expression expression1 = null;
          private Expression expression2 = null;
      
          public AndExpression(Expression expression1, Expression expression2) {
              this.expression1 = expression1;
              this.expression2 = expression2;
          }
      
          public boolean interpret(String str) {
              return expression1.interpret(str) && expression2.interpret(str);
          }
      }

      public class OrExpression extends Expression {
          private Expression expression1 = null;
          private Expression expression2 = null;
      
          public OrExpression(Expression expression1, Expression expression2) {
              this.expression1 = expression1;
              this.expression2 = expression2;
          }
      
          public boolean interpret(String str) {
              return expression1.interpret(str) || expression2.interpret(str);
          }
      }

      public class Client {
      
          /**
           * 构建解析树
           */
          public static Expression buildInterpreterTree() {
              // Literal
              Expression terminal1 = new TerminalExpression("A");
              Expression terminal2 = new TerminalExpression("B");
              Expression terminal3 = new TerminalExpression("C");
              Expression terminal4 = new TerminalExpression("D");
              // B C
              Expression alternation1 = new OrExpression(terminal2, terminal3);
              // A Or (B C)
              Expression alternation2 = new OrExpression(terminal1, alternation1);
              // D And (A Or (B C))
              return new AndExpression(terminal4, alternation2);
          }
      
          public static void main(String[] args) {
              Expression define = buildInterpreterTree();
              String context1 = "D A";
              String context2 = "A B";
              System.out.println(define.interpret(context1));
              System.out.println(define.interpret(context2));
          }
      }

      true
      false

      JDK

      • java.util.Pattern
      • java.text.Normalizer
      • All subclasses of java.text.Format
      • javax.el.ELResolver

      4. 迭代器(Iterator)

      意图

      提供一种顺序访问聚合对象元素的方法,并且不暴露聚合对象的内部表示。

      类图

      • Aggregate 是聚合类,其中 createIterator() 方法可以产生一个 Iterator;
      • Iterator 主要定义了 hasNext() 和 next() 方法。
      • Client 组合了 Aggregate,为了迭代遍历 Aggregate,也需要组合 Iterator。

      实现

      public interface Aggregate {
          Iterator createIterator();
      }

      public class ConcreteAggregate implements Aggregate {
      
          private Integer[] items;
      
          public ConcreteAggregate() {
              items = new Integer[10];
              for (int i = 0; i < items.length; i++) {
                  items[i] = i;
              }
          }
      
          @Override
          public Iterator createIterator() {
              return new ConcreteIterator<Integer>(items);
          }
      }

      public interface Iterator<Item> {
          Item next();
      
          boolean hasNext();
      }

      public class ConcreteIterator<Item> implements Iterator {
      
          private Item[] items;
          private int position = 0;
      
          public ConcreteIterator(Item[] items) {
              this.items = items;
          }
      
          @Override
          public Object next() {
              return items[position++];
          }
      
          @Override
          public boolean hasNext() {
              return position < items.length;
          }
      }

      public class Client {
          public static void main(String[] args) {
              Aggregate aggregate = new ConcreteAggregate();
              Iterator<Integer> iterator = aggregate.createIterator();
              while (iterator.hasNext()) {
                  System.out.println(iterator.next());
              }
          }
      }

      JDK

      • java.util.Iterator
      • java.util.Enumeration

      5. 中介者(Mediator)

      意图

      集中相关对象之间复杂的沟通和控制方式。

      类图

      • Mediator:中介者,定义一个接口用于与各同事(Colleague)对象通信
      • Colleague:同事,相关对象

      实现

      Alarm(闹钟)、CoffeePot(咖啡壶)、Calendar(日历)、Sprinkler(喷头)是一组相关的对象,在某个对象的事件产生时需要去操作其它对象,形成了下面这种依赖结构:

      使用中介者模式可以将复杂的依赖结构变成星形结构:

      public abstract class Colleague {
          public abstract void onEvent(Mediator mediator);
      }

      public class Alarm extends Colleague {
      
          @Override
          public void onEvent(Mediator mediator) {
              mediator.doEvent("alarm");
          }
      
          public void doAlarm() {
              System.out.println("doAlarm()");
          }
      }

      public class CoffeePot extends Colleague {
          @Override
          public void onEvent(Mediator mediator) {
              mediator.doEvent("coffeePot");
          }
      
          public void doCoffeePot() {
              System.out.println("doCoffeePot()");
          }
      }

      public class Calender extends Colleague {
          @Override
          public void onEvent(Mediator mediator) {
              mediator.doEvent("calender");
          }
      
          public void doCalender() {
              System.out.println("doCalender()");
          }
      }

      public class Sprinkler extends Colleague {
          @Override
          public void onEvent(Mediator mediator) {
              mediator.doEvent("sprinkler");
          }
      
          public void doSprinkler() {
              System.out.println("doSprinkler()");
          }
      }

      public abstract class Mediator {
          public abstract void doEvent(String eventType);
      }

      public class ConcreteMediator extends Mediator {
          private Alarm alarm;
          private CoffeePot coffeePot;
          private Calender calender;
          private Sprinkler sprinkler;
      
          public ConcreteMediator(Alarm alarm, CoffeePot coffeePot, Calender calender, Sprinkler sprinkler) {
              this.alarm = alarm;
              this.coffeePot = coffeePot;
              this.calender = calender;
              this.sprinkler = sprinkler;
          }
      
          @Override
          public void doEvent(String eventType) {
              switch (eventType) {
                  CASE "alarm":
                      doAlarmEvent();
                      break;
                  case "coffeePot":
                      doCoffeePotEvent();
                      break;
                  case "calender":
                      doCalenderEvent();
                      break;
                  default:
                      doSprinklerEvent();
              }
          }
      
          public void doAlarmEvent() {
              alarm.doAlarm();
              coffeePot.doCoffeePot();
              calender.doCalender();
              sprinkler.doSprinkler();
          }
      
          public void doCoffeePotEvent() {
              // ...
          }
      
          public void doCalenderEvent() {
              // ...
          }
      
          public void doSprinklerEvent() {
              // ...
          }
      }

      public class Client {
          public static void main(String[] args) {
              Alarm alarm = new Alarm();
              CoffeePot coffeePot = new CoffeePot();
              Calender calender = new Calender();
              Sprinkler sprinkler = new Sprinkler();
              Mediator mediator = new ConcreteMediator(alarm, coffeePot, calender, sprinkler);
              // 闹钟事件到达,调用中介者就可以操作相关对象
              alarm.onEvent(mediator);
          }
      }

      doAlarm()
      doCoffeePot()
      doCalender()
      doSprinkler()

      JDK

      • All scheduleXXX() methods of java.util.Timer
      • java.util.concurrent.Executor#execute()
      • submit() and invokeXXX() methods of java.util.concurrent.Executorservice
      • scheduleXXX() methods of java.util.concurrent.ScheduledExecutorService
      • java.lang.reflect.Method#invoke()

      6. 备忘录(Memento)

      意图

      在不违反封装的情况下获得对象的内部状态,从而在需要时可以将对象恢复到最初状态。

      类图

      • Originator:原始对象
      • Caretaker:负责保存好备忘录
      • Menento:备忘录,存储原始对象的的状态。备忘录实际上有两个接口,一个是提供给 Caretaker 的窄接口:它只能将备忘录传递给其它对象;一个是提供给 Originator 的宽接口,允许它访问到先前状态所需的所有数据。理想情况是只允许 Originator 访问本备忘录的内部状态。

      实现

      以下实现了一个简单计算器程序,可以输入两个值,然后计算这两个值的和。备忘录模式允许将这两个值存储起来,然后在某个时刻用存储的状态进行恢复。

      实现参考:Memento Pattern - Calculator Example - Java Sourcecode

      /**
       * Originator Interface
       */
      public interface Calculator {
      
          // Create Memento
          PreviousCalculationToCareTaker backupLastCalculation();
      
          // setMemento
          void restorePreviousCalculation(PreviousCalculationToCareTaker memento);
      
          int getCalculationResult();
      
          void setFirstNumber(int firstNumber);
      
          void setSecondNumber(int secondNumber);
      }

      /**
       * Originator Implementation
       */
      public class CalculatorImp implements Calculator {
      
          private int firstNumber;
          private int secondNumber;
      
          @Override
          public PreviousCalculationToCareTaker backupLastCalculation() {
              // create a memento object used for restoring two numbers
              return new PreviousCalculationImp(firstNumber, secondNumber);
          }
      
          @Override
          public void restorePreviousCalculation(PreviousCalculationToCareTaker memento) {
              this.firstNumber = ((PreviousCalculationToOriginator) memento).getFirstNumber();
              this.secondNumber = ((PreviousCalculationToOriginator) memento).getSecondNumber();
          }
      
          @Override
          public int getCalculationResult() {
              // result is adding two numbers
              return firstNumber + secondNumber;
          }
      
          @Override
          public void setFirstNumber(int firstNumber) {
              this.firstNumber = firstNumber;
          }
      
          @Override
          public void setSecondNumber(int secondNumber) {
              this.secondNumber = secondNumber;
          }
      }

      /**
       * Memento Interface to Originator
       *
       * This interface allows the originator to restore its state
       */
      public interface PreviousCalculationToOriginator {
          int getFirstNumber();
          int getSecondNumber();
      }

      /**
       *  Memento interface to CalculatorOperator (Caretaker)
       */
      public interface PreviousCalculationToCareTaker {
          // no operations permitted for the caretaker
      }

      /**
       * Memento Object Implementation
       * <p>
       * Note that this object implements both interfaces to Originator and CareTaker
       */
      public class PreviousCalculationImp implements PreviousCalculationToCareTaker,
              PreviousCalculationToOriginator {
      
          private int firstNumber;
          private int secondNumber;
      
          public PreviousCalculationImp(int firstNumber, int secondNumber) {
              this.firstNumber = firstNumber;
              this.secondNumber = secondNumber;
          }
      
          @Override
          public int getFirstNumber() {
              return firstNumber;
          }
      
          @Override
          public int getSecondNumber() {
              return secondNumber;
          }
      }

      /**
       * CareTaker object
       */
      public class Client {
      
          public static void main(String[] args) {
              // program starts
              Calculator calculator = new CalculatorImp();
      
              // assume user enters two numbers
              calculator.setFirstNumber(10);
              calculator.setSecondNumber(100);
      
              // find result
              System.out.println(calculator.getCalculationResult());
      
              // Store result of this calculation in case of error
              PreviousCalculationToCareTaker memento = calculator.backupLastCalculation();
      
              // user enters a number
              calculator.setFirstNumber(17);
      
              // user enters a wrong second number and calculates result
              calculator.setSecondNumber(-290);
      
              // calculate result
              System.out.println(calculator.getCalculationResult());
      
              // user hits CTRL + Z to undo last operation and see last result
              calculator.restorePreviousCalculation(memento);
      
              // result restored
              System.out.println(calculator.getCalculationResult());
          }
      }

      110
      -273
      110

      JDK

      • java.io.Serializable

      7. 观察者(ObServer

      意图

      定义对象之间的一对多依赖,当一个对象状态改变时,它的所有依赖都会收到通知并且自动更新状态。

      主题(Subject)是被观察的对象,而其所有依赖者(Observer)称为观察者。

      类图

      主题(Subject)具有注册和移除观察者、并通知所有注册者的功能,主题是通过维护一张观察者列表来实现这些操作的。

      观察者(Observer)的注册功能需要调用主题的 registerObserver() 方法。

      实现

      天气数据布告板会在天气信息发生改变时更新其内容,布告板有多个,并且在将来会继续增加。

      public interface Subject {
          void resisterObserver(Observer o);
      
          void removeObserver(Observer o);
      
          void notifyObserver();
      }

      import java.util.ArrayList;
      import java.util.List;
      
      public class WeatherDATa implements Subject {
          private List<Observer> observers;
          private float temperature;
          private float humidity;
          private float pressure;
      
          public WeatherData() {
              observers = new ArrayList<>();
          }
      
          public void setMeasurements(float temperature, float humidity, float pressure) {
              this.temperature = temperature;
              this.humidity = humidity;
              this.pressure = pressure;
              notifyObserver();
          }
      
          @Override
          public void resisterObserver(Observer o) {
              observers.add(o);
          }
      
          @Override
          public void removeObserver(Observer o) {
              int i = observers.indexOf(o);
              if (i >= 0) {
                  observers.remove(i);
              }
          }
      
          @Override
          public void notifyObserver() {
              for (Observer o : observers) {
                  o.update(temperature, humidity, pressure);
              }
          }
      }

      public interface Observer {
          void update(float temp, float humidity, float pressure);
      }

      public class StatisticsDisplay implements Observer {
      
          public StatisticsDisplay(Subject weatherData) {
              weatherData.resisterObserver(this);
          }
      
          @Override
          public void update(float temp, float humidity, float pressure) {
              System.out.println("StatisticsDisplay.update: " + temp + " " + humidity + " " + pressure);
          }
      }

      public class CurrentConditionsDisplay implements Observer {
      
          public CurrentConditionsDisplay(Subject weatherData) {
              weatherData.resisterObserver(this);
          }
      
          @Override
          public void update(float temp, float humidity, float pressure) {
              System.out.println("CurrentConditionsDisplay.update: " + temp + " " + humidity + " " + pressure);
          }
      }

      public class WeatherStation {
          public static void main(String[] args) {
              WeatherData weatherData = new WeatherData();
              CurrentConditionsDisplay currentConditionsDisplay = new CurrentConditionsDisplay(weatherData);
              StatisticsDisplay statisticsDisplay = new StatisticsDisplay(weatherData);
      
              weatherData.setMeasurements(0, 0, 0);
              weatherData.setMeasurements(1, 1, 1);
          }
      }

      CurrentConditionsDisplay.update: 0.0 0.0 0.0
      StatisticsDisplay.update: 0.0 0.0 0.0
      CurrentConditionsDisplay.update: 1.0 1.0 1.0
      StatisticsDisplay.update: 1.0 1.0 1.0

      JDK

      • java.util.Observer
      • java.util.EventListener
      • javax.servlet.http.HttpSessionBindingListener
      • RxJava

      8. 状态(State)

      意图

      允许对象在内部状态改变时改变它的行为,对象看起来好像修改了它所属的类。

      类图

      实现

      糖果销售机有多种状态,每种状态下销售机有不同的行为,状态可以发生转移,使得销售机的行为也发生改变。

      public interface State {
          /**
           * 投入 25 分钱
           */
          void insertQuarter();
      
          /**
           * 退回 25 分钱
           */
          void ejectQuarter();
      
          /**
           * 转动曲柄
           */
          void turnCrank();
      
          /**
           * 发放糖果
           */
          void dispense();
      }

      public class HasQuarterState implements State {
      
          private GumballMAChine gumballMachine;
      
          public HasQuarterState(GumballMachine gumballMachine) {
              this.gumballMachine = gumballMachine;
          }
      
          @Override
          public void insertQuarter() {
              System.out.println("You can't insert another quarter");
          }
      
          @Override
          public void ejectQuarter() {
              System.out.println("Quarter returned");
              gumballMachine.setState(gumballMachine.getNoQuarterState());
          }
      
          @Override
          public void turnCrank() {
              System.out.println("You turned...");
              gumballMachine.setState(gumballMachine.getSoldState());
          }
      
          @Override
          public void dispense() {
              System.out.println("No gumball dispensed");
          }
      }

      public class NoQuarterState implements State {
      
          GumballMachine gumballMachine;
      
          public NoQuarterState(GumballMachine gumballMachine) {
              this.gumballMachine = gumballMachine;
          }
      
          @Override
          public void insertQuarter() {
              System.out.println("You insert a quarter");
              gumballMachine.setState(gumballMachine.getHasQuarterState());
          }
      
          @Override
          public void ejectQuarter() {
              System.out.println("You haven't insert a quarter");
          }
      
          @Override
          public void turnCrank() {
              System.out.println("You turned, but there's no quarter");
          }
      
          @Override
          public void dispense() {
              System.out.println("You need to pay first");
          }
      }

      public class SoldOutState implements State {
      
          GumballMachine gumballMachine;
      
          public SoldOutState(GumballMachine gumballMachine) {
              this.gumballMachine = gumballMachine;
          }
      
          @Override
          public void insertQuarter() {
              System.out.println("You can't insert a quarter, the machine is sold out");
          }
      
          @Override
          public void ejectQuarter() {
              System.out.println("You can't eject, you haven't inserted a quarter yet");
          }
      
          @Override
          public void turnCrank() {
              System.out.println("You turned, but there are no gumballs");
          }
      
          @Override
          public void dispense() {
              System.out.println("No gumball dispensed");
          }
      }

      public class SoldState implements State {
      
          GumballMachine gumballMachine;
      
          public SoldState(GumballMachine gumballMachine) {
              this.gumballMachine = gumballMachine;
          }
      
          @Override
          public void insertQuarter() {
              System.out.println("Please wait, we're already giving you a gumball");
          }
      
          @Override
          public void ejectQuarter() {
              System.out.println("Sorry, you already turned the crank");
          }
      
          @Override
          public void turnCrank() {
              System.out.println("Turning twice doesn't get you another gumball!");
          }
      
          @Override
          public void dispense() {
              gumballMachine.releaseBall();
              if (gumballMachine.getCount() > 0) {
                  gumballMachine.setState(gumballMachine.getNoQuarterState());
              } else {
                  System.out.println("Oops, out of gumballs");
                  gumballMachine.setState(gumballMachine.getSoldOutState());
              }
          }
      }

      public class GumballMachine {
      
          private State soldOutState;
          private State noQuarterState;
          private State hasQuarterState;
          private State soldState;
      
          private State state;
          private int count = 0;
      
          public GumballMachine(int numberGumballs) {
              count = numberGumballs;
              soldOutState = new SoldOutState(this);
              noQuarterState = new NoQuarterState(this);
              hasQuarterState = new HasQuarterState(this);
              soldState = new SoldState(this);
      
              if (numberGumballs > 0) {
                  state = noQuarterState;
              } else {
                  state = soldOutState;
              }
          }
      
          public void insertQuarter() {
              state.insertQuarter();
          }
      
          public void ejectQuarter() {
              state.ejectQuarter();
          }
      
          public void turnCrank() {
              state.turnCrank();
              state.dispense();
          }
      
          public void setState(State state) {
              this.state = state;
          }
      
          public void releaseBall() {
              System.out.println("A gumball comes rolling out the slot...");
              if (count != 0) {
                  count -= 1;
              }
          }
      
          public State getSoldOutState() {
              return soldOutState;
          }
      
          public State getNoQuarterState() {
              return noQuarterState;
          }
      
          public State getHasQuarterState() {
              return hasQuarterState;
          }
      
          public State getSoldState() {
              return soldState;
          }
      
          public int getCount() {
              return count;
          }
      }

      public class Client {
      
          public static void main(String[] args) {
              GumballMachine gumballMachine = new GumballMachine(5);
      
              gumballMachine.insertQuarter();
              gumballMachine.turnCrank();
      
              gumballMachine.insertQuarter();
              gumballMachine.ejectQuarter();
              gumballMachine.turnCrank();
      
              gumballMachine.insertQuarter();
              gumballMachine.turnCrank();
              gumballMachine.insertQuarter();
              gumballMachine.turnCrank();
              gumballMachine.ejectQuarter();
      
              gumballMachine.insertQuarter();
              gumballMachine.insertQuarter();
              gumballMachine.turnCrank();
              gumballMachine.insertQuarter();
              gumballMachine.turnCrank();
              gumballMachine.insertQuarter();
              gumballMachine.turnCrank();
          }
      }

      You insert a quarter
      You turned...
      A gumball comes rolling out the slot...
      You insert a quarter
      Quarter returned
      You turned, but there's no quarter
      You need to pay first
      You insert a quarter
      You turned...
      A gumball comes rolling out the slot...
      You insert a quarter
      You turned...
      A gumball comes rolling out the slot...
      You haven't insert a quarter
      You insert a quarter
      You can't insert another quarter
      You turned...
      A gumball comes rolling out the slot...
      You insert a quarter
      You turned...
      A gumball comes rolling out the slot...
      Oops, out of gumballs
      You can't insert a quarter, the machine is sold out
      You turned, but there are no gumballs
      No gumball dispensed

      9. 策略(Strategy)

      意图

      定义一系列算法,封装每个算法,并使它们可以互换。

      策略模式可以让算法独立于使用它的客户端

      类图

      • Strategy 接口定义了一个算法族,它们都具有 BehaviorInterface() 方法。
      • Context 是使用到该算法族的类,其中的 doSomething() 方法会调用 BehaviorInterface(),setStrategy(in Strategy) 方法可以动态地改变 strategy 对象,也就是说能动态地改变 Context 所使用的算法。

      与状态模式的比较

      状态模式的类图和策略模式一样,并且都是能够动态改变对象的行为。

      但是状态模式是通过状态转移来改变 Context 所组合的 State 对象,而策略模式是通过 Context 本身的决策来改变组合的 Strategy 对象。

      所谓的状态转移,是指 Context 在运行过程中由于一些条件发生改变而使得 State 对象发生改变,注意必须要是在运行过程中。

      状态模式主要是用来解决状态转移的问题,当状态发生转移了,那么 Context 对象就会改变它的行为;而策略模式主要是用来封装一组可以互相替代的算法族,并且可以根据需要动态地去替换 Context 使用的算法。

      实现

      设计一个鸭子,它可以动态地改变叫声。这里的算法族是鸭子的叫声行为。

      public interface QuackBehavior {
          void quack();
      }

      public class Quack implements QuackBehavior {
          @Override
          public void quack() {
              System.out.println("quack!");
          }
      }

      public class Squeak implements QuackBehavior{
          @Override
          public void quack() {
              System.out.println("squeak!");
          }
      }

      public class Duck {
          private QuackBehavior quackBehavior;
      
          public void performQuack() {
              if (quackBehavior != null) {
                  quackBehavior.quack();
              }
          }
      
          public void setQuackBehavior(QuackBehavior quackBehavior) {
              this.quackBehavior = quackBehavior;
          }
      }

      public class Client {
          public static void main(String[] args) {
              Duck duck = new Duck();
              duck.setQuackBehavior(new Squeak());
              duck.performQuack();
              duck.setQuackBehavior(new Quack());
              duck.performQuack();
          }
      }

      squeak!
      quack!

      JDK

      • java.util.Comparator#compare()
      • javax.servlet.http.Httpservlet
      • javax.servlet.Filter#doFilter()

      10. 模板方法(Template Method)

      意图

      定义算法框架,并将一些步骤的实现延迟到子类。

      通过模板方法,子类可以重新定义算法的某些步骤,而不用改变算法的结构。

      类图

      实现

      冲咖啡和冲茶都有类似的流程,但是某些步骤会有点不一样,要求复用那些相同步骤的代码。

      public abstract class CaffeineBeverage {
      
          final void prepareRecipe() {
              boilWater();
              brew();
              pourInCup();
              addCondiments();
          }
      
          abstract void brew();
      
          abstract void addCondiments();
      
          void boilWater() {
              System.out.println("boilWater");
          }
      
          void pourInCup() {
              System.out.println("pourInCup");
          }
      }

      public class Coffee extends CaffeineBeverage{
          @Override
          void brew() {
              System.out.println("Coffee.brew");
          }
      
          @Override
          void addCondiments() {
              System.out.println("Coffee.addCondiments");
          }
      }

      public class Tea extends CaffeineBeverage{
          @Override
          void brew() {
              System.out.println("Tea.brew");
          }
      
          @Override
          void addCondiments() {
              System.out.println("Tea.addCondiments");
          }
      }

      public class Client {
          public static void main(String[] args) {
              CaffeineBeverage caffeineBeverage = new Coffee();
              caffeineBeverage.prepareRecipe();
              System.out.println("-----------");
              caffeineBeverage = new Tea();
              caffeineBeverage.prepareRecipe();
          }
      }

      boilWater
      Coffee.brew
      pourInCup
      Coffee.addCondiments
      -----------
      boilWater
      Tea.brew
      pourInCup
      Tea.addCondiments

      JDK

      • java.util.Collections#sort()
      • java.io.inputStream#skip()
      • java.io.InputStream#read()
      • java.util.AbstractList#indexOf()

      11. 访问者(Visitor)

      意图

      为一个对象结构(比如组合结构)增加新能力。

      类图

      • Visitor:访问者,为每一个 ConcreteElement 声明一个 visit 操作
      • ConcreteVisitor:具体访问者,存储遍历过程中的累计结果
      • ObjectStructure:对象结构,可以是组合结构,或者是一个集合。

      实现

      public interface Element {
          void accept(Visitor visitor);
      }

      class CustomerGroup {
      
          private List<Customer> customers = new ArrayList<>();
      
          void accept(Visitor visitor) {
              for (Customer customer : customers) {
                  customer.accept(visitor);
              }
          }
      
          void addCustomer(Customer customer) {
              customers.add(customer);
          }
      }

      public class Customer implements Element {
      
          private String name;
          private List<Order> orders = new ArrayList<>();
      
          Customer(String name) {
              this.name = name;
          }
      
          String getName() {
              return name;
          }
      
          void addOrder(Order order) {
              orders.add(order);
          }
      
          public void accept(Visitor visitor) {
              visitor.visit(this);
              for (Order order : orders) {
                  order.accept(visitor);
              }
          }
      }

      public class Order implements Element {
      
          private String name;
          private List<Item> items = new ArrayList();
      
          Order(String name) {
              this.name = name;
          }
      
          Order(String name, String itemName) {
              this.name = name;
              this.addItem(new Item(itemName));
          }
      
          String getName() {
              return name;
          }
      
          void addItem(Item item) {
              items.add(item);
          }
      
          public void accept(Visitor visitor) {
              visitor.visit(this);
      
              for (Item item : items) {
                  item.accept(visitor);
              }
          }
      }

      public class Item implements Element {
      
          private String name;
      
          Item(String name) {
              this.name = name;
          }
      
          String getName() {
              return name;
          }
      
          public void accept(Visitor visitor) {
              visitor.visit(this);
          }
      }

      public interface Visitor {
          void visit(Customer customer);
      
          void visit(Order order);
      
          void visit(Item item);
      }

      public class GeneralReport implements Visitor {
      
          private int customersNo;
          private int ordersNo;
          private int itemsNo;
      
          public void visit(Customer customer) {
              System.out.println(customer.getName());
              customersNo++;
          }
      
          public void visit(Order order) {
              System.out.println(order.getName());
              ordersNo++;
          }
      
          public void visit(Item item) {
              System.out.println(item.getName());
              itemsNo++;
          }
      
          public void displayResults() {
              System.out.println("Number of customers: " + customersNo);
              System.out.println("Number of orders:    " + ordersNo);
              System.out.println("Number of items:     " + itemsNo);
          }
      }

      public class Client {
          public static void main(String[] args) {
              Customer customer1 = new Customer("customer1");
              customer1.addOrder(new Order("order1", "item1"));
              customer1.addOrder(new Order("order2", "item1"));
              customer1.addOrder(new Order("order3", "item1"));
      
              Order order = new Order("order_a");
              order.addItem(new Item("item_a1"));
              order.addItem(new Item("item_a2"));
              order.addItem(new Item("item_a3"));
              Customer customer2 = new Customer("customer2");
              customer2.addOrder(order);
      
              CustomerGroup customers = new CustomerGroup();
              customers.addCustomer(customer1);
              customers.addCustomer(customer2);
      
              GeneralReport visitor = new GeneralReport();
              customers.accept(visitor);
              visitor.displayResults();
          }
      }

      customer1
      order1
      item1
      order2
      item1
      order3
      item1
      customer2
      order_a
      item_a1
      item_a2
      item_a3
      Number of customers: 2
      Number of orders:    4
      Number of items:     6

      JDK

      • javax.lang.model.element.Element and javax.lang.model.element.ElementVisitor
      • javax.lang.model.type.TypeMirror and javax.lang.model.type.TypeVisitor

      12. 空对象(Null)

      意图

      使用什么都不做的空对象来替代 NULL。

      一个方法返回 NULL,意味着方法的调用端需要去检查返回值是否是 NULL,这么做会导致非常多的冗余的检查代码。并且如果某一个调用端忘记了做这个检查返回值,而直接使用返回的对象,那么就有可能抛出空指针异常。

      类图

      实现

      public abstract class AbstractOperation {
          abstract void request();
      }

      public class RealOperation extends AbstractOperation {
          @Override
          void request() {
              System.out.println("do something");
          }
      }

      public class NullOperation extends AbstractOperation{
          @Override
          void request() {
              // do nothing
          }
      }

      public class Client {
          public static void main(String[] args) {
              AbstractOperation abstractOperation = func(-1);
              abstractOperation.request();
          }
      
          public static AbstractOperation func(int para) {
              if (para < 0) {
                  return new NullOperation();
              }
              return new RealOperation();
          }
      }

      四、结构型

      1. 适配器(Adapter)

      意图

      把一个类接口转换成另一个用户需要的接口。

      类图

      实现

      鸭子(Duck)和火鸡(Turkey)拥有不同的叫声,Duck 的叫声调用 quack() 方法,而 Turkey 调用 gobble() 方法。

      要求将 Turkey 的 gobble() 方法适配成 Duck 的 quack() 方法,从而让火鸡冒充鸭子!

      public interface Duck {
          void quack();
      }

      public interface Turkey {
          void gobble();
      }

      public class WildTurkey implements Turkey {
          @Override
          public void gobble() {
              System.out.println("gobble!");
          }
      }

      public class TurkeyAdapter implements Duck {
          Turkey turkey;
      
          public TurkeyAdapter(Turkey turkey) {
              this.turkey = turkey;
          }
      
          @Override
          public void quack() {
              turkey.gobble();
          }
      }

      public class Client {
          public static void main(String[] args) {
              Turkey turkey = new WildTurkey();
              Duck duck = new TurkeyAdapter(turkey);
              duck.quack();
          }
      }

      JDK

      • java.util.Arrays#asList()
      • java.util.Collections#list()
      • java.util.Collections#enumeration()
      • javax.xml.bind.annotation.adapters.XMLAdapter

      2. 桥接(Bridge)

      意图

      将抽象与实现分离开来,使它们可以独立变化。

      类图

      • Abstraction:定义抽象类的接口
      • Implementor:定义实现类接口

      实现

      RemoteControl 表示遥控器,指代 Abstraction。

      TV 表示电视,指代 Implementor。

      桥接模式将遥控器和电视分离开来,从而可以独立改变遥控器或者电视的实现。

      public abstract class TV {
          public abstract void on();
      
          public abstract void off();
      
          public abstract void tuneChannel();
      }

      public class Sony extends TV{
          @Override
          public void on() {
              System.out.println("Sony.on()");
          }
      
          @Override
          public void off() {
              System.out.println("Sony.off()");
          }
      
          @Override
          public void tuneChannel() {
              System.out.println("Sony.tuneChannel()");
          }
      }

      public class RCA extends TV{
          @Override
          public void on() {
              System.out.println("RCA.on()");
          }
      
          @Override
          public void off() {
              System.out.println("RCA.off()");
          }
      
          @Override
          public void tuneChannel() {
              System.out.println("RCA.tuneChannel()");
          }
      }

      public abstract class RemoteControl {
          protected TV tv;
      
          public RemoteControl(TV tv) {
              this.tv = tv;
          }
      
          public abstract void on();
      
          public abstract void off();
      
          public abstract void tuneChannel();
      }

      public class ConcreteRemoteControl1 extends RemoteControl {
          public ConcreteRemoteControl1(TV tv) {
              super(tv);
          }
      
          @Override
          public void on() {
              System.out.println("ConcreteRemoteControl1.on()");
              tv.on();
          }
      
          @Override
          public void off() {
              System.out.println("ConcreteRemoteControl1.off()");
              tv.off();
          }
      
          @Override
          public void tuneChannel() {
              System.out.println("ConcreteRemoteControl1.tuneChannel()");
              tv.tuneChannel();
          }
      }

      public class ConcreteRemoteControl2 extends RemoteControl {
          public ConcreteRemoteControl2(TV tv) {
              super(tv);
          }
      
          @Override
          public void on() {
              System.out.println("ConcreteRemoteControl2.on()");
              tv.on();
          }
      
          @Override
          public void off() {
              System.out.println("ConcreteRemoteControl2.off()");
              tv.off();
          }
      
          @Override
          public void tuneChannel() {
              System.out.println("ConcreteRemoteControl2.tuneChannel()");
              tv.tuneChannel();
          }
      }

      public class Client {
          public static void main(String[] args) {
              RemoteControl remoteControl1 = new ConcreteRemoteControl1(new RCA());
              remoteControl1.on();
              remoteControl1.off();
              remoteControl1.tuneChannel();
          }
      }

      JDK

      • AWT (It provides an abstraction layer which Maps onto the native OS the windowing support.)
      • JDBC

      3. 组合(Composite)

      意图

      将对象组合成树形结构来表示“整体/部分”层次关系,允许用户以相同的方式处理单独对象和组合对象。

      类图

      组件(Component)类是组合类(Composite)和叶子类(Leaf)的父类,可以把组合类看成是树的中间节点。

      组合对象拥有一个或者多个组件对象,因此组合对象的操作可以委托给组件对象去处理,而组件对象可以是另一个组合对象或者叶子对象。

      实现

      public abstract class Component {
          protected String name;
      
          public Component(String name) {
              this.name = name;
          }
      
          public void print() {
              print(0);
          }
      
          abstract void print(int level);
      
          abstract public void add(Component component);
      
          abstract public void remove(Component component);
      }

      import java.util.ArrayList;
      import java.util.List;
      
      public class Composite extends Component {
      
          private List<Component> child;
      
          public Composite(String name) {
              super(name);
              child = new ArrayList<>();
          }
      
          @Override
          void print(int level) {
              for (int i = 0; i < level; i++) {
                  System.out.print("--");
              }
              System.out.println("Composite:" + name);
              for (Component component : child) {
                  component.print(level + 1);
              }
          }
      
          @Override
          public void add(Component component) {
              child.add(component);
          }
      
          @Override
          public void remove(Component component) {
              child.remove(component);
          }
      }

      public class Leaf extends Component {
          public Leaf(String name) {
              super(name);
          }
      
          @Override
          void print(int level) {
              for (int i = 0; i < level; i++) {
                  System.out.print("--");
              }
              System.out.println("left:" + name);
          }
      
          @Override
          public void add(Component component) {
              throw new UnsupportedOperationException(); // 牺牲透明性换取单一职责原则,这样就不用考虑是叶子节点还是组合节点
          }
      
          @Override
          public void remove(Component component) {
              throw new UnsupportedOperationException();
          }
      }

      public class Client {
          public static void main(String[] args) {
              Composite root = new Composite("root");
              Component node1 = new Leaf("1");
              Component node2 = new Composite("2");
              Component node3 = new Leaf("3");
              root.add(node1);
              root.add(node2);
              root.add(node3);
              Component node21 = new Leaf("21");
              Component node22 = new Composite("22");
              node2.add(node21);
              node2.add(node22);
              Component node221 = new Leaf("221");
              node22.add(node221);
              root.print();
          }
      }

      Composite:root
      --left:1
      --Composite:2
      ----left:21
      ----Composite:22
      ------left:221
      --left:3

      JDK

      • javax.swing.JComponent#add(Component)
      • java.awt.Container#add(Component)
      • java.util.Map#putAll(Map)
      • java.util.List#addAll(Collection)
      • java.util.Set#addAll(Collection)

      4. 装饰(Decorator)

      意图

      为对象动态添加功能。

      类图

      装饰者(Decorator)和具体组件(ConcreteComponent)都继承自组件(Component),具体组件的方法实现不需要依赖于其它对象,而装饰者组合了一个组件,这样它可以装饰其它装饰者或者具体组件。所谓装饰,就是把这个装饰者套在被装饰上,从而动态扩展被装饰者的功能。装饰者的方法有一部分是自己的,这属于它的功能,然后调用被装饰者的方法实现,从而也保留了被装饰者的功能。可以看到,具体组件应当是装饰层次的最低层,因为只有具体组件的方法实现不需要依赖于其它对象。

      实现

      设计不同种类的饮料,饮料可以添加配料,比如可以添加牛奶,并且支持动态添加新配料。每增加一种配料,该饮料的价格就会增加,要求计算一种饮料的价格。

      下图表示在 DarkRoast 饮料上新增新添加 Mocha 配料,之后又添加了 Whip 配料。DarkRoast 被 Mocha 包裹,Mocha 又被 Whip 包裹。它们都继承自相同父类,都有 cost() 方法,外层类的 cost() 方法调用了内层类的 cost() 方法。

      public interface Beverage {
          double cost();
      }

      public class DarkRoast implements Beverage{
          @Override
          public double cost() {
              return 1;
          }
      }

      public class HouseBlend implements Beverage {
          @Override
          public double cost() {
              return 1;
          }
      }

      public abstract class CondimentDecorator implements Beverage {
          protected Beverage beverage;
      }

      public class Milk extends CondimentDecorator {
      
          public Milk(Beverage beverage) {
              this.beverage = beverage;
          }
      
          @Override
          public double cost() {
              return 1 + beverage.cost();
          }
      }

      public class Mocha extends CondimentDecorator {
      
          public Mocha(Beverage beverage) {
              this.beverage = beverage;
          }
      
          @Override
          public double cost() {
              return 1 + beverage.cost();
          }
      }

      public class Client {
          public static void main(String[] args) {
              Beverage beverage = new HouseBlend();
              beverage = new Mocha(beverage);
              beverage = new Milk(beverage);
              System.out.println(beverage.cost());
          }
      }

      3.0

      设计原则

      类应该对扩展开放,对修改关闭:也就是添加新功能时不需要修改代码。饮料可以动态添加新的配料,而不需要去修改饮料的代码。不可能把所有的类设计成都满足这一原则,应当把该原则应用于最有可能发生改变的地方。

      JDK

      • java.io.BufferedInputStream(InputStream)
      • java.io.DataInputStream(InputStream)
      • java.io.BufferedOutputStream(OutputStream)
      • java.util.zip.ZipOutputStream(OutputStream)
      • java.util.Collections#checkedList|Map|Set|SortedSet|SortedMap

      5. 外观(FaCADe)

      意图

      提供了一个统一的接口,用来访问子系统中的一群接口,从而让子系统更容易使用。

      类图

      实现

      观看电影需要操作很多电器,使用外观模式可以实现一键看电影功能。

      public class SubSystem {
          public void turnOnTV() {
              System.out.println("turnOnTV()");
          }
      
          public void setCD(String cd) {
              System.out.println("setCD( " + cd + " )");
          }
      
          public void starWatching(){
              System.out.println("starWatching()");
          }
      }

      public class Facade {
          private SubSystem subSystem = new SubSystem();
      
          public void watchMovie() {
              subSystem.turnOnTV();
              subSystem.setCD("a movie");
              subSystem.starWatching();
          }
      }

      public class Client {
          public static void main(String[] args) {
              Facade facade = new Facade();
              facade.watchMovie();
          }
      }

      设计原则

      最少知识原则:只和你的密友谈话。也就是客户对象所需要交互的对象应当尽可能少。

      6. 享元(Flyweight)

      意图

      利用共享的方式来支持大量细粒度的对象,这些对象一部分内部状态是相同的。

      类图

      • Flyweight:享元对象
      • IntrinsicState:内部状态,相同的项元对象共享
      • ExtrinsicState:外部状态

      实现

      public interface Flyweight {
          void doOperation(String extrinsicState);
      }

      public class ConcreteFlyweight implements Flyweight {
      
          private String intrinsicState;
      
          public ConcreteFlyweight(String intrinsicState) {
              this.intrinsicState = intrinsicState;
          }
      
          @Override
          public void doOperation(String extrinsicState) {
              System.out.println("Object address: " + System.identityHashCode(this));
              System.out.println("IntrinsicState: " + intrinsicState);
              System.out.println("ExtrinsicState: " + extrinsicState);
          }
      }

      import java.util.HashMap;
      
      public class FlyweightFactory {
      
          private HashMap<String, Flyweight> flyweights = new HashMap<>();
      
          Flyweight getFlyweight(String intrinsicState) {
              if (!flyweights.containsKey(intrinsicState)) {
                  Flyweight flyweight = new ConcreteFlyweight(intrinsicState);
                  flyweights.put(intrinsicState, flyweight);
              }
              return flyweights.get(intrinsicState);
          }
      }

      public class Client {
          public static void main(String[] args) {
              FlyweightFactory factory = new FlyweightFactory();
              Flyweight flyweight1 = factory.getFlyweight("aa");
              Flyweight flyweight2 = factory.getFlyweight("aa");
              flyweight1.doOperation("x");
              flyweight2.doOperation("y");
          }
      }

      Object address: 1163157884
      IntrinsicState: aa
      ExtrinsicState: x
      Object address: 1163157884
      IntrinsicState: aa
      ExtrinsicState: y

      JDK

      Java 利用缓存来加速大量小对象的访问时间。

      • java.lang.Integer#valueOf(int)
      • java.lang.Boolean#valueOf(boolean)
      • java.lang.Byte#valueOf(byte)
      • java.lang.Character#valueOf(char)

      7. 代理(Proxy)

      意图

      控制对其它对象的方法。

      类图

      代理有以下四类:

      • 远程代理(Remote Proxy):控制对远程对象(不同地址空间)的访问,它负责将请求及其参数进行编码,并向不同地址空间中的对象发送已经编码的请求。
      • 虚拟代理(virtual Proxy):根据需要创建开销很大的对象,它可以缓存实体的附加信息,以便延迟对它的访问,例如在网站加载一个很大图片时,不能马上完成,可以用虚拟代理缓存图片的大小信息,然后生成一张临时图片代替原始图片。
      • 保护代理(Protection Proxy):按权限控制对象的访问,它负责检查调用者是否具有实现一个请求所必须的访问权限。
      • 智能代理(Smart Reference:取代了简单的指针,它在访问对象时执行一些附加操作:记录对象的引用次数,比如智能智能;当第一次引用一个持久化对象时,将它装入内存;在访问一个实际对象前,检查是否已经锁定了它,以确保其它对象不能改变它。

      实现

      以下是一个虚拟代理的实现,模拟了图片延迟加载的情况下使用与图片大小相等的临时内容去替换原始图片,直到图片加载完成才将图片显示出来。

      public interface Image {
          void showImage();
      }

      public class HighResolutionImage implements Image {
      
          private URL imageURL;
          private long startTime;
          private int height;
          private int width;
      
          public int getHeight() {
              return height;
          }
      
          public int getWidth() {
              return width;
          }
      
          public HighResolutionImage(URL imageURL) {
              this.imageURL = imageURL;
              this.startTime = System.currentTimeMillis();
              this.width = 600;
              this.height = 600;
          }
      
          public boolean isLoad() {
              // 模拟图片加载,延迟 3s 加载完成
              long endTime = System.currentTimeMillis();
              return endTime - startTime > 3000;
          }
      
          @Override
          public void showImage() {
              System.out.println("Real Image: " + imageURL);
          }
      }

      public class ImageProxy implements Image {
          private HighResolutionImage highResolutionImage;
      
          public ImageProxy(HighResolutionImage highResolutionImage) {
              this.highResolutionImage = highResolutionImage;
          }
      
          @Override
          public void showImage() {
              while (!highResolutionImage.isLoad()) {
                  try {
                      System.out.println("Temp Image: " + highResolutionImage.getWidth() + " " + highResolutionImage.getHeight());
                      Thread.sleep(100);
                  } catch (InterruptedException e) {
                      e.printStackTrace();
                  }
              }
              highResolutionImage.showImage();
          }
      
      }

      public class ImageViewer {
          public static void main(String[] args) throws Exception {
              String image = "http://image.jpg";
              URL url = new URL(image);
              HighResolutionImage highResolutionImage = new HighResolutionImage(url);
              ImageProxy imageProxy = new ImageProxy(highResolutionImage);
              imageProxy.showImage();
          }
      }

      JDK

      • java.lang.reflect.Proxy
      • RMI

      参考资料

      • 弗里曼. Head First 设计模式 [M]. 中国电力出版社, 2007.
      • Gamma E. 设计模式: 可复用面向对象软件的基础 [M]. 机械工业出版社, 2007.
      • Bloch J. Effective java[M]. Addison-Wesley Professional, 2017.
      • Design Patterns
      • Design patterns implemented in Java
      • The breakdown of design patterns in JDK

      相关阅读

      程序设计模式————编程模式

      设计模式的分类 创建型模式&#xff0c;共五种&#xff1a;工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。 结构型模式

      PHP设计模式之门面模式(Facade)代码实例大全(16)

      目的 门面模式的最初目的并不是为了避免让你阅读复杂的 A

      Head First设计模式(中文版)PDF

      https://pan.baidu.com/s/1YGPvwmd-nyBpG5qD2NJlOQ

      【设计模式】最常用的设计模式之一的观察者模式

      以下是之前做的“产品详情页”的长截图,这里讲解一下这个页面与“观察者模式”的关系:在活动季,底部的“开始预订按钮”会变成“秒杀

      设计模式(一):策略模式

      设计模式(一):策略模式 本文将以一个小Demo及其新需求来分析使用策略模式的好处。设计模式简述:设计模式:1.设计模式是人们在面对同类

      分享到:

      IT相关

      程序相关

      推荐文章

      热门文章

      东北老女人嫖老头视频_无遮挡H肉动漫视频在线观看_欧美牲交a欧美牲交aⅴ另类_狼人乱码无限2021芒果