设计模式理解

最新推荐文章于 2024-09-28 22:54:00 发布

唱着歌搬砖

最新推荐文章于 2024-09-28 22:54:00 发布

阅读量93

点赞数

分类专栏：设计模式文章标签：设计模式

本文链接：https://blog.csdn.net/cxydkh/article/details/122957681

版权

设计模式专栏收录该内容

1 篇文章 0 订阅

订阅专栏

一、分类

创建型模式：针对对象创建，实例化对象；
结构型模式：处理类或对象之间组合；
行为型模式：描述类或对象的交互及职责分配。
在这里插入图片描述

二、六大原则

在这里插入图片描述

三、应用

1.工厂方法模式

将创建对象的接口交给子类决定选择实例化。
1.1简单工厂模式：支持同基类的不同子类行为（对子类的扩展性不佳，叠加子类需更改工厂逻辑）。

/**
 * @Author xu.yao
 * @Description 普通工厂模式
 * @Date 2022/12/06 10:08
 * @Version 1.0
 */
public class TestDemo {

    public static void main(String[] args) {
        SendFactory sendFactory = new SendFactory();
        Sender sender = sendFactory.produce("sms");
        sender.Send();
    }
}

/**
 * @author: xu.yao
 * @description: 消息发送业务接口层
 * @date: 2022/12/6 11:30
 */
interface Sender {
    void Send();
}

class MailSender implements Sender {

    @Override
    public void Send() {
        System.out.println("this is mailsender!");
    }
}

class SmsSender implements Sender {

    @Override
    public void Send() {
        System.out.println("this is sms sender!");
    }
}

/**
 * @author: xu.yao
 * @description: 消息工厂
 * @date: 2022/12/6 11:30
 */
class SendFactory {

    public Sender produce(String type) {
        if ("mail".equals(type)) {
            return new MailSender();
        } else if ("sms".equals(type)) {
            return new SmsSender();
        } else {
            System.out.println("请输入正确的类型!");
            return null;
        }
    }
}

1.2工厂方法模式：支持同基类的不同子类行为（弥补简单工厂模式的缺点）。

/**
 * @Author xu.yao
 * @Description 工厂方法模式
 * @Date 2022/12/06 10:08
 * @Version 1.0
 */
public class TestDemo {

    public static void main(String[] args) {
        SendFactory sendFactory = new SendFactory();
        Sender sender = sendFactory.produceMail();
        sender.Send();
    }
}

/**
 * @author: xu.yao
 * @description: 消息发送业务接口层
 * @date: 2022/12/6 11:30
 */
interface Sender {
    void Send();
}

class MailSender implements Sender {

    @Override
    public void Send() {
        System.out.println("this is mailsender!");
    }
}

class SmsSender implements Sender {

    @Override
    public void Send() {
        System.out.println("this is sms sender!");
    }
}

/**
 * @author: xu.yao
 * @description: 消息工厂
 * @date: 2022/12/6 11:30
 */
class SendFactory {

	//补充：静态工厂方法模式即在方法上添加static，不需要实例化即可调用
	//例： public Static Sender produceMail(){
    public Sender produceMail(){ 	
        return new MailSender();
    }

    public Sender produceSms(){
        return new SmsSender();
    }
}

2.抽象工厂模式

创建相互依赖对象的接口，无需指定具体类。

/**
 * @Author xu.yao
 * @Description 抽象工厂模式
 * @Date 2022/12/06 10:08
 * @Version 1.0
 */
public class TestDemo {

    public static void main(String[] args) {
        Provider provider = new SendMailFactory();
        Sender sender = provider.produce();
        sender.Send();
    }
}

/**
 * @author: xu.yao
 * @description: 消息工厂
 * @date: 2022/12/6 11:30
 */
interface Provider {
    Sender produce();
}

class SendMailFactory implements Provider {

    @Override
    public Sender produce(){
        return new MailSender();
    }
}

class SendSmsFactory implements Provider{

    @Override
    public Sender produce() {
        return new SmsSender();
    }
}

/**
 * @author: xu.yao
 * @description: 消息发送
 * @date: 2022/12/6 11:30
 */
interface Sender {
    void Send();
}

class MailSender implements Sender {

    @Override
    public void Send() {
        System.out.println("this is mailsender!");
    }
}

class SmsSender implements Sender {

    @Override
    public void Send() {
        System.out.println("this is sms sender!");
    }
}

3.单例模式

保证一个类仅有一个实例，并提供一个访问它的全局访问点。
3.1饿汉模式

 /**
 * @description: 饿汉式
 *          是否 Lazy 初始化：否
 *           是否多线程安全：是
 * @author: xu.yao
 * @date: 2022/12/6 11:30
 */
public class EHan {

    private static EHan eHan = new EHan();

    private EHan() {
    }

    public static EHan getInstance() {
        return eHan;
    }
}

3.2懒汉模式

/**
 * @description: 懒汉式-线程安全
 *          是否 Lazy 初始化：是
 *          是否多线程安全：是
 * @author: xu.yao
 * @date: 2022/12/6 11:30
 */
public class LHanSafe {
    private static LHanSafe lHanSafe;
    private LHanSafe(){}

    public static synchronized LHanSafe getInstance(){
        if(lHanSafe == null){
            return new LHanSafe();
        }

        return lHanSafe;
    }
}

 /**
 * @description: 懒汉式-线程不安全
 *          是否 Lazy 初始化：是
 *          是否多线程安全：否
 * @author: xu.yao
 * @date: 2022/12/6 11:30
 */
public class LHanUnSafe {
    private static LHanUnSafe lHanUnSafe;
    private LHanUnSafe(){}

    public static LHanUnSafe getInstance(){
        if(lHanUnSafe == null){
            return new LHanUnSafe();
        }
        return lHanUnSafe;
    }
}

3.3双重校验锁

/**
 * @description: double-checked locking(双重校验锁)
 * 				是否 Lazy 初始化：是
 * 				是否多线程安全：是
 * @author: xu.yao
 * @date: 2022/12/6 11:30
 */
public class DoubleCheckedLockingSingletonPattern {
    private volatile static DoubleCheckedLockingSingletonPattern doubleCheckedLockingSingletonPattern;

    private DoubleCheckedLockingSingletonPattern() {
    }

    public static DoubleCheckedLockingSingletonPattern getInstance() {
        if (doubleCheckedLockingSingletonPattern == null) {
            synchronized (DoubleCheckedLockingSingletonPattern.class) {
                if (doubleCheckedLockingSingletonPattern == null) {
                    doubleCheckedLockingSingletonPattern = new DoubleCheckedLockingSingletonPattern();
                }
            }
        }
        return doubleCheckedLockingSingletonPattern;
    }
}

4.建造者模式

将很多功能集成到一个类里，这个类可以创造出比较复杂的东西。

public class Builder {  
    private List<Sender> list = new ArrayList<Sender>(); 
     
    public void produceMailSender(int count){  
        for(int i=0; i<count; i++){  
            list.add(new MailSender());  
        }  
    }  
    
    public void produceSmsSender(int count){  
        for(int i=0; i<count; i++){  
            list.add(new SmsSender());  
        }  
    }  
}

public class Test {  
    public static void main(String[] args) {  
        Builder builder = new Builder();  
        builder.produceMailSender(10);  
    }  
}

5.原型模式

思想就是将一个对象作为原型，对其进行复制、克隆，产生一个和原对象类似的新对象。

public class Prototype implements Cloneable, Serializable {  

    private static final long serialVersionUID = 1L;  
    private String string;  

    private SerializableObject obj;  

    /**
 	  * @description: 浅复制
      * @author: xu.yao
      * @date: 2022/12/6 11:30
      */
    public Object clone() throws CloneNotSupportedException {  
        Prototype proto = (Prototype) super.clone();  
        return proto;  
    }  

    /**
 	  * @description: 深复制
      * @author: xu.yao
      * @date: 2022/12/6 11:30
      */
    public Object deepClone() throws IOException, ClassNotFoundException {  
        /* 写入当前对象的二进制流 */  
        ByteArrayOutputStream bos = new ByteArrayOutputStream();  
        ObjectOutputStream oos = new ObjectOutputStream(bos);  
        oos.writeObject(this);  
        /* 读出二进制流产生的新对象 */  
        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());  
        ObjectInputStream ois = new ObjectInputStream(bis);  
        return ois.readObject();  
    }  
    public String getString() {  
        return string;  
    }  
    public void setString(String string) {  
        this.string = string;  
    }  
    public SerializableObject getObj() {  
        return obj;  
    }  
    public void setObj(SerializableObject obj) {  
        this.obj = obj;  
    }  
}  
class SerializableObject implements Serializable {  
    private static final long serialVersionUID = 1L;  
}

6.适配器模式

将类的接口转换成客户端期望的接口表示，解决接口不匹配造成的类的兼容性问题。
主要分为三类：类适配器模式、对象适配器模式、接口适配器模式。
6.1类适配器模式

class Source {  
    public void method1() {  
        System.out.println("this is original method!");  
    }  
}  

interface Targetable {  
    /* 与原类中的方法相同 */  
    public void method1();  
  
    /* 新类的方法 */  
    public void method2();  
}  

class Adapter extends Source implements Targetable {   
    @Override  
    public void method2() {  
        System.out.println("this is the targetable method!");  
    }  
}

class AdapterTest {  
    public static void main(String[] args) {  
        Targetable target = new Adapter();  
        target.method1();  
        target.method2();  
    }  
}

6.2对象适配器模式

class Source {  
    public void method1() {  
        System.out.println("this is original method!");  
    }  
}  

interface Targetable {  
    /* 与原类中的方法相同 */  
    void method1();  
  
    /* 新类的方法 */  
    void method2();  
}  

class Wrapper implements Targetable {  
  
    private Source source;  
      
    public Wrapper(Source source){  
        super();  
        this.source = source;  
    }  
    @Override  
    public void method2() {  
        System.out.println("this is the targetable method!");  
    }  
  
    @Override  
    public void method1() {  
        source.method1();  
    }  
}

class AdapterTest {   
    public static void main(String[] args) {  
        Source source = new Source();  
        Targetable target = new Wrapper(source);  
        target.method1();  
        target.method2();  
    }  
}

6.3接口适配器模式

interface Sourceable {
    void method1();

    void method2();
}

abstract class Wrapper2 implements Sourceable {
    public void method1() {
    }

    public void method2() {
    }
}

class SourceSub1 extends Wrapper2 {
    public void method1() {
        System.out.println("the sourceable interface's first Sub1!");
    }
}

class SourceSub2 extends Wrapper2 {
    public void method2() {
        System.out.println("the sourceable interface's second Sub2!");
    }
}

class WrapperTest {

    public static void main(String[] args) {
        Sourceable source1 = new SourceSub1();
        Sourceable source2 = new SourceSub2();

        source1.method1();
        source1.method2();
        source2.method1();
        source2.method2();
    }
}

7.装饰器模式

动态给对象增加功能，要求装饰对象和被装饰对象实现同一个接口，装饰对象持有被装饰对象的实例。
缺点：产生过多相似的对象，不易排错！

interface Sourceable {  
    void method();  
}  

public class Source implements Sourceable {  
  
    @Override  
    public void method() {  
        System.out.println("the original method!");  
    }  
}  

class Decorator implements Sourceable {  
  
    private Sourceable source;  
      
    public Decorator(Sourceable source){  
        super();  
        this.source = source;  
    }  
    
    @Override  
    public void method() {  
        System.out.println("before decorator!");  
        source.method();  
        System.out.println("after decorator!");  
    }  
}

class DecoratorTest {  
    public static void main(String[] args) {  
        Sourceable source = new Source();  
        Sourceable obj = new Decorator(source);  
        obj.method();  
    }  
}

8.代理模式

辅助原对象完成一部分操作。

interface Sourceable {  
    public void method();  
}  

class Source implements Sourceable {  
  
    @Override  
    public void method() {  
        System.out.println("the original method!");  
    }  
}  

class Proxy implements Sourceable {  
  
    private Source source;  
    public Proxy(){  
        super();  
        this.source = new Source();  
    }  
    @Override  
    public void method() {  
        before();  
        source.method();  
        atfer();  
    }  
    private void atfer() {  
        System.out.println("after proxy!");  
    }  
    private void before() {  
        System.out.println("before proxy!");  
    }  
}

public class ProxyTest {  
    public static void main(String[] args) {  
        Sourceable source = new Proxy();  
        source.method();  
    } 
}

9.外观模式

解决类与类之间的依赖关系。

class CPU {  
      
    public void startup(){  
        System.out.println("cpu startup!");  
    }  
      
    public void shutdown(){  
        System.out.println("cpu shutdown!");  
    }  
}  

class Memory {  
      
    public void startup(){  
        System.out.println("memory startup!");  
    }  
      
    public void shutdown(){  
        System.out.println("memory shutdown!");  
    }  
}  

class Disk {  
      
    public void startup(){  
        System.out.println("disk startup!");  
    }  
      
    public void shutdown(){  
        System.out.println("disk shutdown!");  
    }  
}  

class Computer {  
    private CPU cpu;  
    private Memory memory;  
    private Disk disk;  
      
    public Computer(){  
        cpu = new CPU();  
        memory = new Memory();  
        disk = new Disk();  
    }  
      
    public void startup(){  
        System.out.println("start the computer!");  
        cpu.startup();  
        memory.startup();  
        disk.startup();  
        System.out.println("start computer finished!");  
    }  
      
    public void shutdown(){  
        System.out.println("begin to close the computer!");  
        cpu.shutdown();  
        memory.shutdown();  
        disk.shutdown();  
        System.out.println("computer closed!");  
    }  
}

class User {  
  
    public static void main(String[] args) {  
        Computer computer = new Computer();  
        computer.startup();  
        computer.shutdown();  
    }  
}

10.桥接模式

把事务和实现分开，让其各自独立变化。

interface Sourceable {
    void method();
}

class SourceSub1 implements Sourceable {
    @Override
    public void method() {
        System.out.println("this is the first sub!");
    }
}

class SourceSub2 implements Sourceable {

    @Override
    public void method() {
        System.out.println("this is the second sub!");
    }
}

abstract class Bridge {
    private Sourceable source;

    public void method(){
        source.method();
    }

    public Sourceable getSource() {
        return source;
    }

    public void setSource(Sourceable source) {
        this.source = source;
    }
}

class MyBridge extends Bridge {
    public void method(){
        getSource().method();
    }
}

class BridgeTest {
    public static void main(String[] args) {

        Bridge bridge = new MyBridge();

        /*调用第一个对象*/
        Sourceable source1 = new SourceSub1();
        bridge.setSource(source1);
        bridge.method();

        /*调用第二个对象*/
        Sourceable source2 = new SourceSub2();
        bridge.setSource(source2);
        bridge.method();
    }
}

11.组合模式

把事务和实现分开，让其各自独立变化。

class TreeNode {  
      
    private String name;  
    private TreeNode parent;  
    private Vector<TreeNode> children = new Vector<TreeNode>();  
      
    public TreeNode(String name){  
        this.name = name;  
    }  
  
    public String getName() {  
        return name;  
    }  
  
    public void setName(String name) {  
        this.name = name;  
    }  
  
    public TreeNode getParent() {  
        return parent;  
    }  
  
    public void setParent(TreeNode parent) {  
        this.parent = parent;  
    }  
      
    //添加孩子节点  
    public void add(TreeNode node){  
        children.add(node);  
    }  
      
    //删除孩子节点  
    public void remove(TreeNode node){  
        children.remove(node);  
    }  
      
    //取得孩子节点  
    public Enumeration<TreeNode> getChildren(){  
        return children.elements();  
    }  
}  

class Tree {  
  
    TreeNode root = null;  
  
    public Tree(String name) {  
        root = new TreeNode(name);  
    }  
  
    public static void main(String[] args) {  
        Tree tree = new Tree("A");  
        TreeNode nodeB = new TreeNode("B");  
        TreeNode nodeC = new TreeNode("C");  
          
        nodeB.add(nodeC);  
        tree.root.add(nodeB);  
        System.out.println("build the tree finished!");  
    }  
}

12.享元模式

实现对象共享，即共享池，通常与工厂模式一起使用。

class ConnectionPool {  
      
    private Vector<Connection> pool;  
      
    /*公有属性*/  
    private String url = "jdbc:mysql://localhost:3306/test";  
    private String username = "root";  
    private String password = "root";  
    private String driverClassName = "com.mysql.jdbc.Driver";  
  
    private int poolSize = 100;  
    private static ConnectionPool instance = null;  
    Connection conn = null;  
  
    /*构造方法，做一些初始化工作*/  
    private ConnectionPool() {  
        pool = new Vector<Connection>(poolSize);  
  
        for (int i = 0; i < poolSize; i++) {  
            try {  
                Class.forName(driverClassName);  
                conn = DriverManager.getConnection(url, username, password);  
                pool.add(conn);  
            } catch (ClassNotFoundException e) {  
                e.printStackTrace();  
            } catch (SQLException e) {  
                e.printStackTrace();  
            }  
        }  
    }  
  
    /* 返回连接到连接池 */  
    public synchronized void release() {  
        pool.add(conn);  
    }  
  
    /* 返回连接池中的一个数据库连接 */  
    public synchronized Connection getConnection() {  
        if (pool.size() > 0) {  
            Connection conn = pool.get(0);  
            pool.remove(conn);  
            return conn;  
        } else {  
            return null;  
        }  
    }  
}

13.策略模式

定义一系列算法，封装使其可以相互替换，且算法的变换不会影响到使用算法的用户。

interface ICalculator {  
    public int calculate(String exp);  
}  

abstract class AbstractCalculator {  
      
    public int[] split(String exp,String opt){  
        String array[] = exp.split(opt);  
        int arrayInt[] = new int[2];  
        arrayInt[0] = Integer.parseInt(array[0]);  
        arrayInt[1] = Integer.parseInt(array[1]);  
        return arrayInt;  
    }  
}

class Plus extends AbstractCalculator implements ICalculator {  
  
    @Override  
    public int calculate(String exp) {  
        int arrayInt[] = split(exp,"\\+");  
        return arrayInt[0]+arrayInt[1];  
    }  
}  

class Minus extends AbstractCalculator implements ICalculator {  
  
    @Override  
    public int calculate(String exp) {  
        int arrayInt[] = split(exp,"-");  
        return arrayInt[0]-arrayInt[1];  
    }  
  
}  

class Multiply extends AbstractCalculator implements ICalculator {  
  
    @Override  
    public int calculate(String exp) {  
        int arrayInt[] = split(exp,"\\*");  
        return arrayInt[0]*arrayInt[1];  
    }  
}

class StrategyTest {  
  
    public static void main(String[] args) {  
        String exp = "2+8";  
        ICalculator cal = new Plus();  
        int result = cal.calculate(exp);  
        System.out.println(result);  
    }  
}

14.模板方法模式

一个功能的完成需要经过一系列步骤，这些步骤是固定的，但是中间某些步骤是待定的，在不同场景中行为不同。

abstract class AbstractCalculator {  
      
    /*主方法，实现对本类其它方法的调用*/  
    public final int calculate(String exp,String opt){  
        int array[] = split(exp,opt);  
        return calculate(array[0],array[1]);  
    }  
      
    /*被子类重写的方法*/  
    abstract public int calculate(int num1,int num2);  
      
    public int[] split(String exp,String opt){  
        String array[] = exp.split(opt);  
        int arrayInt[] = new int[2];  
        arrayInt[0] = Integer.parseInt(array[0]);  
        arrayInt[1] = Integer.parseInt(array[1]);  
        return arrayInt;  
    }  
}  

public class Plus extends AbstractCalculator {  
  
    @Override  
    public int calculate(int num1,int num2) {  
        return num1 + num2;  
    }  
}

class StrategyTest {  
  
    public static void main(String[] args) {  
        String exp = "8+8";  
        AbstractCalculator cal = new Plus();  
        int result = cal.calculate(exp, "\\+");  
        System.out.println(result);  
    }  
}

15.观察者模式

当对象变化时，其他依赖对象都会收到通知，并跟随变化！处理对象之间一对多的关系。

interface Observer {
    void update();
}

class Observer1 implements Observer {

    @Override
    public void update() {
        System.out.println("observer1 has received!");
    }
}

class Observer2 implements Observer {

    @Override
    public void update() {
        System.out.println("observer2 has received!");
    }

}

interface Subject {

    /*增加观察者*/
    void add(Observer observer);

    /*删除观察者*/
    void del(Observer observer);

    /*通知所有的观察者*/
    void notifyObservers();

    /*自身的操作*/
    void operation();
}

abstract class AbstractSubject implements Subject {

    private Vector<Observer> vector = new Vector<>();

    @Override
    public void add(Observer observer) {
        vector.add(observer);
    }

    @Override
    public void del(Observer observer) {
        vector.remove(observer);
    }

    @Override
    public void notifyObservers() {
        Enumeration<Observer> enumo = vector.elements();
        while (enumo.hasMoreElements()) {
            enumo.nextElement().update();
        }
    }
}

class MySubject extends AbstractSubject {

    @Override
    public void operation() {
        System.out.println("update self!");
        notifyObservers();
    }
}

class ObserverTest {

    public static void main(String[] args) {
        Subject sub = new MySubject();
        sub.add(new Observer1());
        sub.add(new Observer2());
        sub.operation();
    }
}

16.迭代子模式

当对象变化时，其他依赖对象都会收到通知，并跟随变化！处理对象之间一对多的关系。

interface Collection {  
      
    Iterator iterator();  
      
    /*取得集合元素*/  
    Object get(int i);  
      
    /*取得集合大小*/  
    int size();  
}  

interface Iterator {  
    //前移  
    Object previous();  
      
    //后移  
    Object next();  
    
    boolean hasNext();  
      
    //取得第一个元素  
    Object first();  
}

class MyCollection implements Collection {  
  
    public String string[] = {"A","B","C","D","E"};  
    @Override  
    public Iterator iterator() {  
        return new MyIterator(this);  
    }  
  
    @Override  
    public Object get(int i) {  
        return string[i];  
    }  
  
    @Override  
    public int size() {  
        return string.length;  
    }  
}  

class MyIterator implements Iterator {  
  
    private Collection collection;  
    private int pos = -1;  
      
    public MyIterator(Collection collection){  
        this.collection = collection;  
    }  
      
    @Override  
    public Object previous() {  
        if(pos > 0){  
            pos--;  
        }  
        return collection.get(pos);  
    }  
  
    @Override  
    public Object next() {  
        if(pos<collection.size()-1){  
            pos++;  
        }  
        return collection.get(pos);  
    }  
  
    @Override  
    public boolean hasNext() {  
        if(pos<collection.size()-1){  
            return true;  
        }else{  
            return false;  
        }  
    }  
  
    @Override  
    public Object first() {  
        pos = 0;  
        return collection.get(pos);  
    }  
}

class Test {  
    public static void main(String[] args) {  
        Collection collection = new MyCollection();  
        Iterator it = collection.iterator();  
          
        while(it.hasNext()){  
            System.out.println(it.next());  
        }  
    }  
}

17.责任链模式

多个对象，每个对象持有下个对象的引用。

interface Handler {  
    void operator();  
}  

abstract class AbstractHandler {  
      
    private Handler handler;  
  
    public Handler getHandler() {  
        return handler;  
    }  
  
    public void setHandler(Handler handler) {  
        this.handler = handler;  
    } 
}  

class MyHandler extends AbstractHandler implements Handler {  
  
    private String name;  
  
    public MyHandler(String name) {  
        this.name = name;  
    }  
  
    @Override  
    public void operator() {  
        System.out.println(name+"deal!");  
        if(getHandler()!=null){  
            getHandler().operator();  
        }  
    }  
}  

class Test {  
  
    public static void main(String[] args) {  
        MyHandler h1 = new MyHandler("h1");  
        MyHandler h2 = new MyHandler("h2");  
        MyHandler h3 = new MyHandler("h3");  
  
        h1.setHandler(h2);  
        h2.setHandler(h3);  
        h1.operator();  
    }  
}

18.命令模式

达到命令的发出者和执行者之间解耦，实现请求和执行分开。

/**
 * @author: xu.yao
 * @description: 命令
 * @date: 2022/12/8 13:34
 */
interface Command {
    void exe();
}

/**
 * @author: xu.yao
 * @description: 命令接收者
 * @date: 2022/12/8 13:35
 */
class Receiver {
    public void action() {
        System.out.println("command received!");
    }
}

class MyCommand implements Command {

    private Receiver receiver;

    public MyCommand(Receiver receiver) {
        this.receiver = receiver;
    }

    @Override
    public void exe() {
        receiver.action();
    }
}

class Invoker {

    private Command command;

    public Invoker(Command command) {
        this.command = command;
    }

    public void action() {
        command.exe();
    }
}

class Test {
    public static void main(String[] args) {
        Receiver receiver = new Receiver();
        Command cmd = new MyCommand(receiver);
        Invoker invoker = new Invoker(cmd);
        invoker.action();
    }
}

19.备忘录模式

保存对象的状态，以便在适当的时候恢复对象。

class Original {

    private String value;

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }

    public Original(String value) {
        this.value = value;
    }

    public Memento createMemento() {
        return new Memento(value);
    }

    public void restoreMemento(Memento memento) {
        this.value = memento.getValue();
    }
}

class Memento {

    private String value;

    public Memento(String value) {
        this.value = value;
    }

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }
}

class Storage {

    private Memento memento;

    public Storage(Memento memento) {
        this.memento = memento;
    }

    public Memento getMemento() {
        return memento;
    }

    public void setMemento(Memento memento) {
        this.memento = memento;
    }
}

class Test {

    public static void main(String[] args) {

        // 创建原始类  
        Original origi = new Original("egg");

        // 创建备忘录  
        Storage storage = new Storage(origi.createMemento());

        // 修改原始类的状态  
        System.out.println("初始化状态为：" + origi.getValue());
        origi.setValue("niu");
        System.out.println("修改后的状态为：" + origi.getValue());

        // 回复原始类的状态  
        origi.restoreMemento(storage.getMemento());
        System.out.println("恢复后的状态为：" + origi.getValue());
    }
}

20.状态模式

对象状态发生改变时，其行为也发生改变。

/**
 * 状态类的核心类
 *
 * @author xu.yao
 */
class State {

    private String value;

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }

    public void method1() {
        System.out.println("execute the first opt!");
    }

    public void method2() {
        System.out.println("execute the second opt!");
    }
}

/**
 * 状态模式的切换类
 *
 * @author xu.yao
 */
class Context {

    private State state;

    public Context(State state) {
        this.state = state;
    }

    public State getState() {
        return state;
    }

    public void setState(State state) {
        this.state = state;
    }

    public void method() {
        if (state.getValue().equals("state1")) {
            state.method1();
        } else if (state.getValue().equals("state2")) {
            state.method2();
        }
    }
}

class Test {

    public static void main(String[] args) {

        State state = new State();
        Context context = new Context(state);

        //设置第一种状态
        state.setValue("state1");
        context.method();

        //设置第二种状态
        state.setValue("state2");
        context.method();
    }
}

21.访问者模式

分离对象数据结构与行为的方法，通过这种分离，可为一个被访问者动态添加新的操作而无需做其它的修改的效果。

interface Visitor {

    void visit(Subject sub);
}

class MyVisitor implements Visitor {

    @Override
    public void visit(Subject sub) {
        System.out.println("visit the subject：" + sub.getSubject());
    }
}

interface Subject {

    void accept(Visitor visitor);

    String getSubject();
}

class MySubject implements Subject {

    @Override
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }

    @Override
    public String getSubject() {
        return "love";
    }
}

22.中介者模式

降低类类之间的耦合的，因为如果类类之间有依赖关系的话，不利于功能的拓展和维护。

interface Mediator {

    void createMediator();

    void workAll();
}

class MyMediator implements Mediator {

    private User user1;

    private User user2;

    public User getUser1() {
        return user1;
    }

    public User getUser2() {
        return user2;
    }

    @Override
    public void createMediator() {
        user1 = new User1(this);
        user2 = new User2(this);
    }

    @Override
    public void workAll() {
        user1.work();
        user2.work();
    }
}

abstract class User {

    private Mediator mediator;

    public Mediator getMediator() {
        return mediator;
    }

    public User(Mediator mediator) {
        this.mediator = mediator;
    }

    public abstract void work();
}

class User1 extends User {

    public User1(Mediator mediator) {
        super(mediator);
    }

    @Override
    public void work() {
        System.out.println("user1 exe!");
    }
}

class User2 extends User {

    public User2(Mediator mediator) {
        super(mediator);
    }

    @Override
    public void work() {
        System.out.println("user2 exe!");
    }
}

class Test {

    public static void main(String[] args) {
        Mediator mediator = new MyMediator();
        mediator.createMediator();
        mediator.workAll();
    }
}

23.解释器模式

用来做各种各样的解释器，如正则表达式等的解释器等等。

interface Expression {

    int interpret(Context context);
}

class Plus implements Expression {

    @Override
    public int interpret(Context context) {
        return context.getNum1() + context.getNum2();
    }
}

class Minus implements Expression {

    @Override
    public int interpret(Context context) {
        return context.getNum1() - context.getNum2();
    }
}

class Context {

    private int num1;
    private int num2;

    public Context(int num1, int num2) {
        this.num1 = num1;
        this.num2 = num2;
    }

    public int getNum1() {
        return num1;
    }

    public void setNum1(int num1) {
        this.num1 = num1;
    }

    public int getNum2() {
        return num2;
    }

    public void setNum2(int num2) {
        this.num2 = num2;
    }
}

class Test {

    public static void main(String[] args) {
        // 计算9+2-8的值  
        int result = new Minus().interpret((new Context(new Plus()
                .interpret(new Context(9, 2)), 8)));
        System.out.println(result);
    }
}