（一）面向复用性的Java设计模式

目录

0、写在前面

万变不离其宗，无外乎委托+继承。
设计模式的分类：
①创建型模式（关注对象的创建过程）
factory（工厂模式）
abstract factory（抽象工厂模式）
builder（建造者模式）
（面向性能的模式，尽量少创建对象）
singleton（单例模式）
prototype（原型模式）
flyweight（轻量模式）
object pool（对象池）

②结构型模式（处理类和对象的构成）
（使用各种继承和组合以及委托）
Adapter（适配器模式）
Decorator（装饰器模式）
Facade（外观模式模式）
bridge（桥接模式）
proxy（代理模式）
composite（组合模式）

③行为类模式（表征类或对象交互和分配责任的方式）
Strategy（策略模式）
Template（模板模式）
Iterator（迭代模式）
observer（观察者模式）
visitor（访问者模式）
state（状态模式）
memento（备忘录模式）

1、面向可复用性的设计模式

1.1、结构型模式

1.1.1、Adapter（适配器模式）

将某个类/接口转换为client期望的其他形式。
继承树

举例

Rectangle作为一个适配器，内部使用委托调用LegacyRectangle类的方法，实现将LegacyRectangle中的display转化成client**期望的方式，体现为参数命名**上。在这里对抽象接口进行编程，所以定义了一个Shape接口，Rectangle实现Shape。
在后续的所有模式中，都不是直接创建一个类，而是先创建一个接口，然后类实现接口，并且使用SuperInterface obj = new SubClass()的形式创建对象，其实这就是接口转置原则（SOLID中的DIP）。

1.1.2、Decorator（装饰器模式）

为对象增加不同侧面的特性，对每一个特性构造子类，通过委派机制增加到对象上。
继承树

举例

/* 父接口 */
interface Stack {
    void push(Item e);
    Item pop();
}
/* 抽象子类 */
public abstract class AbstractStackDecorator implements Stack {
    /* 委托 */
    protected final Stack stack;
    public AbstractStackDecorator(Stack stack) {
        this.stack = stack;
    }
    public void push(Item e) {
        stack.push(e);
    }
    public Item pop() {
        return stack.pop();
    }
    ...
}
/* 实际装饰器类，子类型 */
public class UndoStack extends AbstractStackDecorator implements Stack {
    private final UndoLog log = new UndoLog();
    public UndoStack(Stack stack) {
        super(stack);
    }
    public void push(Item e) {
        log.append(UndoLog.PUSH, e);
        super.push(e);
    }
    public void undo() {
    //implement decorator behaviors on stack
    }
...
}
/* 创建一个普通堆栈，ArrayStack实现了Stack接口 */
    Stack s = new ArrayStack();
/* 创建一个撤销栈，只有一个撤销的装饰器 */
    UndoStack s = new UndoStack(new ArrayStack());
/* 创建一个线程安全的撤销栈，有两个装饰器  */
    SecureStack s = new SecureStack(new SynchronizedStack(new UndoStack(s))

本来存在的是Stack接口，然后AbstractStack使用委托实现了Stack的所有操作（其实也可以在装饰器中实现，但是为了使装饰器只实现一个功能，同时也为了实现更多的装饰器，所以特意创建一个抽象子类）；最后创建装饰器类，继承了AbstractStack，实现了Stack接口，内部实现具体的装饰，比如记录入栈日志（原本的入栈操作使用super调用父类中的实现），以及撤销操作。
过程本质可以从创建对象的方式上看出，传入一个对象，进行装饰，然后返回一个新的对象。
Java集合类中常见的装饰器有：

/* Turn a mutable list into an immutable list */
    static List<T> unmodifiableList(List<T> lst);
    static Set<T> unmodifiableSet( Set<T> set);
    static Map<K,V> unmodifiableMap( Map<K,V> map);
/* Similar for synchronization */
    static List<T> synchronizedList(List<T> lst);
    static Set<T> synchronizedSet( Set<T> set);
    static Map<K,V> synchronizedMap( Map<K,V> map);

1.1.3、Facade（外观模式模式）

客户端需要通过一个简化的接口来访问复杂系统内的功能；提供一个统一的接口来取代一系列小接口调用，相当于对复杂系统做了一个封装，简化客户端使用。（解耦）
形式化（上层客户端只需要调用一个接口，并传入选择代号，内部进行选择操作，最后返回需求）

举例

/* 两个类分别封装客户端所需的功能 */
public class MySqlHelper {
    public static Connection getMySqlDBConnection() {…}
    public void generateMySqlPDFReport(String tableName, Connection con){…}
    public void generateMySqlHTMLReport(String tableName, Connection con){…}
}
public class OracleHelper {
    public static Connection getOracleDBConnection() {…}
    public void generateOraclePDFReport(String tableName, Connection con){…}
    public void generateOracleHTMLReport(String tableName, Connection con){…}
}
/* 外观类 */
public class HelperFacade {
    public static void generateReport(DBTypes dbType, ReportTypes reportType, String tableName){
    Connection con = null;
    switch (dbType){
        case MYSQL:
            con = MySqlHelper.getMySqlDBConnection();
            MySqlHelper mySqlHelper = new MySqlHelper();
            switch(reportType){
                case HTML:
                    mySqlHelper.generateMySqlHTMLReport(tableName, con);
                    break;
                case PDF:
                    mySqlHelper.generateMySqlPDFReport(tableName, con);
                    break;
            }
            break;
    case ORACLE: …
}
/* 选择 */
    public static enum DBTypes { MYSQL,ORACLE; }
    public static enum ReportTypes { HTML,PDF;}
}
/* 客户端调用 */
/* 选择：MYSQL，HTML */
HelperFacade.generateReport(HelperFacade.DBTypes.MYSQL,HelperFacade.ReportTypes.HTML, tableName);
/* 选择：ORACLE，PDF */
HelperFacade.generateReport(HelperFacade.DBTypes.ORACLE,HelperFacade.ReportTypes.PDF, tableName);

首先，有两个类OracleHelper和MySQLHelper，分别封装了客户端的需求（产生HTMl类型、PDF类型报告）；然后使用外观类HelperFacede，使用枚举，给出了数据库类型的选择和报告类型的选择，在generateReport中，使用switch-case语句，根据客户端传入的数据库类型进行选择，每个数据库类型中，再根据操作类型进行选择，最后实现需求。
外观模式，主要是通过创建一个外观辅助类，简化了客户端的调用，客户端只需要传入选择即可，在外观辅助类中通过if-else或switch-case语句，根据客户端的选择分情况进行操作。
需要注意的是，外观辅助类中使用了静态方法和枚举变量，这也是一种简化，便于客户端直接调用。

1.2、行为类模式

1.2.1、Strategy（策略模式）

问题：针对特定任务存在不同的算法，但客户端可以根据动态上下文在运行时切换算法。
示例：对客户列表进行排序（冒泡排序，合并排序，快速排序）。
解决方案：为算法创建一个接口，并为算法的每个变体创建一个实现类。
优点： 易于扩展新算法实现，从客户端上下文中分离算法。
继承树（反而一头雾水，看代码分析）

举例

/* 支付策略接口 */
public interface PaymentStrategy {
    public void pay(int amount);
}
/* 信用卡支付，策略1 */
public class CreditCardStrategy implements PaymentStrategy {
    ...
    public CreditCardStrategy(String nm, String ccNum,String cvv, String expiryDate){
    ...
    }
    @Override
    public void pay(int amount) {
        System.out.println(amount +" paid with credit card");
    }
}
/* Paypal支付，策略2 */
public class PaypalStrategy implements PaymentStrategy {
    ...
    public PaypalStrategy(String email, String pwd){
    ...
    }
    @Override
    public void pay(int amount) {
        System.out.println(amount + " paid using Paypal.");
    }
}
/* 购物清单-管理支付策略类 */
public class ShoppingCart {
    /* 有addItem()添加物品操作；calculateTotal()计算总价操作 */
    ...
    public void pay(PaymentStrategy paymentMethod){
        /*  */
        int amount = calculateTotal();
        paymentMethod.pay(amount);
    }
}
/* 客户端 */
public class ShoppingCartTest {
    public static void main(String[] args) {
        /* 创建策略管理类 */
        ShoppingCart cart = new ShoppingCart();
        /* 添加物品 */
        Item item1 = new Item("1234",10);
        Item item2 = new Item("5678",40);
        cart.addItem(item1);
        cart.addItem(item2);
        /* 使用不同的支付方式 */
        //pay by paypal
        cart.pay(new PaypalStrategy("myemail@exp.com", "mypwd"));
        //pay by credit card
        cart.pay(new CreditCardStrategy(“Alice", "1234", "786", "12/18"));
    }
}

策略模式，主要分为策略接口（支付策略接口），多个实现接口的策略子类（信用卡支付，PayPal支付），策略管理类（ShoppingCart购物清单类）。最重要的是选择策略方式，

public void pay(PaymentStrategy paymentMethod){
    int amount = calculateTotal();
    paymentMethod.pay(amount);
}

其实策略的选择创建在客户端中实现，客户端传入具体策略对象，然后在策略管理类中进行下一步操作。
可以发现，只有在客户端选择策略时是直接创建策略子类，其他地方一律使用的策略接口。

1.2.2、Template（模板模式）

做事情的步骤一样，但具体方法不同，共性的步骤在抽象类内公共实现，差异化的步骤在各个子类中实现。使用继承和重写实现模板模式。
继承树

举例

/* 模板：父类，抽象类，包含统一的行为-抽象的行为和具体的行为 */
public abstract class OrderProcessTemplate {
    public boolean isGift;
    /* 抽象方法，子类中具体实现 */
    public abstract void doSelect();
    public abstract void doPayment();
    public abstract void doDelivery();
    /* 共有方法 */
    public final void giftWrap() {
        System.out.println("Gift wrap done.");
    }
    public final void processOrder() {
        doSelect();
        doPayment();
        if (isGift)
            giftWrap();
        doDelivery();
    }
}
/* 模板的一种实现 */
public class NetOrder extends OrderProcessTemplate {
    @Override
    public void doSelect() { … }
    @Override
    public void doPayment() { … }
    @Override
    public void doDelivery() { … }
}
/* 模板的另一种实现 */
public class StoreOrderer extends OrderProcessTemplate {
    @Override
    public void doSelect() { … }
    @Override
    public void doPayment() { … }
    @Override
    public void doDelivery() { … }
}
/* 客户端 */
    OrderProcessTemplate netOrder = new NetOrder();
    netOrder.processOrder();
    OrderProcessTemplate storeOrder = new StoreOrder();
    storeOrder.processOrder();

总体上和策略模式很像，但是策略模式中策略接口只有一种方法，而模板模式中，模板是一个抽象类，有具体方法，有抽象方法，而实现模板就是实现抽象的方法。
可以发现，在客户端使用时，仍然是面向接口编程。

1.2.3、Iterator（迭代器模式）

Iterable接口：实现该接口的集合对象是可迭代遍历的：

public interface Iterable<T> {
    ...
    Iterator<T> iterator();
}

Iterator接口：迭代器，具有三个方法：

public interface Iterator<E> {
    boolean hasNext();
    E next();
    void remove();
}

让自己的集合类实现Iterable 接口，并实现自己的独特Iterator(hasNext, next, remove)，允许客户端利用这个迭代器进行显式或隐式的迭代遍历：

    /* for-each遍历 */
    for (E e : collection) { … }
    /* 使用迭代器对象 */
    Iterator<E> iter = collection.iterator();
    while(iter.hasNext()) { … }

继承树

举例

/* 实现Iterable接口 */
public class Pair<E> implements Iterable<E> {
    private final E first, second;
    public Pair(E f, E s) {
        first = f; 
        second = s; 
    }
    public Iterator<E> iterator() {
        return new PairIterator();
    }
    /* 实现iterator接口，包含三个方法 */
    private class PairIterator implements Iterator<E> {
        private boolean seenFirst = false, seenSecond = false;
        public boolean hasNext() {
            return !seenSecond; 
        }
        public E next() {
            if (!seenFirst) {
                 seenFirst = true; 
                  return first;
            }
            if (!seenSecond) { 
                seenSecond = true;
                return second; 
            }
            throw new NoSuchElementException();
        }
        public void remove() {
            throw new UnsupportedOperationException();
        }
    }
}
/* 客户端 */
    Pair<String> pair = new Pair<String>("foo", "bar");
    for (String s : pair) { … }

这个模式主要是实现自己的集合类，使其具有使用迭代器的功能。
实现过程是：自己的集合类实现Iterable接口，实现iterator方法，该方法要返回一个Iterator对象，该对象可以通过实现Iterator接口（实现其中的hasNext()，next()，remove()方法。）来定制。
需要注意的是，过程中统一使用泛型，可以方便任意类型参数使用。
关于迭代器，有一个易错点，就是，使用迭代器遍历时，无法正常使用集合本身的删除操作，此时需要使用iterator的remove操作（在讲内存快照时具体分析过）。