三、装饰者模式_策略模式_观察者模式

1、装饰模式：
    就是给一个对象增加一些新的功能，并且是动态的，要求装饰对象和被装对象实现同一个接口。装饰对象持有被装饰对象的实例。
装饰者模式中的要求：
 1) 装饰者和被装饰则应该实现同一个类；
 2) 装饰者含有被装饰者的引用
 3) 一个类含有另一个类明显的关联关系
 4) 装饰者和被装饰者里面的方法一定要一样，为什么要这样做？是为了保障这两个类具有相同的方法
装饰者模式比继承更能降低代码的耦合度，有利于项目的扩展；

public class DecoratorTest {
    public static void main(String[] args) {
        FileReader fReader = new FileReader();//创建被装饰者
        BufferedReader brReader = new BufferedReader(fReader);//创建装饰者
        brReader.close();//通过执行装饰者中的方法间接去执行被装饰者中的方法。
    }
}

abstract class Reader {
    public abstract void close();
}

class FileReader extends Reader {// FileReader 是被装饰者
    @Override
    public void close() {
        System.out.println("FileReader类中的重写的close方法执行");
    }
}

class BufferedReader extends Reader {// BufferedReader是装饰者
    FileReader fileReader;// 一个类含有另一个类明显的关联关系

    public BufferedReader(FileReader fileReader) {// 装饰者模式中要求，装饰者含有被装饰者的引用
        this.fileReader = fileReader;
    }

    @Override
    public void close() {
        System.out.println("扩展代码1");// 什么是扩展就是在源代码执行的基础之上，加一些代码，这就是扩展
        fileReader.close();
        System.out.println("扩展代码2");
    }
}

 运行结果：

扩展代码1
FileReader类中的重写的close方法执行
扩展代码2

2、策略模式:
    定义了一系列算法，并将每个算法封装起来，使他们可以相互替换，且算法的变化不会影响到使用算法的客户。需要设计一个接口，为一系列实现类提供统一的方法，多个实现类实现该接口，设计一个抽象类（可有可无，属于辅助类），提供辅助函数。
    策略模式的决定权在用户，系统本身提供不同算法的实现，新增或者删除算法，对各种算法做封装。因此，策略模式多用在算法决策系统中，外部用户只需要决定用哪个算法即可。

public 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);
    }
}
//定义算法接口：为一系列实现类提供统一的方法，多个实现类实现该接口
interface ICalculator {
    public int calculate(String exp);
}
//定义一个抽象类：提供辅助函数，（可有可无，属于辅助类）。
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 Minus extends AbstractCalculator implements ICalculator {

    public int calculate(String exp) {
        int arrayInt[] = split(exp, "-");
        return arrayInt[0] - arrayInt[1];
    }
}

class Plus extends AbstractCalculator implements ICalculator {

    public int calculate(String exp) {
        int arrayInt[] = split(exp, "\+");
        return arrayInt[0] + arrayInt[1];
    }
}

运行结果：10
3、观察者模式:
    类似于邮件订阅和 RSS 订阅，当我们浏览一些博客或 wiki 时，经常会看到 RSS 图标，就这的意思是，当你订阅了该文章，如果后续有更新，会及时通知你。其实，简单来讲就一句话：当一个对象变化时，其它依赖该对象的对象都会收到通知，并且随着变化！对象之间是一种一对多的关系。
下面示列含义：MySubject 自己发生变化之后，会通知关注MySubject的对象Observer1、Observer2

import java.util.Enumeration;
import java.util.Vector;

public class ObserverTest {
    /**
     * @param args
     */
    public static void main(String[] args) {
        Subject sub = new MySubject();
        sub.add(new Observer1());
        sub.add(new Observer2());
        sub.operation();
        int x = 0;
        int y = 10;
        do {
            y--;
            ++x;
        } while (x < 6);
        System.out.println(x + ',' + y);
    }

}

interface Observer {
    public void update();
}

class Observer1 implements Observer {
    public void update() {
        System.out.println("observer1 has received!");
    }
}

class Observer2 implements Observer {
    public void update() {
        System.out.println("observer2 has received!");
    }
}

interface Subject {
    /* 增加观察者 */
    public void add(Observer observer);

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

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

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

abstract class AbstractSubject implements Subject {
    //Vector 类可以实现可增长的对象数组
    private Vector<Observer> vector = new Vector<Observer>();

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

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

    public void notifyObservers() {
        Enumeration<Observer> enumo = vector.elements();// elements()
        // 返回此向量的组件的枚举。
        while (enumo.hasMoreElements()) {
            enumo.nextElement().update();
        }
    }
}

class MySubject extends AbstractSubject {
    public void operation() {
        System.out.println("update self!");
        notifyObservers();
    }
}

运行结果：

update self!
observer1 has received!
observer2 has received!
54