Android中常用設計模式

阿新 • • 發佈：2019-01-01

介紹

Java 中一般認為有 23 種設計模式，我們不需要所有的都會，但是其中常用的幾種設計模式應該去掌握。下面列出了所有的設計模式。需要掌握的設計模式我單獨列出來了，當然能掌握的越多越好。
總體來說設計模式分為三大類：

建立型模式，共五種：工廠方法模式、抽象工廠模式、單例模式、建造者模式、原型模式。

結構型模式，共七種：介面卡模式、裝飾器模式、代理模式、外觀模式、橋接模式、組合模式、享元模式。

行為型模式，共十一種：策略模式、模板方法模式、觀察者模式、迭代子模式、責任鏈模式、命令模式、備忘錄模式、狀態模式、訪問者模式、中介者模式、直譯器模式。

1、單例設計模式

最好理解的一種設計模式，分為懶漢式和餓漢式。

餓漢式：

public class Singleton {
    // 直接建立物件
    public static Singleton instance = new Singleton();
    // 私有化建構函式
    private Singleton() {
    }
    // 返回物件例項
    public static Singleton getInstance() {
        return instance;
    }
}

懶漢式：

public class Singleton {
    // 宣告變數
    private static volatile 
 Singleton singleton = null;
    // 私有建構函式
    private Singleton() {
    }
    // 提供對外方法
    public static Singleton getInstance() {
        if (singleton == null) {
            synchronized (Singleton.class) {
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return 
 singleton;
    }
}

2、工廠設計模式

工廠模式分為工廠方法模式和抽象工廠模式。

工廠方法模式

工廠方法模式分為三種：

1、普通工廠模式，就是建立一個工廠類，對實現了同一介面的一些類進行例項的建立。
2、多個工廠方法模式，是對普通工廠方法模式的改進，在普通工廠方法模式中，如果傳遞的字串出錯，則不能正確建立物件，而多個工廠方法模式是提供多個工廠方法，分別建立物件。
3、靜態工廠方法模式，將上面的多個工廠方法模式裡的方法置為靜態的，不需要建立例項，直接呼叫即可。

普通工廠模式

public interface Sender {
    public void Send();
}
public class MailSender implements Sender {
    @Override
    public void Send() {
    System.out.println("this is mail sender!");
    }
}
public class SmsSender implements Sender {
    @Override
    public void Send() {
    System.out.println("this is sms sender!");
    }
}
public 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;
        }
    }
}

多個工廠方法模式

該模式是對普通工廠方法模式的改進，在普通工廠方法模式中，如果傳遞的字元
串出錯，則不能正確建立物件，而多個工廠方法模式是提供多個工廠方法，分別
建立物件。

public class SendFactory {
    public Sender produceMail(){
        return new MailSender();
    }
    public Sender produceSms(){
        return new SmsSender();
    }
}
public class FactoryTest {
    public static void main(String[] args) {
        SendFactory factory = new SendFactory();
        Sender sender = factory.produceMail();
        sender.send();
    }
}

靜態工廠方法模式

將上面的多個工廠方法模式裡的方法置為靜態的，不需要建立例項，直接呼叫即可

public class SendFactory {
    public static Sender produceMail(){
        return new MailSender();
    }
    public static Sender produceSms(){
        return new SmsSender();
    }
}
public class FactoryTest {
    public static void main(String[] args) {
        Sender sender = SendFactory.produceMail();
        sender.send();
    }
}

抽象工廠模式

工廠方法模式有一個問題就是，類的建立依賴工廠類，也就是說，如果想要拓展程式，必須對工廠類進行修改，這違背了閉包原則，所以，從設計角度考慮，有一定的問題，如何解決？就用到抽象工廠模式，建立多個工廠類，這樣一旦需要增加新的功能，直接增加新的工廠類就可以了，不需要修改之前的程式碼。

public interface Provider {
    public Sender produce();
}

//-------------------------------------------------------------------------------------
public interface Sender {
    public void send();
}
//-------------------------------------------------------------------------------------
public class MailSender implements Sender {
    @Override
    public void send() {
        System.out.println("this is mail sender!");
    }
}
//-------------------------------------------------------------------------------------
public class SmsSender implements Sender {
    @Override
    public void send() {
        System.out.println("this is sms sender!");
    }
}
//-------------------------------------------------------------------------------------
public class SendSmsFactory implements Provider {
    @Override
    public Sender produce() {
        return new SmsSender();
    }
}

//-------------------------------------------------------------------------------------
public class SendMailFactory implements Provider {
    @Override
    public Sender produce() {
        return new MailSender();
    }
}
//-------------------------------------------------------------------------------------
public class Test {
    public static void main(String[] args) {
        Provider provider = new SendMailFactory();
        Sender sender = provider.produce();
        sender.send();
    }
}

3、建造者模式（Builder）

工廠類模式提供的是建立單個類的模式，而建造者模式則是將各種產品集中起來進行管理，用來建立複合物件，所謂複合物件就是指某個類具有不同的屬性，其實建造者模式就是前面抽象工廠模式和最後的 Test 結合起來得到的。

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 TestBuilder {
    public static void main(String[] args) {
        Builder builder = new Builder();
        builder.produceMailSender(10);
    }
}

4、介面卡設計模式

介面卡模式將某個類的介面轉換成客戶端期望的另一個介面表示，目的是消除由於介面不匹配所造成的類的相容性問題。主要分為三類：類的介面卡模式、物件的介面卡模式、介面的介面卡模式。

類的介面卡模式

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

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

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

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

物件的介面卡模式

基本思路和類的介面卡模式相同，只是將 Adapter 類作修改，這次不繼承Source 類，而是持有 Source 類的例項，以達到解決相容性的問題。

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

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

介面的介面卡模式

介面的介面卡是這樣的：有時我們寫的一個介面中有多個抽象方法，當我們寫該介面的實現類時，必須實現該介面的所有方法，這明顯有時比較浪費，因為並不是所有的方法都是我們需要的，有時只需要某一些，此處為了解決這個問題，我們引入了介面的介面卡模式，藉助於一個抽象類，該抽象類實現了該介面，實現了所有的方法，而我們不和原始的介面打交道，只和該抽象類取得聯絡，所以
我們寫一個類，繼承該抽象類，重寫我們需要的方法就行。

5、裝飾模式（Decorator）

顧名思義，裝飾模式就是給一個物件增加一些新的功能，而且是動態的，要求裝飾物件和被裝飾物件實現同一個介面，裝飾物件持有被裝飾物件的例項。

public interface Sourceable {
    public void method();
}
//----------------------------------------------------
public class Source implements Sourceable {
    @Override
    public void method() {
        System.out.println("the original method!");
    }
}
//----------------------------------------------------
public 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!");
    }
}

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

6、策略模式（strategy）

策略模式定義了一系列演算法，並將每個演算法封裝起來，使他們可以相互替換，且演算法的變化不會影響到使用演算法的客戶。需要設計一個介面，為一系列實現類提供統一的方法，多個實現類實現該介面，設計一個抽象類（可有可無，屬於輔助類），提供輔助函式。策略模式的決定權在使用者，系統本身提供不同演算法的實現，新增或者刪除演算法，對各種演算法做封裝。因此，策略模式多用在演算法決策系統中，外部使用者只需要決定用哪個演算法即可。

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

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

//---------------------------------------------------------
public class Plus extends AbstractCalculator implements ICalculator {
    @Override
    public int calculate(String exp) {
        int arrayInt[] = split(exp, "\\+");
        return arrayInt[0] + arrayInt[1];
    }
}
//--------------------------------------------------------
public 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;
    }
}
//---------------------------------------------------------
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);
    }
}

7、觀察者模式（Observer）

觀察者模式很好理解，類似於郵件訂閱和 RSS 訂閱，當我們瀏覽一些部落格或wiki 時，經常會看到 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 {
    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("update self!");
        notifyObservers();
    }
}

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

Android中常用設計模式

介紹

1、單例設計模式

2、工廠設計模式

3、建造者模式（Builder）

4、介面卡設計模式

5、裝飾模式（Decorator）

6、策略模式（strategy）

7、觀察者模式（Observer）

Android中常用設計模式

java中常用設計模式

Android中的設計模式--建造者模式

Android中的設計模式之構建者模式

Android中的設計模式--介面卡模式

Android中常用的設計模式

Android常用設計模式

android中的佈局模式以及android中的一些常用快捷鍵

Java中幾個常用設計模式

Android 原始碼中的設計模式

android原始碼中的設計模式

常用設計模式的小結和實際中的應用

Android 常用設計模式(二) -- 單例模式(詳解)

常用設計模式的實現，以及Netty中的設計模式

談談Java常用類庫中的設計模式 - Part Ⅰ

PHP常用設計模式匯總

工廠模式（think in java中的設計模式）

叠代器模式（think in java中的設計模式）

模板方法模式（think in java中的設計模式）

android深入之設計模式（一）托付模式

Android中常用設計模式

介紹

1、單例設計模式

2、工廠設計模式

3、建造者模式（Builder）

4、介面卡設計模式

5、裝飾模式（Decorator）

6、策略模式（strategy）

7、觀察者模式（Observer）

相關推薦