設計模式

設計模式的分類
總體來說設計模式分爲三大類：
創建型模式，共5種： 工廠方法模式、抽象工廠模式、單例模式、建造者模式、原型模式。
結構型模式，共7種： 適配器模式、裝飾器模式、代理模式、外觀模式、橋接模式、組合模式、享元模式。
行爲型模式，共11種：策略模式、*模板方法模式、觀察者模式*、迭代子模式、責任鏈模式、命令模式、
備忘錄模式、狀態模式、訪問者模式、中介者模式、解釋器模式。
1、單例(掌握)
概述：內存中只能存在一個該類的對象
餓漢式：對象的初始化過程在類加載的時候就已經完成
懶漢式：調用方法的時候再創建對象,需要注意線程安全問題

開發中建議使用餓漢式，面試兩種都要說明

/**
 * 餓漢式:對象的初始化過程在類加載的時候就已經完成
 * 在開發中建議使用
 */
 public class Singleton{
 //直接創建對象
 public static Singleton instance = new Singleton();
 //私有化構造函數
 private Singleton(){
 }
 //返回對象實例
 public static Singleton getInstance(){
 return instance;
 }
}

/**
 * 懶漢式:調用方法的時候再創建使用
 */
public class Configuration {
       private static Configuration conf = null;
       public static synchronized Configuration getInstance(){
              if(conf ==null){
                     conf = newConfiguration();
              }
              return conf;
       }
       privateConfiguration(){
       }
}

2、工廠模式
概述
創建對象的事情，可能比較複雜的，所以創建對象的這個邏輯我們應該定義到專門的一個類裏面，這個類專門負責創建各種對象實例，那麼這個類就被稱爲工廠類

簡單工廠和工廠模式的區別
簡單工廠：一個工廠可以創建多個對象，如果要添加對象，那應該修改工廠.簡單工廠模式中的工廠類一般是使用靜態方法，通過接收的參數的不同來返回2不同的對象實例。不修改代碼無法擴展
工廠模式：一個工廠對應一個對象，換句話說 一個工廠只能創建一個對象，如果我要創建這個對象，第一步應該先創建工廠對象，然後通過工廠對象來創建對象。如果要添加對象，只需要再新增一個工廠即可，更符合開閉原則

比如說，我們現在有很多動物類，貓，狗，豬 …
而這些動物有相同的行爲， eat()。
抽取一個共同的父類。動物。
簡單工廠模式：
Animal
|–Dog
|–Cat

  AnimalFactory
                 public static Animal createAnimal(String type){
                      if("dog".equals(type)){
                            return new Dog();
                      }else if("cat".equals(type)){
                            return new Cat();
                      }else {
                            return null;
                      }
                 }  

     工廠方法模式：
      Animal
             |--Dog
             |--Cat
             |--Pig

       AnimalFactory
             |--DogFactory
             |--CatFactory
             |--PigFactory

多個工廠模式

3、包裝設計模式(掌握)
概述
對一個已知類，類的原始行爲要保留住而且對於某一個方法或者給類增加一些新的內容，這種情況下使用包裝設計模式
編寫步驟
1、編寫一個類，繼承被包裝類
2、在包裝類中定義一個變量temp這個變量的類型是被包裝類
3、定義構造方法，通過構造方法初始化temp
4、改寫需要增強的方法
5、對於不需要增強的方法，調用原有對象的方法

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class MyBufferedReader extends BufferedReader{
       private BufferedReader br ;
       private int number= 1;
       public MyBufferedReader(BufferedReader br){
              super(br);
              this.br = br;
       }

       public String readLine() throws IOException{
              if(br.readLine() == null)
                     return null;
              return number+++br.readLine();
       }

       public static void main(String[] args) throws Exception {

              MyBufferedReader reader = new MyBufferedReader(new BufferedReader(new FileReader("d://giftsstore.log")));

              String line = null;
              while((line=reader.readLine()) != null){
                     System.out.println(line);
              }
       }
}

4、模板設計模式
概述：
模版設計模式中，將工作的主體架構規定好，具體類可以根據自己的需要，各自去實現
模板類最好是一個抽象類，裏面包含抽象方法和非抽象方法
5.觀察者模式
觀察者模式類似於郵件訂閱和RSS訂閱，當你訂閱了該文章，如果後續有更新會及時通知你。其實，簡單的說就一句話：當一個對象變化時，其他依賴該對象的對象都會收到通知，並且隨着變化。對象之間是一種一對多的關係。

public interface Observer{
      public void update();
    }

    //定義兩個觀察者實現接口
    public class Observer1 implements Observer{
        @Override
        public void update() {
            System.out.println("Observer1 has received！");
        }
    }

    public class Observer2 implements Observer{
        @Override
        public void update() {
            System.out.println("Observer2 has received！");
        }
    }

    public interface Subject{
        /*增加觀察者*/
        public void add(Observer  observer);
        /*刪除觀察者*/
        public void del(Observer  observer);
        /*通知所有觀察者*/
        public void notifyObservers();
        /*操作自身*/
        public void operation();
    }
    /*定義抽象類實現某個類*/
    public abstract class AbstractSubject implements Subject{
        //創建一個私有的 廣播變量 vector
        private Vector<Observer> vector = new Vector<Observer>();

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

    public class MySubject extends AbstractSubject{

        @Override
        public void operation() {
            System.out.println("更新自身");
            notifyObservers();
        }

    }

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