设计模式

发表于 更新于

概览

  1. 创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式

  2. 结构型模式，共七种：适配器模式、装饰者模式、代理模式、外观模式、桥接模式、组合模式、享元模式。

  3. 行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

还有两类：并发型模式和线程池模式。

原则：六大原则

总原则－开闭原则

对扩展开放，对修改封闭。在程序需要进行拓展的时候，不能去修改原有的代码，而是要扩展原有代码，实现一个热插拔的效果。所以一句话概括就是：为了使程序的扩展性好，易于维护和升级。
想要达到这样的效果，需要使用接口和抽象类等。

  1. 单一职责原则

不要存在多于一个导致类变更的原因，也就是说每个类应该实现单一的职责，否则就应该把类拆分。

  1. 里氏替换原则（Liskov Substitution Principle）

任何基类可以出现的地方，子类一定可以出现。里氏替换原则是继承复用的基石，只有当衍生类可以替换基类，软件单位的功能不受到影响时，基类才能真正被复用，而衍生类也能够在基类的基础上增加新的行为。
里氏代换原则是对“开-闭”原则的补充。实现“开闭”原则的关键步骤就是抽象化。而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。里氏替换原则中，子类对父类的方法尽量不要重写和重载。因为父类代表了定义好的结构，通过这个规范的接口与外界交互，子类不应该随便破坏它。

  1. 依赖倒转原则（Dependence Inversion Principle）

面向接口编程，依赖于抽象而不依赖于具体。写代码时用到具体类时，不与具体类交互，而与具体类的上层接口交互。

  1. 接口隔离原则（Interface Segregation Principle）

每个接口中不存在子类用不到却必须实现的方法，如果不然，就要将接口拆分。使用多个隔离的接口，比使用单个接口（多个接口方法集合到一个的接口）要好。

  1. 迪米特法则（最少知道原则）（Demeter Principle）

一个类对自己依赖的类知道的越少越好。无论被依赖的类多么复杂，都应该将逻辑封装在方法的内部，通过public方法提供给外部。这样当被依赖的类变化时，才能最小的影响该类。

最少知道原则的另一个表达方式是：只与直接的朋友通信。类之间只要有耦合关系，就叫朋友关系。耦合分为依赖、关联、聚合、组合等。我们称出现为成员变量、方法参数、方法返回值中的类为直接朋友。局部变量、临时变量则不是直接的朋友。我们要求陌生的类不要作为局部变量出现在类中。

  1. 合成复用原则（Composite Reuse Principle）

尽量首先使用合成/聚合的方式，而不是使用继承。

创建型模式

  1. 工厂方法模式

定义一个用于创建对象的接口，让子类决定实例化哪一个类，工厂方法使一个类的实例化延迟到其子类。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
interface IProduct{
    void ProductMethod();
}
interface IFactory{
    IProduct CreateProduct();
}
class Product : IProduct{
    public void ProductMethod(){
        Console.WriteLine("Product");
    }
}
class Factory : IFactory{
    public IProduct CreateProduct(){
        return new Product();
    }
}

public static void Main(string[] args){
    IFactory factory = new Factory();
    IProduct product = factory.CreateProduct();
    product.ProductMethod();
}
  1. 抽象工厂模式

为创建一组相关或相互依赖的对象提供一个接口，而且无需指定他们的具体类。
抽象工厂模式是工厂方法模式的升级版本，他用来创建一组相关或者相互依赖的对象。他与工厂方法模式的区别就在于，工厂方法模式针对的是一个产品等级结构；而抽象工厂模式则是针对的多个产品等级结构。在编程中，通常一个产品结构，表现为一个接口或者抽象类，也就是说，工厂方法模式提供的所有产品都是衍生自同一个接口或抽象类，而抽象工厂模式所提供的产品则是衍生自不同的接口或抽象类。

在抽象工厂模式中，有一个产品族的概念：

所谓的产品族，是指位于不同产品等级结构中功能相关联的产品组成的家族。抽象工厂模式所提供的一系列产品就组成一个产品族；而工厂方法提供的一系列产品称为一个等级结构。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
interface IProduct1 {
    void Show();
}
interface IProduct2 {
    void Show();
}
interface IFactory2 {
    IProduct1 CreateProduct1();
    IProduct2 CreateProduct2();
}
class Product1 : IProduct1 {
    public void Show() {
        Console.WriteLine("这是1型产品");
    }
}
class Product2 : IProduct2 {
    public void Show() {
        Console.WriteLine("这是2型产品");
    }
}
class Factory2 : IFactory2 {
    public IProduct1 CreateProduct1() {
        return new Product1();
    }
    public IProduct2 CreateProduct2() {
        return new Product2();
    }
}
public static void Main() {
    IFactory2 factory = new Factory2();
    factory.CreateProduct1().Show();
    factory.CreateProduct2().Show();
}
  1. 单例模式

确保一个类只有一个实例，而且自行实例化并向整个系统提供这个实例
要素：

  1. 私有的构造方法
  2. 指向自己实例的私有静态引用
  3. 以自己实例为返回值的静态的公有的方法

根据实例化对象时机的不同分为两种：一种是饿汉式单例，一种是懒汉式单例。
饿汉式单例在单例类被加载时候，就实例化一个对象交给自己的引用：

1
2
3
4
5
6
7
public class Singleton {
    private static readonly Singleton singleton = new Singleton();
    private Singleton(){}
    public static Singleton GetInstance(){
        return singleton;
    }
}

懒汉式在调用取得实例方法的时候才会实例化对象；

1
2
3
4
5
6
7
8
9
10
11
public class Singleton {
    private static Singleton singleton;
    private Singleton(){}
    
    public static Singleton getInstance(){
        if(singleton==null){
            singleton = new Singleton();
        }
        return singleton;
    }
}

优点：

  1. 在内存中只有一个对象，节省内存空间。
  2. 避免频繁的创建销毁对象，可以提高性能。
  3. 避免对共享资源的多重占用。
  4. 可以全局访问。

    1. 建造者模式

      将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

      四个要素

      1. 产品类：一般是一个较为复杂的对象，也就是说创建对象的过程比较复杂，一般会有比较多的代码量。在本类图中，产品类是一个具体的类，而非抽象类。实际编程中，产品类可以是由一个抽象类与它的不同实现组成，也可以是由多个抽象类与他们的实现组成。
      2. 抽象建造者：引入抽象建造者的目的，是为了将建造的具体过程交与它的子类来实现。这样更容易扩展。一般至少会有两个抽象方法，一个用来建造产品，一个是用来返回产品。
      3. 建造者：实现抽象类的所有未实现的方法，具体来说一般是两项任务：组建产品；返回组建好的产品。
      4. 导演类：负责调用适当的建造者来组建产品，导演类一般不与产品类发生依赖关系，与导演类直接交互的是建造者类。一般来说，导演类被用来封装程序中易变的部分。

      优点

      1. 建造者模式的封装性很好。使用建造者模式可以有效的封装变化，在使用建造者模式的场景中，一般产品类和建造者类是比较稳定的，因此，将主要的业务逻辑封装在导演类中对整体而言可以取得比较好的稳定性。
      2. 建造者模式很容易进行扩展。如果有新的需求，通过实现一个新的建造者类就可以完成，基本上不用修改之前已经测试通过的代码，因此也就不会对原有功能引入风险。

      建造者模式与工厂模式的区别

      建造者模式与工厂模式是极为相似的，总体上，建造者模式仅仅只比工厂模式多了一个“导演类”的角色。在建造者模式的类图中，假如把这个导演类看做是最终调用的客户端，那么图中剩余的部分就可以看作是一个简单的工厂模式了。

      与工厂模式相比，建造者模式一般用来创建更为复杂的对象，因为对象的创建过程更为复杂，因此将对象的创建过程独立出来组成一个新的类——导演类。也就是说，工厂模式是将对象的全部创建过程封装在工厂类中，由工厂类向客户端提供最终的产品；而建造者模式中，建造者类一般只提供产品类中各个组件的建造，而将具体建造过程交付给导演类。由导演类负责将各个组件按照特定的规则组建为产品，然后将组建好的产品交付给客户端。

总结

建造者模式与工厂模式类似，他们都是建造者模式，适用的场景也很相似。一般来说，如果产品的建造很复杂，那么请用工厂模式；如果产品的建造更复杂，那么请用建造者模式。

    1. 原型模式

      用原型实例指定创建对象的种类，并通过拷贝这些原型创建新的对象。

      原型模式主要用于对象的复制，它的核心是就是类图中的原型类Prototype。Prototype类需要具备以下两个条件：

      实现Cloneable接口。在java语言有一个Cloneable接口，它的作用只有一个，就是在运行时通知虚拟机可以安全地在实现了此接口的类上使用clone方法。在java虚拟机中，只有实现了这个接口的类才可以被拷贝，否则在运行时会抛出CloneNotSupportedException异常。
      重写Object类中的clone方法。Java中，所有类的父类都是Object类，Object类中有一个clone方法，作用是返回对象的一个拷贝，但是其作用域protected类型的，一般的类无法调用，因此，Prototype类需要将clone方法的作用域修改为public类型。
      原型模式是一种比较简单的模式，也非常容易理解，实现一个接口，重写一个方法即完成了原型模式。在实际应用中，原型模式很少单独出现。经常与其他模式混用，他的原型类Prototype也常用抽象类来替代。

      public class Prototype : Cloneable {

      public Prototype clone(){
    Prototype prototype = null;
    try{
        prototype = (Prototype)super.clone();
    }catch(Exception e){
    }
    return prototype; 
}

      }

      public class ConcretePrototype : Prototype{

      public void show(){
    Console.WriteLine("原型模式实现类");
}

      }

      public static void Main(String[] args){

      ConcretePrototype cp = new ConcretePrototype();
for(int i=0; i< 10; i++){
    ConcretePrototype clonecp = (ConcretePrototype)cp.clone();
    clonecp.show();
}

      }

      原型模式的优点及适用场景

      使用原型模式创建对象比直接new一个对象在性能上要好的多，因为Object类的clone方法是一个本地方法，它直接操作内存中的二进制流，特别是复制大对象时，性能的差别非常明显。

      使用原型模式的另一个好处是简化对象的创建，使得创建对象就像我们在编辑文档时的复制粘贴一样简单。

      因为以上优点，所以在需要重复地创建相似对象时可以考虑使用原型模式。比如需要在一个循环体内创建对象，假如对象创建过程比较复杂或者循环次数很多的话，使用原型模式不但可以简化创建过程，而且可以使系统的整体性能提高很多。

      原型模式的注意事项

      使用原型模式复制对象不会调用类的构造方法。因为对象的复制是通过调用Object类的clone方法来完成的，它直接在内存中复制数据，因此不会调用到类的构造方法。不但构造方法中的代码不会执行，甚至连访问权限都对原型模式无效。还记得单例模式吗？单例模式中，只要将构造方法的访问权限设置为private型，就可以实现单例。但是clone方法直接无视构造方法的权限，所以，单例模式与原型模式是冲突的，在使用时要特别注意。
      深拷贝与浅拷贝。Object类的clone方法只会拷贝对象中的基本的数据类型，对于数组、容器对象、引用对象等都不会拷贝，这就是浅拷贝。如果要实现深拷贝，必须将原型模式中的数组、容器对象、引用对象等另行拷贝。

结构型模式

    1. 适配器模式

      作为两个不兼容的接口之间的桥梁。这种类型的设计模式属于结构型模式，它结合了两个独立接口的功能。

      这种模式涉及到一个单一的类，该类负责加入独立的或不兼容的接口功能。举个真实的例子，读卡器是作为内存卡和笔记本之间的适配器。您将内存卡插入读卡器，再将读卡器插入笔记本，这样就可以通过笔记本来读取内存卡。

      我们通过下面的实例来演示适配器模式的使用。其中，音频播放器设备只能播放 mp3 文件，通过使用一个更高级的音频播放器来播放 vlc 和 mp4 文件。

      意图：将一个类的接口转换成客户希望的另外一个接口。适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。
      主要解决：主要解决在软件系统中，常常要将一些”现存的对象”放到新的环境中，而新环境要求的接口是现对象不能满足的。
      何时使用： 1、系统需要使用现有的类，而此类的接口不符合系统的需要。 2、想要建立一个可以重复使用的类，用于与一些彼此之间没有太大关联的一些类，包括一些可能在将来引进的类一起工作，这些源类不一定有一致的接口。 3、通过接口转换，将一个类插入另一个类系中。（比如老虎和飞禽，现在多了一个飞虎，在不增加实体的需求下，增加一个适配器，在里面包容一个虎对象，实现飞的接口。）
      如何解决：继承或依赖（推荐）。
      关键代码：适配器继承或依赖已有的对象，实现想要的目标接口。

      应用实例：

      1、美国电器 110V，中国 220V，就要有一个适配器将 110V 转化为 220V。
      2、JAVA JDK 1.1 提供了 Enumeration 接口，而在 1.2 中提供了 Iterator 接口，想要使用 1.2 的 JDK，则要将以前系统的 Enumeration 接口转化为 Iterator 接口，这时就需要适配器模式。
      3、在 LINUX 上运行 WINDOWS 程序。
      4、JAVA 中的 jdbc。

      优点：

      1、可以让任何两个没有关联的类一起运行。
      2、提高了类的复用。
      3、增加了类的透明度。 4、灵活性好。

      缺点：

      1、过多地使用适配器，会让系统非常零乱，不易整体进行把握。比如，明明看到调用的是 A 接口，其实内部被适配成了 B 接口的实现，一个系统如果太多出现这种情况，无异于一场灾难。因此如果不是很有必要，可以不使用适配器，而是直接对系统进行重构。
      2.由于 JAVA 至多继承一个类，所以至多只能适配一个适配者类，而且目标类必须是抽象类。

      使用场景：有动机地修改一个正常运行的系统的接口，这时应该考虑使用适配器模式。

      步骤 1
      为媒体播放器和更高级的媒体播放器创建接口。

      MediaPlayer.java

      public interface MediaPlayer {

      public void play(String audioType, String fileName);

      }

      AdvancedMediaPlayer.java

      public interface AdvancedMediaPlayer { 

      public void playVlc(String fileName);
public void playMp4(String fileName);

      }

      步骤 2
      创建实现了 AdvancedMediaPlayer 接口的实体类。

      VlcPlayer.java

      public class VlcPlayer implements AdvancedMediaPlayer{

      @Override
public void playVlc(String fileName) {
    System.out.println("Playing vlc file. Name: "+ fileName);      
}

@Override
public void playMp4(String fileName) {
    //什么也不做
}

      }

      Mp4Player.java

      public class Mp4Player implements AdvancedMediaPlayer{

      @Override
public void playVlc(String fileName) {
    //什么也不做
}

@Override
public void playMp4(String fileName) {
    System.out.println("Playing mp4 file. Name: "+ fileName);      
}

      }

      步骤 3
      创建实现了 MediaPlayer 接口的适配器类。

      MediaAdapter.java

      public class MediaAdapter implements MediaPlayer {
      AdvancedMediaPlayer advancedMusicPlayer;
      public MediaAdapter(String audioType){

      if(audioType.equalsIgnoreCase("vlc") ){
    advancedMusicPlayer = new VlcPlayer();       
} else if (audioType.equalsIgnoreCase("mp4")){
    advancedMusicPlayer = new Mp4Player();
}

      }
      @Override
      public void play(String audioType, String fileName) {

      if(audioType.equalsIgnoreCase("vlc")){
    advancedMusicPlayer.playVlc(fileName);
}else if(audioType.equalsIgnoreCase("mp4")){
    advancedMusicPlayer.playMp4(fileName);
}

      }
      }

      步骤 4
      创建实现了 MediaPlayer 接口的实体类。

      AudioPlayer.java

      public class AudioPlayer implements MediaPlayer {

      MediaAdapter mediaAdapter; 

@Override
public void play(String audioType, String fileName) {    
    //播放 mp3 音乐文件的内置支持
    if(audioType.equalsIgnoreCase("mp3")){
        System.out.println("Playing mp3 file. Name: "+ fileName);         
    } 
    //mediaAdapter 提供了播放其他文件格式的支持
    else if(audioType.equalsIgnoreCase("vlc") || audioType.equalsIgnoreCase("mp4")){
        mediaAdapter = new MediaAdapter(audioType);
        mediaAdapter.play(audioType, fileName);
    }
    else{
        System.out.println("Invalid media. "+audioType + " format not supported");
    }
}

      }

      步骤 5
      使用 AudioPlayer 来播放不同类型的音频格式。

      AdapterPatternDemo.java

      public class AdapterPatternDemo {

      public static void main(String[] args) {
    AudioPlayer audioPlayer = new AudioPlayer();
    audioPlayer.play("mp3", "beyond the horizon.mp3");
    audioPlayer.play("mp4", "alone.mp4");
    audioPlayer.play("vlc", "far far away.vlc");
    audioPlayer.play("avi", "mind me.avi");
}

      }

      步骤 6
      执行程序，输出结果：

      Playing mp3 file. Name: beyond the horizon.mp3
      Playing mp4 file. Name: alone.mp4
      Playing vlc file. Name: far far away.vlc
      Invalid media. avi format not supported

    1. 装饰者模式

      Decorator模式（别名Wrapper）：动态将职责附加到对象上，若要扩展功能，装饰者提供了比继承更具弹性的代替方案。
      意图：

      动态地给一个对象添加一些额外的职责。就增加功能来说，Decorator模式相比生成子类更为灵活。

      设计原则：

      1. 多用组合，少用继承。利用继承设计子类的行为，是在编译时静态决定的，而且所有的子类都会继承到相同的行为。然而，如果能够利用组合的做法扩展对象的行为，就可以在运行时动态地进行扩展。
      2. 类应设计的对扩展开放，对修改关闭。

      要点：

      1． 装饰者和被装饰对象有相同的超类型。
      2． 可以用一个或多个装饰者包装一个对象。
      3． 装饰者可以在所委托被装饰者的行为之前或之后，加上自己的行为，以达到特定的目的。
      4． 对象可以在任何时候被装饰，所以可以在运行时动态的，不限量的用你喜欢的装饰者来装饰对象。
      5． 装饰模式中使用继承的关键是想达到装饰者和被装饰对象的类型匹配，而不是获得其行为。
      6． 装饰者一般对组件的客户是透明的，除非客户程序依赖于组件的具体类型。在实际项目中可以根据需要为装饰者添加新的行为，做到“半透明”装饰者。
      7． 适配器模式的用意是改变对象的接口而不一定改变对象的性能，而装饰模式的用意是保持接口并增加对象的职责。

      Component：
      定义一个对象接口，可以给这些对象动态地添加职责。

      public interface Component {

      void operation();

      }

      Concrete Component：
      定义一个对象，可以给这个对象添加一些职责。

      public class ConcreteComponent implements Component{

      public void operation() {
    // Write your code here
}

      }

Decorator：

维持一个指向Component对象的引用，并定义一个与 Component接口一致的接口。

    public class Decorator implements Component {
        public Decorator(Component component) {
            this.component = component;
        }
        public void operation() {
            component.operation();
        }
        private Component component;
    }

Concrete Decorator：
在Concrete Component的行为之前或之后，加上自己的行为，以“贴上”附加的职责。

    public class ConcreteDecorator extends Decorator {
        public void operation() {
            //addBehavior也可以在前面
            super.operation();
            addBehavior();
        }
        private void addBehavior() {
            //your code
        }
    }

适用性：以下情况使用Decorator模式

    1. 需要扩展一个类的功能，或给一个类添加附加职责。
    2. 需要动态的给一个对象添加功能，这些功能可以再动态的撤销。
    3. 需要增加由一些基本功能的排列组合而产生的非常大量的功能，从而使继承关系变的不现实。
    4. 当不能采用生成子类的方法进行扩充时。一种情况是，可能有大量独立的扩展，为支持每一种组合将产生大量的子类，使得子类数目呈爆炸性增长。另一种情况可能是因为类定义被隐藏，或类定义不能用于生成子类。

优点：

    1. Decorator模式与继承关系的目的都是要扩展对象的功能，但是Decorator可以提供比继承更多的灵活性。
    2. 通过使用不同的具体装饰类以及这些装饰类的排列组合，设计师可以创造出很多不同行为的组合。

缺点：

    1. 这种比继承更加灵活机动的特性，也同时意味着更加多的复杂性。
    2. 装饰模式会导致设计中出现许多小类，如果过度使用，会使程序变得很复杂。
    3. 装饰模式是针对抽象组件（Component）类型编程。但是，如果你要针对具体组件编程时，就应该重新思考你的应用架构，以及装饰者是否合适。当然也可以改变Component接口，增加新的公开的行为，实现“半透明”的装饰者模式。在实际项目中要做出最佳选择。

编写一个装饰者把所有的输入流内的大写字符转化成小写字符：

    import java.io.FilterInputStream;
    import java.io.IOException;
    import java.io.InputStream;
    public class LowerCaseInputStream extends FilterInputStream {
        protected LowerCaseInputStream(InputStream in) {
            super(in);
        }
        @Override
        public int read() throws IOException {
            int c = super.read();
            return (c == -1 ? c : Character.toLowerCase((char) c));
        }
        @Override
        public int read(byte[] b, int offset, int len) throws IOException {
            int result = super.read(b, offset, len);
            for (int i = offset; i < offset + result; i++) {
                b[i] = (byte) Character.toLowerCase((char) b[i]);
            }
            return result;
        }
    }

测试我们的装饰者类：

    import java.io.*;
    public class InputTest {
        public static void main(String[] args) throws IOException {
            int c;
            try {
                InputStream in = new LowerCaseInputStream(new BufferedInputStream(new FileInputStream("D:\\test.txt")));
                while ((c = in.read()) >= 0) {
                    System.out.print((char) c);
                }
                in.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    1. 代理模式
    1. 外观模式
    1. 桥接模式
    1. 组合模式
    1. 享元模式

行为型模式

    1. 策略模式
    1. 模板方法模式

    1. 观察者模式

      当对象间存在一对多关系时，则使用观察者模式（Observer Pattern）。比如，当一个对象被修改时，则会自动通知它的依赖对象。观察者模式属于行为型模式。

      意图：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。
      主要解决：一个对象状态改变给其他对象通知的问题，而且要考虑到易用和低耦合，保证高度的协作。
      何时使用：一个对象（目标对象）的状态发生改变，所有的依赖对象（观察者对象）都将得到通知，进行广播通知。
      如何解决：使用面向对象技术，可以将这种依赖关系弱化。
      关键代码：在抽象类里有一个 ArrayList 存放观察者们。
      应用实例： 1、拍卖的时候，拍卖师观察最高标价，然后通知给其他竞价者竞价。 2、西游记里面悟空请求菩萨降服红孩儿，菩萨洒了一地水招来一个老乌龟，这个乌龟就是观察者，他观察菩萨洒水这个动作。

      优点：

      1. 观察者和被观察者是抽象耦合的。
      2. 建立一套触发机制。

      缺点：

      1. 如果一个被观察者对象有很多的直接和间接的观察者的话，将所有的观察者都通知到会花费很多时间。
      2. 如果在观察者和观察目标之间有循环依赖的话，观察目标会触发它们之间进行循环调用，可能导致系统崩溃。
      3. 观察者模式没有相应的机制让观察者知道所观察的目标对象是怎么发生变化的，而仅仅只是知道观察目标发生了变化。

      使用场景：

      1. 一个抽象模型有两个方面，其中一个方面依赖于另一个方面。将这些方面封装在独立的对象中使它们可以各自独立地改变和复用。
      2. 一个对象的改变将导致其他一个或多个对象也发生改变，而不知道具体有多少对象将发生改变，可以降低对象之间的耦合度。
      3. 一个对象必须通知其他对象，而并不知道这些对象是谁。
      4. 需要在系统中创建一个触发链，A对象的行为将影响B对象，B对象的行为将影响C对象……，可以使用观察者模式创建一种链式触发机制。

      Subject.java

      import java.util.ArrayList;
      import java.util.List;
      public class Subject {

      private List<Observer> observers = new ArrayList<Observer>();
private int state;
public int getState() {
    return state;
}
public void setState(int state) {
    this.state = state;
    notifyAllObservers();
}
public void attach(Observer observer){
    observers.add(observer);      
}
public void notifyAllObservers(){
    for (Observer observer : observers) {
        observer.update();
    }
}

      }

      Observer.java

      public abstract class Observer {

      protected Subject subject;
public abstract void update();

      }

      创建实体观察者类
      BinaryObserver.java

      public class BinaryObserver extends Observer{

      public BinaryObserver(Subject subject){
    this.subject = subject;
    this.subject.attach(this);
}
@Override
public void update() {
    System.out.println( "Binary String: " + Integer.toBinaryString( subject.getState() ) ); 
}

      }

      OctalObserver.java

      public class OctalObserver extends Observer{

      public OctalObserver(Subject subject){
    this.subject = subject;
    this.subject.attach(this);
}
@Override
public void update() {
    System.out.println( "Octal String: " + Integer.toOctalString( subject.getState() ) ); 
}

      }

      HexaObserver.java

      public class HexaObserver extends Observer{

      public HexaObserver(Subject subject){
    this.subject = subject;
    this.subject.attach(this);
}
@Override
public void update() {
    System.out.println( "Hex String: " + Integer.toHexString( subject.getState() ).toUpperCase() ); 
}

      }

      使用 Subject 和实体观察者对象

      ObserverPatternDemo.java

      public class ObserverPatternDemo {

      public static void main(String[] args) {
    Subject subject = new Subject();
    new HexaObserver(subject);
    new OctalObserver(subject);
    new BinaryObserver(subject);
    System.out.println("First state change: 15");   
    subject.setState(15);
    System.out.println("Second state change: 10");  
    subject.setState(10);
}

      }

      执行程序，输出结果：

      First state change: 15
      Hex String: F
      Octal String: 17
      Binary String: 1111
      Second state change: 10
      Hex String: A
      Octal String: 12
      Binary String: 1010

    1. 迭代子模式

    1. 责任链模式

      为请求创建了一个接收者对象的链。这种模式给予请求的类型，对请求的发送者和接收者进行解耦。这种类型的设计模式属于行为型模式。

      在这种模式中，通常每个接收者都包含对另一个接收者的引用。如果一个对象不能处理该请求，那么它会把相同的请求传给下一个接收者，依此类推。

      意图：避免请求发送者与接收者耦合在一起，让多个对象都有可能接收请求，将这些对象连接成一条链，并且沿着这条链传递请求，直到有对象处理它为止。

      主要解决：职责链上的处理者负责处理请求，客户只需要将请求发送到职责链上即可，无须关心请求的处理细节和请求的传递，所以职责链将请求的发送者和请求的处理者解耦了。

      何时使用：在处理消息的时候以过滤很多道。

      如何解决：拦截的类都实现统一接口。

      关键代码：Handler 里面聚合它自己，在 HandlerRequest 里判断是否合适，如果没达到条件则向下传递，向谁传递之前 set 进去。

      应用实例： 1、红楼梦中的”击鼓传花”。 2、JS 中的事件冒泡。 3、JAVA WEB 中 Apache Tomcat 对 Encoding 的处理，Struts2 的拦截器，jsp servlet 的 Filter。

      优点： 1、降低耦合度。它将请求的发送者和接收者解耦。 2、简化了对象。使得对象不需要知道链的结构。 3、增强给对象指派职责的灵活性。通过改变链内的成员或者调动它们的次序，允许动态地新增或者删除责任。 4、增加新的请求处理类很方便。

      缺点： 1、不能保证请求一定被接收。 2、系统性能将受到一定影响，而且在进行代码调试时不太方便，可能会造成循环调用。 3、可能不容易观察运行时的特征，有碍于除错。

      使用场景： 1、有多个对象可以处理同一个请求，具体哪个对象处理该请求由运行时刻自动确定。 2、在不明确指定接收者的情况下，向多个对象中的一个提交一个请求。 3、可动态指定一组对象处理请求。

      创建抽象的记录器类。
      AbstractLogger.java

      public abstract class AbstractLogger {

      public static int INFO = 1;
public static int DEBUG = 2;
public static int ERROR = 3;

protected int level;

//责任链中的下一个元素
protected AbstractLogger nextLogger;

public void setNextLogger(AbstractLogger nextLogger){
    this.nextLogger = nextLogger;
}

public void logMessage(int level, String message){
    if(this.level <= level){
        write(message);
    }
    if(nextLogger !=null){
        nextLogger.logMessage(level, message);
    }
}
abstract protected void write(String message);

      }

      创建扩展了该记录器类的实体类。
      ConsoleLogger.java

      public class ConsoleLogger extends AbstractLogger {

      public ConsoleLogger(int level){
    this.level = level;
}

@Override
protected void write(String message) {    
    System.out.println("Standard Console::Logger: " + message);
}

      }

      ErrorLogger.java

      public class ErrorLogger extends AbstractLogger {

      public ErrorLogger(int level){
    this.level = level;
}

@Override
protected void write(String message) {    
    System.out.println("Error Console::Logger: " + message);
}

      }

      FileLogger.java

      public class FileLogger extends AbstractLogger {

      public FileLogger(int level){
    this.level = level;
}
@Override
protected void write(String message) {    
    System.out.println("File::Logger: " + message);
}

      }

      创建不同类型的记录器。赋予它们不同的错误级别，并在每个记录器中设置下一个记录器。每个记录器中的下一个记录器代表的是链的一部分。
      ChainPatternDemo.java

      public class ChainPatternDemo {

      private static AbstractLogger getChainOfLoggers(){
    AbstractLogger errorLogger = new ErrorLogger(AbstractLogger.ERROR);
    AbstractLogger fileLogger = new FileLogger(AbstractLogger.DEBUG);
    AbstractLogger consoleLogger = new ConsoleLogger(AbstractLogger.INFO);
    errorLogger.setNextLogger(fileLogger);
    fileLogger.setNextLogger(consoleLogger);
    return errorLogger;  
}
public static void main(String[] args) {
    AbstractLogger loggerChain = getChainOfLoggers();
    loggerChain.logMessage(AbstractLogger.INFO, "This is an information.");
    loggerChain.logMessage(AbstractLogger.DEBUG, "This is a debug level information.");
    loggerChain.logMessage(AbstractLogger.ERROR, "This is an error information.");
}

      }

      执行程序，输出结果：

      Standard Console::Logger: This is an information.
      File::Logger: This is a debug level information.
      Standard Console::Logger: This is a debug level information.
      Error Console::Logger: This is an error information.
      File::Logger: This is an error information.
      Standard Console::Logger: This is an error information.

    1. 命令模式
    1. 备忘录模式
    1. 状态模式
    1. 访问者模式
    1. 中介者模式
    1. 解释器模式