3、裝飾者模式_策略模式_觀察者模式

一、裝飾模式：
    就是給一個對象增長一些新的功能，而且是動態的，要求裝飾對象和被裝對象實現同一個接口。裝飾對象持有被裝飾對象的實例。
裝飾者模式中的要求：
 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");
    }
}

View Code

 運行結果：

擴展代碼1
FileReader類中的重寫的close方法執行
擴展代碼2

View Code

二、策略模式:
    定義了一系列算法，並將每一個算法封裝起來，使他們能夠相互替換，且算法的變化不會影響到使用算法的客戶。須要設計一個接口，爲一系列實現類提供統一的方法，多個實現類實現該接口，設計一個抽象類（無關緊要，屬於輔助類），提供輔助函數。
    策略模式的決定權在用戶，系統自己提供不一樣算法的實現，新增或者刪除算法，對各類算法作封裝。所以，策略模式多用在算法決策系統中，外部用戶只須要決定用哪一個算法便可。

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

View Code

運行結果：10
三、觀察者模式:
    相似於郵件訂閱和 RSS 訂閱，當咱們瀏覽一些博客或 wiki 時，常常會看到 RSS 圖標，就這的意思是，當你訂閱了該文章，若是後續有更新，會及時通知你。其實，簡單來說就一句話：當一個對象變化時，其它依賴該對象的對象都會收到通知，而且隨着變化！對象之間是一種一對多的關係。
下面示列含義：MySubject 本身發生變化以後，會通知關注MySubject的對象Observer一、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();
    }
}

View Code

運行結果：

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

View Code