Lzone

always be doing

0%

设计模式

发表于 更新于 分类于
本文字数： 36k 阅读时长 ≈ 33 分钟
《图解设计模式》图书总结

设计模式概述

设计模式的分类

20180820002505651 (761×914) (csdn.net)

设计模式的六大原则

  1. 开闭原则（Open Close Principle）

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

    详细介绍：https://blog.csdn.net/lovelion/article/details/7537584

  2. 里氏代换原则（Liskov Substitution Principle）

    里氏代换原则(Liskov Substitution Principle LSP)面向对象设计的基本原则之一。 里氏代换原则中说，任何基类可以出现的地方，子类一定可以出现。 LSP是继承复用的基石，只有当衍生类可以替换掉基类，软件单位的功能不受到影响时，基类才能真正被复用，而衍生类也能够在基类的基础上增加新的行为。里氏代换原则是对“开-闭”原则的补充。实现“开-闭”原则的关键步骤就是抽象化。而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。—— From Baidu 百科

    详细介绍：https://blog.csdn.net/lovelion/article/details/7540445

  3. 依赖倒置原则（Dependence Inversion Principle）

    这个是开闭原则的基础，具体内容：针对接口编程，依赖于抽象而不依赖于具体。

    详解介绍：https://blog.csdn.net/lovelion/article/details/7562783

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

    这个原则的意思是：使用多个隔离的接口，比使用单个接口要好。还是一个降低类之间的耦合度的意思，从这儿我们看出，其实设计模式就是一个软件的设计思想，从大型软件架构出发，为了升级和维护方便。所以上文中多次出现：降低依赖，降低耦合。

    详细介绍：https://blog.csdn.net/lovelion/article/details/7562842

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

    为什么叫最少知道原则，就是说：一个实体应当尽量少的与其他实体之间发生相互作用，使得系统功能模块相对独立。

    详细介绍：https://blog.csdn.net/lovelion/article/details/7563445

  6. 单一职责原则（Single-Responsibility-Principle）

    核心：一个类只负责一个功能领域中相应的职责，或者可以定义为：就一个类而言，应该只有一个引起它变化的原因。

    思想：如果一个类承担的职责过多，就等于把这些职责耦合在一起，一个职责的变化可能会削弱或者抑制这个类完成其他职责的能力。这种耦合会导致脆弱的设计，当变化发生时，设计会遭受到意想不到的破坏。

    详细介绍：https://blog.csdn.net/lovelion/article/details/7536542

原文连接：设计模式的三大分类及六大原则

适应设计模式

Iterator模式

迭代器模式–一个一个遍历

Iterator模式中的角色

  • 迭代器接口Iterator：定义hasNext和next方法
  • 迭代器的实现类BookShelf
  • 集合接口Aggregate：定义迭代器
  • 集合的实现类BookShelfIterator

Iterator.java迭代器接口

1
2
3
4
public interface Iterator {
    public abstract boolean hasNext();
    public abstract Object next();
}

Aggregate.java集合接口

1
2
3
public interface Aggregate {
     public abstract Iterator iterator();
}

再来看实现类

Book.java实体类

1
2
3
4
5
6
7
8
9
10
11
public class Book {
    private String name;

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

BookShelf.java实现集合接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class BookShelf implements Aggregate {
    private Book books[];
    private int last = 0;
    public BookShelf(int maxsize){
        this.books = new Book[maxsize];
    }
    public Book getBookAt(int index) {
        return books[index];
    }
    public void appendBook(Book book){
        this.books[last] = book;
        last++;
    }
    public int getLength(){
        return last;
    }
	//定义迭代器
    public Iterator iterator() {
        return new BookShelfIterator(this);
    }
}

BookShelfIterator.java实现迭代器接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class BookShelfIterator implements Iterator {
    private BookShelf bookShelf;
    private int index;
    public BookShelfIterator(BookShelf bookShelf) {
        this.bookShelf = bookShelf;
        this.index = 0;
    }
    public boolean hasNext() {
        if (index < bookShelf.getLength()){
            return true;
        } else {
            return false;
        }
    }
    public Object next() {
        Book book = bookShelf.getBookAt(index);
        index++;
        return book;
    }
}

测试类：使用迭代器进行遍历输出，而不涉及集合类本身的引用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class IteratorMain {
    public static void main(String[] args) {
        BookShelf bookShelf = new BookShelf(4);
        bookShelf.appendBook(new Book("倚天屠龙记"));
        bookShelf.appendBook(new Book("葵花宝典"));
        bookShelf.appendBook(new Book("九阳真经"));
        bookShelf.appendBook(new Book("神雕侠侣"));
        Iterator it = bookShelf.iterator();
        while (it.hasNext()){
            Book book = (Book) it.next();
            System.out.println(book.getName());
        }
    }
}

Iterator模式的特点

  • 在我们使用while循环来进行遍历时，整个操作不依赖于集合类的具体实现，就算集合类不再使用数组而选择Vector取而代之，只要集合类中的Iterator方法能正确的返回Iterator实例，即使不对迭代器的使用者进行修改，遍历代码都能正常工作
  • 由于上一条的特点：“将遍历功能置于Aggregate角色之外是Iterator的一个特征”，因此可以针对同一个集合角色编写多个Iterator角色
  • 对Java集合中的元素进行清除只能使用迭代器

Adapter模式

适配器模式–添加适配器以便复用

Adaper模式有以下两种模式：

  • 类适配器模式（使用继承）
  • 对象适配器模式（使用委托）

类适配模式

OriginBanner.java被适配类

1
2
3
4
5
6
7
8
9
10
11
12
public class OriginBanner {
    private String string;
    public OriginBanner(String string){
        this.string = string;
    }
    public void showWithParen(){
        System.out.println("("+string+")");
    }
    public void showWithAster(){
        System.out.println("*"+string+"*");
    }
}

PrintInterface业务接口

1
2
3
4
public interface PrintInterface {
    public abstract void printWeak();
    public abstract void printStrong();
}

PrintBannerAdapter适配器类继承被适配类并调用被适配类的方法来实现业务接口

1
2
3
4
5
6
7
8
9
10
11
12
13
public class PrintBannerAdapter extends OriginBanner implements PrintInterface {
    public PrintBannerAdapter(String str){
        super(str);
    }
    @Override
    public void printWeak() {
        super.showWithParen();
    }
    @Override
    public void printStrong() {
        super.showWithAster();
    }
}

测试类：调用业务接口

1
2
3
4
5
6
7
public class Main {
    public static void main(String[] args) {
        PrintBannerAdapter adapter = new PrintBannerAdapter("Hello");
        adapter.printWeak();
        adapter.printStrong();
    }
}

对象适配模式

将业务接口改为抽象类

1
2
3
4
public abstract class PrintAbstract {
    public abstract void printWeak();
    public abstract void printStrong();
}

适配器继承抽象类而在内部实例化被适配类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
//这里继承的是PrintAbstract抽象类
public class PrintBannerAdapter extends PrintAbstract {
    //实例化原实现类
    private OriginBanner banner;
    public PrintBannerAdapter(String str){
        this.banner = new OriginBanner(str);
    }
    public void printWeak() {
        banner.showWithParen();
    }
    public void printStrong() {
        banner.showWithAster();
    }
}

Adapter模式中的角色

  • 需求接口/抽象类PrintInterface、PrintAbstract：定义请求者调用的方法
  • 请求者Main
  • 被适配类OriginBanner
  • 适配器类PrintBannerAdapter：

Adapter模式的特点

将一个类的接口转换成客户希望的另外一个接口。适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。

例如：在解决版本升级和兼容性问题时，可以使用Adapter模式来使新版本的接口兼容老版本的实现类

交给子类

Template Method模式

模板模式–将具体处理交给子类

Template Method模式中的角色

  • 模板：抽象类AbstractDisplay
  • 具体类：抽象类的子类DisplayA和DisplayB

模板：抽象类AbstractDisplay.java

1
2
3
4
5
6
7
8
9
public abstract class AbstractDisplay {
    public abstract void print();
    //调用print方法，并且不能被子类所重写
    public final void formalPrint(){
        for (int i = 0; i < 5; i++) {
            print();
        }
    }
}

实现类1：DisplayA.java

1
2
3
4
5
6
7
8
9
10
public class DisplayA extends AbstractDisplay{
    private String string;
    public DisplayA(String string){
        this.string = string;
    }
    @Override
    public void print() {
        System.out.println(">>>>>>" + string);
    }
}

实现类2：DisplayB.java

1
2
3
4
5
6
7
8
9
10
public class DisplayB extends AbstractDisplay{
    private String string;
    public DisplayB(String string){
        this.string = string;
    }
    @Override
    public void print() {
        System.out.println(string + "<<<<<<");
    }
}

测试类

1
2
3
4
5
6
7
8
public class Main {
    public static void main(String[] args) {
        AbstractDisplay displayA = new DisplayA("testA");
        AbstractDisplay displayB = new DisplayB("testB");
        displayA.formalPrint();
        displayB.formalPrint();
    }
}

Template Method模式的特点

  • 父类的模板方法中已经定义了调用方法的逻辑关系（这里表现为formalPrint调用了5次print），无需在每个子类中再实现算法
  • 在上面的示例中不论是DisplayA还是DisplayB的实例都是保存在AbstractDisplay类型的变量中的，这样编写的优点是，即使没有指定子类的具体种类，程序也能正常工作

父类与子类之间协作的必要性

如果将更多的方法放在父类中会导致子类更轻松，但也降低了子类的灵活性；反之，父类实现方法过少，子类会变得臃肿不堪，还可能会导致大量的代码重复

Factory Method模式

工厂模式–将实例的生成交给子类

Factory Method模式中的角色

  • 产品的抽象类Product：定义了实例所持有的接口
  • 工厂的抽象类Factory：不使用new创建实例，而是使用抽象方法createProduct来防止耦合
  • 产品实现类Product
  • 工厂实现类Factory

下面的示例结合了模板模式来实现

抽象类Product.java代表产品

1
2
3
public abstract class Product {
    public abstract void use();
}

抽象类Factory.java代表工厂

1
2
3
4
5
6
7
8
9
10
public abstract class Factory {
    public final Product create(String owner){
        Product product = createProduct(owner);
        registerProduct(product);
        return product;
    }
    //使用实例化的方法而不是直接new对象来减轻耦合性
    public abstract Product createProduct(String owner);
    public abstract void registerProduct(Product product);
}

IDCard.java实现产品类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class IDCard extends Product{
    private String owner;
    public IDCard(String owner){
        System.out.println("正在制作" + owner + "的ID卡");
        this.owner = owner;
    }
    @Override
    public void use() {
        System.out.println("正在使用" + owner + "的ID卡");
    }
    public String getOwner(){
        return owner;
    }
}

IdCardFactory.java实现工厂类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class IdCardFactory extends Factory{
    private List<String> owners = new ArrayList<>();
 	//实现实例化对象的方法
    @Override
    public Product createProduct(String owner) {
        return new IDCard(owner);
    }
    @Override
    public void registerProduct(Product product) {
        owners.add(((IDCard)product).getOwner());
    }
    public List<String> getOwners() {
        return owners;
    }
}

测试类

1
2
3
4
5
6
7
8
9
10
11
public class Main {
    public static void main(String[] args) {
        Factory factory = new IdCardFactory();
        Product card1 = factory.create("user1");
        Product card2 = factory.create("user2");
        Product card3 = factory.create("user3");
        card1.use();
        card2.use();
        card3.use();
    }
}

工厂模式的作用

父类决定实例的生成方式，但不决定需要生成的具体的类，这样可以将生成实例的框架与实际负责生成实例的类进行解耦

生成实例

Singleton模式

单例模式–只有一个实例

目的：确保任何情况下只生成一个实例

最大的特点：构造器私有

饿汉式

提前实例化对象，可能会浪费空间

1
2
3
4
5
6
7
8
public class Hungry {
    //加载类的时候就进行实例化
    private final static Hungry HUNGRY = new Hungry();
    private Hungry(){}
    public static Hungry getInstance(){
        return HUNGRY;
    }
}

懒汉式

在获取实例时，对象不存在再实例化对象

1
2
3
4
5
6
7
8
9
10
11
public class Lazy {
    private static Lazy lazy;
    private Lazy(){}
    public static Lazy getInstance(){
        //实例不存在则实例化
        if (lazy == null){
            lazy = new Lazy();
        }
        return lazy;
    }
}

内部类模式

能达到双检锁方式一样的功效，但实现更简单

这种方式只适用于静态域的情况，双检锁方式可在实例域需要延迟初始化时使用。

1
2
3
4
5
6
7
8
9
10
public class Holder {
    private Holder(){}
    public static Holder getInstance(){
        return InnerClass.HOLDER;
    }
    //内部类内实例化对象
    public static class InnerClass{
        private static final Holder HOLDER = new Holder();
    }
}

DCL懒汉式

采用双锁机制，安全且在多线程情况下能保持高性能，但还是不能防止反射机制获取构造方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class LazyDCL {
    private static LazyDCL lazyDCL;
    private LazyDCL(){}
    public static LazyDCL getInstance(){
        //实例不存在则实例化
        if (lazyDCL == null){
            //对类加锁，使其获得原子性
            synchronized (LazyDCL.class){
                if (lazyDCL == null){
                    lazyDCL = new LazyDCL();
                }
            }
        }
        return lazyDCL;
    }
}

枚举

简洁，自动支持序列化机制，绝对防止多次实例化。

1
2
3
4
5
6
7
8
9
10
11
public enum  EnumSingle {
    INSTANCE;
    //这里使用构造方法测试初始化次数
    private EnumSingle() {
        System.out.println("init");
    };
    //这里是单例对象的方法
    public void sayHello() {
        System.out.println("hello");
    }
}

实际使用方式

1
2
EnumSingle instance = EnumSingle.INSTANCE;
instance.sayHello();

测试获取多实例：

1
2
3
4
5
6
public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
    Constructor<EnumSingle> constructor = EnumSingle.class.getDeclaredConstructor(String.class, int.class);
    constructor.setAccessible(true);
    EnumSingle instance = constructor.newInstance();
    System.out.println(instance);
}

结果：不允许利用反射获取实例：java.lang.IllegalArgumentException: Cannot reflectively create enum objects

Prototype模式

原型模式–通过复制生成实例

可以通过clone方法来实现实例克隆

Prototype模式中的角色

  • 产品接口Product继承了Cloneable标记型接口
  • 实现类UnderlinePen调用clone()方法实现实例克隆

产品接口Product.java，clone()是Object类的方法，这里Product继承了Cloneable这个标记型接口，Product的实现类都可以调用clone方法

1
2
3
4
public interface Product extends Cloneable {
    public void use(String s);
    public Product createClone();
}

实现类UnderlinePen.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class UnderlinePen implements Product{
    private String decoChar;
    public UnderlinePen(String decoChar){
        this.decoChar = decoChar;
    }
    @Override
    public void use(String s) {
        System.out.println(s);
        for (int i = 0; i < s.length(); i++) {
            System.out.print("-");
        }
        System.out.println("");
    }
    @Override
    public Product createClone() {
        Product p = null;
        try {
            p = (Product) clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return p;
    }
}

测试类

1
2
3
4
5
6
7
8
public class Main {
    public static void main(String[] args) {
        Product pen = new UnderlinePen("-");
        pen.use("Hello");
        Product penClone = pen.createClone();
        penClone.use("world");
    }
}

Prototype模式使用情景

  • 对象种类繁多，无法合并到同一个类中时
  • 难以根据类生成实例时
  • 想要解耦框架与生成的实例时

Builder模式

建造者模式–组装复杂的实例

Builder模式中的角色

  • 监工Director：负责与Builder沟通，但不关心具体是哪一个Builder工作
  • 建造者抽象类Builder：类似于包工头，定义和协调需要完成的工作，具体工作由子类来完成
  • 建造者实现类TextBuilder和HtmlBuilder：完成每一项单个工作
  • 使用者：类似于业主，只与Director进行沟通，不关心底层的实现逻辑

监工类Director.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class Director {
    private Builder builder;
    public Director(Builder builder){
        this.builder=builder;
    }

    public void construct(){
        String [] items1=new String[]{"奏国歌","升国旗"};
        String [] items2=new String[]{"观众鼓掌","有序撤离"};
        builder.makeTitle("学生日记");
        builder.makeString("毕业典礼");
        builder.makeItems(items1);
        builder.makeString("典礼结束");
        builder.makeItems(items2);
        builder.close();
    }
}

建造者抽象类Builder.java

1
2
3
4
5
6
public abstract class Builder {
    public abstract void makeString(String str);
    public abstract void makeTitle(String title);
    public abstract void makeItems(String[] items);
    public abstract void close();
}

建造者实现类1TextBuilder.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class TextBuilder extends Builder {
    StringBuffer buffer = new StringBuffer();
    public void makeTitle(String title) {
        buffer.append("=====================" + "\n");
        buffer.append("[" + title + "]" + "\n");
    }
    public void makeString(String str) {
        buffer.append("@" + str + "\n");
    }
    public void makeItems(String[] items) {
        for (int i = 0; i < items.length; i++) {
            buffer.append("   ." + items[i] + "\n");
        }
    }
    public void close() {
        buffer.append("=====================");
    }
    public String getResult() {
        return buffer.toString();
    }
}

建造者实现类2HtmlBuilder.java

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
public class HtmlBuilder extends Builder {
    private String filename;
    private PrintWriter writer;
    public void makeTitle(String title) {
        filename = "D:\\" + title + ".html";
        try {
            writer = new PrintWriter(new FileWriter(filename));
        } catch (IOException e) {
            e.printStackTrace();
        }
        writer.println("<html><head><title>" + title + "</title></head><body>");
        writer.println("<h1>" + title + "</h1>");
    }
    public void makeString(String str) {
        writer.println("<p>" + str + "</p>");
    }
    public void makeItems(String[] items) {
        writer.println("<ul>");
        for (int i = 0; i < items.length; i++) {
            writer.println("<li>" + items[i] + "</li>");
        }
        writer.println("</ul>");
    }
    public void close() {
        writer.println("</body></html>");
        writer.close();
    }
    public String getResult() {
        return filename;
    }
}

测试类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class Main {
    public static void main(String[] args) {
        String choice = "text";
        if (choice.equals("text")) {
            TextBuilder t = new TextBuilder();
            Director d = new Director(t);
            d.construct();
            System.out.println(t.getResult());
        } else if (choice.equals("html")) {
            HtmlBuilder html = new HtmlBuilder();
            Director d = new Director(html);
            d.construct();
            System.out.println(html.getResult());
        } else {
            usage();
        }
    }

    private static void usage() {
        System.out.println("使用 plain，编辑文本文件");
        System.out.println("使用 html，编辑HTML文件");
    }
}

Builder模式的特点

每个角色只与其相邻的角色有所沟通，使用者只知道Director，Director只知道Builder，Builder负责沟通协调各个具体的Builder，正是因为这种“不知道”的特点，才能够较为容易的替换组件，组件才具有高价值，我们需要时刻关注这种可替换性

AbstractFactory模式

抽象工厂模式–将关联零件组装成产品

抽象类与工厂模式的结合

AbstractFactory模式的特点：

  • 易于增加具体的工厂
  • 难以增加新的零件，因为每增加一个抽象的零件，都需要在每一个具体的工厂中都添加对应具体的零件，已经编写完成的具体工厂越多，修改的工作量就会越大

分开考虑

Bridge模式

桥接模式–将类的功能层次结构与实现层次结构分离

这里有一篇详细介绍桥接模式的文章桥接模式 | 菜鸟教程 (runoob.com)

Bridge模式中的角色

  • 一个业务类Display：私有并调用接口类DisplayImpl的具体业务
  • 一个扩展抽象类CountDisplay：继承业务类Display，实现更加复杂的功能
  • 一个业务接口/抽象类DisplayImpl：来定义具体业务
  • 一个业务具体实现类StringDisplayImpl：继承或实现DisplayImpl，完成具体功能的实现

Bridge模式的特点

  • 桥接模式即将抽象部分与它的实现部分分离开来，使他们都可以独立变化
  • 桥接模式将继承关系转化成关联关系（委托关系），它降低了类与类之间的耦合度，减少了系统中类的数量，也减少了代码量

优点：

  • 桥接模式提高了系统的可扩充性，在两个变化维度中任意扩展一个维度，都不需要修改原有系统，即分开后更容易扩展
  • 实现细节对客户不可见，可以对用户隐藏实现细节

Strategy模式

策略模式–整体的替换算法

定义一个策略接口，然后创建不同的策略接口实现类来实现不同的策略

Strategy模式的角色

  • 策略接口Strategy
  • 不同的策略实现类OperationAdd, OperationSubtract, OperationMultiply
  • 策略封装类Context

Strategy.java

1
2
3
public interface Strategy {
   public int doOperation(int num1, int num2);
}

不同的实现类

1
2
3
4
5
6
public class OperationAdd implements Strategy{
   @Override
   public int doOperation(int num1, int num2) {
      return num1 + num2;
   }
}
1
2
3
4
5
6
public class OperationSubtract implements Strategy{
   @Override
   public int doOperation(int num1, int num2) {
      return num1 - num2;
   }
}
1
2
3
4
5
6
public class OperationMultiply implements Strategy{
   @Override
   public int doOperation(int num1, int num2) {
      return num1 * num2;
   }
}

Context.java

1
2
3
4
5
6
7
8
9
10
11
public class Context {
   private Strategy strategy;
 
   public Context(Strategy strategy){
      this.strategy = strategy;
   }
 
   public int executeStrategy(int num1, int num2){
      return strategy.doOperation(num1, num2);
   }
}

测试类

1
2
3
4
5
6
7
8
9
10
11
12
public class StrategyPatternDemo {
   public static void main(String[] args) {
      Context context = new Context(new OperationAdd());    
      System.out.println("10 + 5 = " + context.executeStrategy(10, 5));
 
      context = new Context(new OperationSubtract());      
      System.out.println("10 - 5 = " + context.executeStrategy(10, 5));
 
      context = new Context(new OperationMultiply());    
      System.out.println("10 * 5 = " + context.executeStrategy(10, 5));
   }
}

特点：

使用委托这种弱关联关系可以方便的整体替换算法

一致性

Composite模式

组合模式–容器与内容的一致性

将对象组合成树形结构以表示”部分-整体”的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。

Composite模式的特点

  • 以递归的形式使得同一类或相近的类(如File和Directory都是文件系统中的子项)结合成树状结构

优点：

  • 高层模块调用简单
  • 节点增加自由

缺点：

  • 违背了依赖倒置原则

Decorator模式

装饰器模式–装饰边框与装饰物的一致性

Decorator模式中的角色

  • 被装饰类的总接口/抽象类Shape
  • 装饰器的抽象类ShapeDecorator
  • 装饰器的实现类RedShapeDecorator

==这里需要注意：装饰器的抽象类是实现并私有Shape类接口的，而装饰器的实现类继承抽象类，因此被装饰类和装饰器类的所有组件都具有一致性==

Decorator模式的特点

  • 装饰类和被装饰类可以独立发展，不会相互耦合，装饰模式是继承的一个替代模式，装饰模式可以动态扩展一个实现类的功能
  • 可以在不想增加很多子类的情况下扩展类时使用装饰器模式，动态的增加功能

访问数据结构

Visitor模式

以往如果我们要对一些数据进行处理，会在这些数据结构的类中编写处理方法，如果我们需要新增处理方法，就需要修改原来的数据结构类

visitor模式旨在将数据结构与对他们的处理从一个类中分离出来

Visitor模式中的角色

  • 数据结构总接口ComputerPart：定义accept方法
  • 数据结构的具体实现类Computer、KeyBoard、Mouse、Monitor：实现accept方法–根据不同的业务逻辑调用visitor的visit()方法
  • 访问者接口或抽象类ComputerPartDisplayVisitor：定义数据处理方法
  • 访问者实现类ComputerPartVisitor：编写具体的数据处理方法

数据结构接口ComputerPart.java

1
2
3
public interface ComputerPart {
   public void accept(ComputerPartVisitor computerPartVisitor);
}

各个数据结构实现类：调用不同visitor的visit()方法

1
2
3
4
5
6
7
public class Keyboard  implements ComputerPart {
 
   @Override
   public void accept(ComputerPartVisitor computerPartVisitor) {
      computerPartVisitor.visit(this);
   }
}
1
2
3
4
5
6
public class Monitor  implements ComputerPart {
   @Override
   public void accept(ComputerPartVisitor computerPartVisitor) {
      computerPartVisitor.visit(this);
   }
}
1
2
3
4
5
6
public class Mouse  implements ComputerPart {
   @Override
   public void accept(ComputerPartVisitor computerPartVisitor) {
      computerPartVisitor.visit(this);
   }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Computer implements ComputerPart {
   ComputerPart[] parts;
 
   public Computer(){
      parts = new ComputerPart[] {new Mouse(), new Keyboard(), new Monitor()};      
   } 
 
   @Override
   public void accept(ComputerPartVisitor computerPartVisitor) {
      for (int i = 0; i < parts.length; i++) {
         parts[i].accept(computerPartVisitor);
      }
      computerPartVisitor.visit(this);
   }
}

访问者接口ComputerPartVisitor.java

1
2
3
4
5
6
public interface ComputerPartVisitor {
   public void visit(Computer computer);
   public void visit(Mouse mouse);
   public void visit(Keyboard keyboard);
   public void visit(Monitor monitor);
}

访问者实现类ComputerPartDisplayVisitor.java：在这里实际操作数据类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class ComputerPartDisplayVisitor implements ComputerPartVisitor {
   @Override
   public void visit(Computer computer) {
      System.out.println("Displaying Computer.");
   }
 
   @Override
   public void visit(Mouse mouse) {
      System.out.println("Displaying Mouse.");
   }
 
   @Override
   public void visit(Keyboard keyboard) {
      System.out.println("Displaying Keyboard.");
   }
 
   @Override
   public void visit(Monitor monitor) {
      System.out.println("Displaying Monitor.");
   }
}

测试类

1
2
3
4
5
6
7
public class VisitorPatternDemo {
   public static void main(String[] args) {
 
      ComputerPart computer = new Computer();
      computer.accept(new ComputerPartDisplayVisitor());
   }
}

Visitor模式的特点

  • 具体数据元素的实现类调用accept()方法，而后又visitor的visit()方法：element接受visitor，而visitor又访问数据元素，这种消息分发的方式称为双重分发
  • 解决了数据结构和易变的操作耦合问题

优点：

  • 符合单一职责原则
  • 易于添加visitor，优秀的扩展性和灵活性

缺点：

  • 具体元素对访问者公布细节，违反了迪米特原则
  • 违反了依赖倒置原则，依赖于具体类，而不是抽象类
  • 难以扩展数据元素：需要对所有visitor加以修改

Chain of Responsibility

责任链模式–推卸责任

就像我们有时去办理业务，各个部门之间的会互相推卸责任，各自只处理自身所负责的一部分业务

Chain of Responsibility中的角色

  • 抽象类业务类AbstractLogger
  • 业务类实现类ConsoleLogger、ErrorLogger、FileLogger

抽象类业务类AbstractLogger.java

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
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);
}

不同级别的Logger实现类

1
2
3
4
5
6
7
8
9
10
11
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);
   }
}
1
2
3
4
5
6
7
8
9
10
11
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);
   }
}
1
2
3
4
5
6
7
8
9
10
11
public class FileLogger extends AbstractLogger {
 
   public FileLogger(int level){
      this.level = level;
   }
 
   @Override
   protected void write(String message) {    
      System.out.println("File::Logger: " + message);
   }
}

测试类

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
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.");
   }
}

Chain of Responsibility的特点

  • 弱化了发送请求的类和处理业务的类之间的关系
  • 可以动态地改变责任链
  • 每个业务类都专注于自己的工作

优点：

  • 降低耦合度
  • 简化了对象
  • 增强给对象指派职责的灵活性
  • 便于增添新的业务类

缺点：

  • 不能保证请求一定会被接收
  • 系统性能稍微降低
  • 运行过程复杂，不容易排错

简单化

Facade模式

外观模式–简单窗口

Facade模式的角色

  • 外部调用的窗口类：ShapeMaker
  • 业务接口类：Shape
  • 业务实现类：Circle、Rectangel、Square

Facade模式的特点

外观模式隐藏系统的复杂性，并向客户端提供了一个客户端可以访问系统的接口。这种类型的设计模式属于结构型模式，它向现有的系统添加一个接口，来隐藏系统的复杂性。

优点：

  • 减少系统的相互依赖，接口变少，调用方便
  • 提高灵活性
  • 提高安全性

缺点：

  • 不符合开闭原则，修改组件麻烦

Mediator模式

中介者模式–只有一个仲裁者

Mediator模式中的角色

  • 中介者抽象类Mediator
  • 中介者实现类ConcretMediator
  • 同事类接口Colleague
  • 同事类实现类ConcreteColleage

Mediator模式的特点

  • 集中业务逻辑与中介者类中，各个同事类之间的交互集中于调用Mediator类中的实现方法
  • 各对象不需要显式地相互引用，从而使其耦合松散

优点：

  • 降低了类的复杂度，将一对多转化为了一对一
  • 各个类之间解耦
  • 符合迪米特原则

缺点：

  • 中介者类代码庞大且不易于维护

管理状态

Observer模式

观察者模式–发送状态变化通知

另一个称呼为Publish-Subscribe模式，即发布订阅

Observer模式中的对象

  • 主题类Subject
  • 观察者抽象类Observer
  • 观察者实现类BinaryObserver、OctalObserver、HexaObserver

主题类Subject.java

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
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

1
2
3
4
public abstract class Observer {
   protected Subject subject;
   public abstract void update();
}

不同的观察者实现类

1
2
3
4
5
6
7
8
9
10
11
12
13
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() ) ); 
   }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
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() ) ); 
   }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
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() ); 
   }
}

测试类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
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);
   }
}

Observer模式的特点

当一个对象被修改时，则会自动通知依赖它的对象。观察者模式属于行为型模式

优点：

  • 观察者和被观察者通过抽象类耦合
  • 建立了一套触发机制

缺点：

  • 如果一个被观察者有太多直接和简洁的观察者，通知所有的观察者会花费很多时间
  • 只能通知被观察者发生了变化，而不能通知其发生了怎样的变化

Memento模式

备忘录模式–保存对象状态

使用Memento模式可以实现应用程序的以下功能：

  • 撤销
  • 重做
  • 历史记录
  • 快照

Memento模式中的角色

  • 状态类Memento
  • 业务类Originator
  • 状态列表类CareTaker

状态类Memento.java

1
2
3
4
5
6
7
8
9
10
11
public class Memento {
   private String state;
 
   public Memento(String state){
      this.state = state;
   }
 
   public String getState(){
      return state;
   }  
}

业务类Originator.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class Originator {
   private String state;
 
   public void setState(String state){
      this.state = state;
   }
 
   public String getState(){
      return state;
   }
 
   public Memento saveStateToMemento(){
      return new Memento(state);
   }
 
   public void getStateFromMemento(Memento Memento){
      state = Memento.getState();
   }
}

状态列表类CareTaker.java

1
2
3
4
5
6
7
8
9
10
11
public class CareTaker {
   private List<Memento> mementoList = new ArrayList<Memento>();
 
   public void add(Memento state){
      mementoList.add(state);
   }
 
   public Memento get(int index){
      return mementoList.get(index);
   }
}

测试类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class MementoPatternDemo {
   public static void main(String[] args) {
      Originator originator = new Originator();
      CareTaker careTaker = new CareTaker();
      originator.setState("State #1");
      originator.setState("State #2");
      careTaker.add(originator.saveStateToMemento());
      originator.setState("State #3");
      careTaker.add(originator.saveStateToMemento());
      originator.setState("State #4");
 
      System.out.println("Current State: " + originator.getState());    
      originator.getStateFromMemento(careTaker.get(0));
      System.out.println("First saved State: " + originator.getState());
      originator.getStateFromMemento(careTaker.get(1));
      System.out.println("Second saved State: " + originator.getState());
   }
}

Memento模式的特点

  • 在不破坏封装的情况下捕获一个对象的内部状态，并在这个对象之外保存状态，以便恢复
  • 通过一个专门的备忘录类来专门存储对象状态

优点：

  • 提供了可以恢复状态的机制，可以方便的回退到某个历史状态
  • 实现信息的封装，用户不需要关心保存细节

缺点：

  • 消耗内存
  • 如果需要持久化，还需要考虑有效期和对应应用程序版本的问题

State模式

状态模式–用类表示状态

不使用State模式的情况下，如果我们要判断对象处于哪一个状态，往往需要编写许多if_else语句来进行判断，而使用类来表示状态可以解决这一问题

State模式中的角色

  • 状态类接口State
  • 状态实现类StartState、StopState
  • 状态管理类Context

状态类接口State.java

1
2
3
public interface State {
   public void doAction(Context context);
}

不同的状态类实现类

1
2
3
4
5
6
7
8
9
10
public class StartState implements State {
   public void doAction(Context context) {
      System.out.println("Player is in start state");
      context.setState(this); 
   }
 
   public String toString(){
      return "Start State";
   }
}
1
2
3
4
5
6
7
8
9
10
public class StopState implements State {
   public void doAction(Context context) {
      System.out.println("Player is in stop state");
      context.setState(this); 
   }
 
   public String toString(){
      return "Stop State";
   }
}

状态管理类Context.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Context {
   private State state;
 
   public Context(){
      state = null;
   }
 
   public void setState(State state){
      this.state = state;     
   }
 
   public State getState(){
      return state;
   }
}

测试类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class StatePatternDemo {
   public static void main(String[] args) {
      Context context = new Context();
 
      StartState startState = new StartState();
      startState.doAction(context);
 
      System.out.println(context.getState().toString());
 
      StopState stopState = new StopState();
      stopState.doAction(context);
 
      System.out.println(context.getState().toString());
   }
}

State模式的特点

优点：

  • 封装了转换规则，易于增加新的状态
  • 枚举所有可能的状态
  • 将所有与某个状态有关的操作全部放到某个类中，只需要改变状态的类型就能改变状态的行为
  • 可以让多个环境对象共享一个状态对象

缺点：

  • 增加了系统类和对象的个数
  • 不易添加新的状态方法
  • 对开闭原则的支持性不好

避免浪费

Flyweight模式

享元模式–共享对象，避免浪费

通过尽量共享实例来避免new新的实例

Flyweight模式中的角色

  • 工厂类ShapeFactory
  • 业务类接口Shape
  • 业务实现类Circle

工厂类ShapeFactory.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class ShapeFactory {
    //使用HashMap保存已经实例化的对象列表
   private static final HashMap<String, Shape> circleMap = new HashMap<>();
 
   public static Shape getCircle(String color) {
      //尝试从列表中获取已经实例化的对象
      Circle circle = (Circle)circleMap.get(color);
 	  //如果无法获取对象再进行实例化
      if(circle == null) {
         circle = new Circle(color);
         circleMap.put(color, circle);
         System.out.println("Creating circle of color : " + color);
      }
      return circle;
   }
}

业务类接口Shape.java

1
2
3
public interface Shape {
   void draw();
}

业务实现类Circle.java

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
public class Circle implements Shape {
   private String color;
   private int x;
   private int y;
   private int radius;
 
   public Circle(String color){
      this.color = color;     
   }
 
   public void setX(int x) {
      this.x = x;
   }
 
   public void setY(int y) {
      this.y = y;
   }
 
   public void setRadius(int radius) {
      this.radius = radius;
   }
 
   @Override
   public void draw() {
      System.out.println("Circle: Draw() [Color : " + color 
         +", x : " + x +", y :" + y +", radius :" + radius);
   }
}

测试类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class FlyweightPatternDemo {
   private static final String colors[] = 
      { "Red", "Green", "Blue", "White", "Black" };
   public static void main(String[] args) {
 
      for(int i=0; i < 20; ++i) {
         Circle circle = 
            (Circle)ShapeFactory.getCircle(getRandomColor());
         circle.setX(getRandomX());
         circle.setY(getRandomY());
         circle.setRadius(100);
         circle.draw();
      }
   }
   private static String getRandomColor() {
      return colors[(int)(Math.random()*colors.length)];
   }
   private static int getRandomX() {
      return (int)(Math.random()*100 );
   }
   private static int getRandomY() {
      return (int)(Math.random()*100);
   }
}

Flyweight模式的特点

  • 如果要更改被共享的对象，就会对多个引用处造成影响
  • 应该被共享的信息称为固有信息(Intrinsic信息)，不应当被共享的信息被称为外部信息(Extrinsic信息)

优点：

  • 减少了对象的创建，降低系统内存消耗，提高效率

缺点：

  • 提高了系统的复杂度，需要分理出外部状态和固有状态，否则会造成系统混乱

Proxy模式

代理模式–只在必要时生成实例

Proxy模式中的对象

  • 对象接口Image
  • 真实的对象RealImage
  • 代理人ProxyImage

静态代理

对象接口Image.java

1
2
3
public interface Image {
   void display();
}

真实对象RealImage.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class RealImage implements Image {
 
   private String fileName;
 
   public RealImage(String fileName){
      this.fileName = fileName;
      loadFromDisk(fileName);
   }
 
   @Override
   public void display() {
      System.out.println("Displaying " + fileName);
   }
 
   private void loadFromDisk(String fileName){
      System.out.println("Loading " + fileName);
   }
}

代理对象ProxyImage.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class ProxyImage implements Image{
 
   private RealImage realImage;
   private String fileName;
 
   public ProxyImage(String fileName){
      this.fileName = fileName;
   }
   //只在实际执行realImage方法时才会实例化RealImage对象
   @Override
   public void display() {
      if(realImage == null){
         realImage = new RealImage(fileName);
      }
      realImage.display();
   }
}

测试类

1
2
3
4
5
6
7
8
9
10
11
12
public class ProxyPatternDemo {
   
   public static void main(String[] args) {
      Image image = new ProxyImage("test_10mb.jpg");
 
      // 图像将从磁盘加载
      image.display(); 
      System.out.println("");
      // 图像不需要从磁盘加载
      image.display();  
   }
}

动态代理

使用静态代理时，每个代理类只能为一个接口服务，这样在开发中必然会出现许多的代理类

动态代理就能够实现通过一个代理类完成全部的代理功能

这里使用Jdk代理实现

仅修改代理类，实现InvocationHandler接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class ImageHandler implements InvocationHandler {
    private Object target;
    public Object newProxyInstance(Object targetObject){
        this.target=targetObject;
        return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(),
                targetObject.getClass().getInterfaces(),this);
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Proxying：" + proxy.getClass().getName());
        Object result = method.invoke(target, args);
        System.out.println("执行了：" + method.getName() + " 返回：" + result);
        return result;
    }
}

测试类

1
2
3
4
5
6
7
8
public class JdkProxyDemo {
    public static void main(String[] args) throws NoSuchMethodException {
        ImageHandler imageHandler = new ImageHandler();
        //传入需要被代理的实例
        Image instance = (Image) imageHandler.newProxyInstance(new RealImage("1.jpg"));
        instance.display();
    }
}

Proxy模式的特点

在我们想要访问一个类时添加一些控制，增加中间层

优点：

  • 职责清晰
  • 高扩展性

缺点：

  • 代理对象的存在导致请求处理速度变慢

用类来表现

Command模式

命令模式–命令也是类

将一个请求封装成一个对象，可以记录用户的请求来恢复或重做请求等

Command模式中的对象

  • 真实的请求类Stock
  • 请求接口Order
  • 请求实现类BuyStock、SellStock：调用Stock的方法
  • 请求管理类Broker

请求接口Order.java

1
2
3
public interface Order {
   void execute();
}

真实请求类Stock.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Stock {
   private String name = "ABC";
   private int quantity = 10;
 
   public void buy(){
      System.out.println("Stock [ Name: "+name+", 
         Quantity: " + quantity +" ] bought");
      quantity++;
   }
   public void sell(){
      System.out.println("Stock [ Name: "+name+", 
         Quantity: " + quantity +" ] sold");
      quantity--;
      }
}

不同的请求实现类

1
2
3
4
5
6
7
8
9
10
11
public class BuyStock implements Order {
   private Stock abcStock;
 
   public BuyStock(Stock abcStock){
      this.abcStock = abcStock;
   }
 
   public void execute() {
      abcStock.buy();
   }
}
1
2
3
4
5
6
7
8
9
10
11
public class SellStock implements Order {
   private Stock abcStock;
 
   public SellStock(Stock abcStock){
      this.abcStock = abcStock;
   }
 
   public void execute() {
      abcStock.sell();
   }
}

命令调用类Broker.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Broker {
   private List<Order> orderList = new ArrayList<Order>(); 
 
   public void takeOrder(Order order){
      orderList.add(order);      
   }
 
   public void placeOrders(){
      for (Order order : orderList) {
         order.execute();
      }
      orderList.clear();
   }
}

测试类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class CommandPatternDemo {
   public static void main(String[] args) {
      Stock abcStock = new Stock();
 
      BuyStock buyStockOrder = new BuyStock(abcStock);
      SellStock sellStockOrder = new SellStock(abcStock);
 
      Broker broker = new Broker();
      broker.takeOrder(buyStockOrder);
      broker.takeOrder(sellStockOrder);
 
      broker.placeOrders();
   }
}

Command模式的特点

  • 请求执行顺序：调用者->命令->接受者，实际完成具体功能的是接收者

优点：

  • 降低系统耦合度
  • 易于添加新的命令

缺点：

  • 可能会导致系统中命令类过多

Interpreter模式

解释器模式–语法规则也是类

给定一个语言，定义它的文法表示，并定义一个解释器，这个解释器使用该标识来解释语言中的句子

Interpreter模式中的对象

  • 表达式接口
  • 根据具体需求实现的不同表达式

==这里仅给出一个示例，具体的应用结构不一定需要与示例保证完全一致==

表达式接口Expression.java

1
2
3
public interface Expression {
   public boolean interpret(String context);
}

不同类型的表达式：其中TerminalExpression用来存储单个的词语，OrExpression和AndExpression用来记录词语之间的并交关系

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class TerminalExpression implements Expression {
   
   private String data;
 
   public TerminalExpression(String data){
      this.data = data; 
   }
 
   @Override
   public boolean interpret(String context) {
      if(context.contains(data)){
         return true;
      }
      return false;
   }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class OrExpression implements Expression {
    
   private Expression expr1 = null;
   private Expression expr2 = null;
 
   public OrExpression(Expression expr1, Expression expr2) { 
      this.expr1 = expr1;
      this.expr2 = expr2;
   }
 
   @Override
   public boolean interpret(String context) {      
      return expr1.interpret(context) || expr2.interpret(context);
   }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class AndExpression implements Expression {
    
   private Expression expr1 = null;
   private Expression expr2 = null;
 
   public AndExpression(Expression expr1, Expression expr2) { 
      this.expr1 = expr1;
      this.expr2 = expr2;
   }
 
   @Override
   public boolean interpret(String context) {      
      return expr1.interpret(context) && expr2.interpret(context);
   }
}

测试类

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
public class InterpreterPatternDemo {
 
   //规则：Robert 和 John 是男性
   public static Expression getMaleExpression(){
      Expression robert = new TerminalExpression("Robert");
      Expression john = new TerminalExpression("John");
      return new OrExpression(robert, john);    
   }
 
   //规则：Julie 是一个已婚的女性
   public static Expression getMarriedWomanExpression(){
      Expression julie = new TerminalExpression("Julie");
      Expression married = new TerminalExpression("Married");
      return new AndExpression(julie, married);    
   }
 
   public static void main(String[] args) {
      Expression isMale = getMaleExpression();
      Expression isMarriedWoman = getMarriedWomanExpression();
 
      System.out.println("John is male? " + isMale.interpret("John"));
      System.out.println("Julie is a married women? " 
      + isMarriedWoman.interpret("Married Julie"));
   }
}

Interpreter模式的特点

  • 可以将一个需要解释执行的语言中的句子表示为一个抽象语法树
  • 一些重复出现的问题可以用一种简单的语言来进行表达

优点：

  • 可扩展性好，灵活
  • 易于实现简单逻辑表达

缺点：

  • 可用场景少，Java中可用expression4替代
  • 难以进行语法维护
  • 引发类膨胀