2. 程式人生 > >用最簡單的例子說明設計模式（三）之責任鏈、建造者、適配器、代理模式、享元模式

用最簡單的例子說明設計模式（三）之責任鏈、建造者、適配器、代理模式、享元模式

阿新 • • 發佈：2018-05-10
def dap CA 抽象 創建 tcl cte clas eth

責任鏈模式 一個請求有多個對象來處理，這些對象是一條鏈，但具體由哪個對象來處理，根據條件判斷來確定，如果不能處理會傳遞給該鏈中的下一個對象，直到有對象處理它為止 使用場景 1)有多個對象可以處理同一個請求，具體哪個對象處理該請求待運行時刻再確定 2)在不明確指定接收者的情況下，向多個對象中的一個提交一個請求 3)可動態指定一組對象處理請求，客戶端可以動態創建職責鏈來處理請求 技術分享圖片 
public class Chain {

    public abstract class Handler {
        private Handler nextHandler;
        // 當前領導能審批通過的最多天數
        public int maxDay;

        protected Handler(int maxDay) {
            this.maxDay = maxDay;
        }

        //設置責任鏈中下一個處理請求的對象
        public void setNextHandler(Handler handler) {
            nextHandler = handler;
        }

        protected void handleRequest(int day) {
            if (day <= maxDay) {
                reply(day);
            } else {
                if (nextHandler != null) {
                    //審批權限不夠，繼續上報
                    nextHandler.handleRequest(day);
                } else {
                    System.out.println("沒有更高的領導審批了");
                }
            }
        }

        protected abstract void reply(int day);
    }

    class ProjectManager extends Handler {
        public ProjectManager(int day) {
            super(day);
        }

        @Override
        protected void reply(int day) {
            System.out.println(day + "天請假，項目經理直接審批通過");
        }
    }

    class DepartmentManager extends Handler {
        public DepartmentManager(int day) {
            super(day);
        }

        @Override
        protected void reply(int day) {
            System.out.println(day + "天請假，部門經理審批通過");
        }
    }

    class GeneralManager extends Handler {
        public GeneralManager(int day) {
            super(day);
        }

        @Override
        protected void reply(int day) {
            System.out.println(day + "天請假，總經理直接審批通過");
        }
    }

    public static void main(String[] strings) {
        Chain chain = new Chain();
        Handler projectManager = chain.new ProjectManager(3);
        Handler departmentManager = chain.new DepartmentManager(5);
        Handler generalManager = chain.new GeneralManager(15);
        //創建職責鏈
        projectManager.setNextHandler(departmentManager);
        departmentManager.setNextHandler(generalManager);
        //發起請假請求
        projectManager.handleRequest(4);
    }
}

　　

Buidler（建造者）模式 一種創建型的設計模式.，通常用來將一個復雜的對象的構造過程分離, 讓使用者可以根據需要選擇創建過程.另外, 當這個復雜的對象的構造包含很多可選參數時, 也可以使用建造者模式
 
public class AlerDialog {

    private  String title;
    private  String message;

    public AlerDialog(Builder builder) {
//        View.inflate()
        this.title = builder.title;
        this.message = builder.message;
    }

    public static class Builder {
        private  String title;
        private  String message;

        public  Builder setTitle(String title) {
            this.title = title;
            return this;
        }

        public   Builder setMessage(String message) {
            this.message = message;
            return this;
        }

        public  AlerDialog build() {
            return new AlerDialog(this);
        }
    }
}
 new AlerDialog.Builder().setTitle("").setMessage("").build();

　　

適配器模式： 把一個類的接口變換成客戶端所期待的另一種接口，從而使原本因接口不匹配而無法在一起使用的類能夠一起工作。 　 適配器就是一種適配中間件，它存在於不匹配的二者之間，用於連接二者，將不匹配變得匹配，簡單點理解就是平常所見的轉接頭，轉換器之類的存在。 技術分享圖片

技術分享圖片 技術分享圖片
 類適配器 原理：通過繼承來實現適配器功能。 類適配器使用對象繼承的方式，是靜態的定義方式 對於類適配器，適配器可以重定義Adaptee的部分行為，使Adaptee有了sampleOperation2（） 對於類適配器，僅僅引入了一個對象，並不需要額外的引用來間接得 到 Adaptee 對於類適配器，由於適配器直接繼承了Adaptee，使得適配器不能和 Adaptee的子類一起工作 
public interface Target {

    void sampleOperation1();

    void sampleOperation2();
}
public class Adaptee {

    public void sampleOperation1() {
        System.out.println("sampleOperation1");
    }
}
public class Adapter extends Adaptee implements Target {

    @Override
    public void sampleOperation2() {
        System.out.println("sampleOperation2");
    }

}
public class MyClass {
    public static void main(String[] args) {
        Adapter adapter = new Adapter();
        adapter.sampleOperation1();
        adapter.sampleOperation2();
    }
}

　　


對象適配器 與類的適配器模式一樣，對象的適配器模式把被適配的類的API轉換成為目標類的API，與類的適配器模式不同的是，對象的適配器模式不是使用繼承關系連接到Adaptee類，而是使用委派關系連接到Adaptee類。 對象適配器使用對象組合的方式，是動態組合的方式 對於對象適配器，一個適配器（adaptee）可以把多種不同的源適配到同一個目標 對於對象適配器，要重定義Adaptee的行為比較困難 對於對象適配器，需要額外的引用來間接得到Adaptee。
 
public interface Target {

    void sampleOperation1();

    void sampleOperation2();
}

public class Adaptee {
    public void sampleOperation1() {
        System.out.println("sampleOperation1");
    }
}

public class Adapter implements Target {

    private Adaptee mAdaptee;

    public Adapter(Adaptee adaptee) {
        mAdaptee = adaptee;
    }

    @Override
    public void sampleOperation1() {
        mAdaptee.sampleOperation1();
    }

    @Override
    public void sampleOperation2() {
        System.out.println("sampleOperation2");
    }

}

public class MyClass {

    public static void main(String[] args) {
        Adapter adapter =new Adapter(new Adaptee());
        adapter.sampleOperation1();
        adapter.sampleOperation2();
    }
}

　　

代理模式 通過代理對象訪問目標對象.這樣做的好處是：可以在目標對象實現的基礎上，擴展目標對象的功能。在調用這個方法前作的前置處理（統一的流程代碼放到代理中處理）。調用這個方法後做後置處理。
這裏使用到編程中的一個思想:不要隨意去修改別人已經寫好的代碼或者方法,如果需改修改,可以通過代理的方式來擴展該方法。 動態代理的用途與裝飾模式很相似，就是為了對某個對象進行增強。所有使用裝飾者模式的案例都可以使用動態代理來替換。 技術分享圖片 技術分享圖片技術分享圖片技術分享圖片 
/**
 * subject（抽象主題角色）：
 * 真實主題與代理主題的共同接口。
 */
interface Subject {
    void sellBook();
}

/**
 * ReaISubject（真實主題角色）：
 * 定義了代理角色所代表的真實對象。
 */
public class RealSubject implements Subject {
    @Override
    public void sellBook() {
        System.out.println("出版社賣書");
    }
}

/**
 * Proxy（代理主題角色）：
 * 含有對真實主題角色的引用，代理角色通常在將客
 * 戶端調用傳遞給真實主題對象之前或者之後執行某些
 * 操作，而不是單純返回真實的對象。
 */
public class ProxySubject implements Subject {

    private RealSubject realSubject;

    @Override
    public void sellBook() {
        if (realSubject == null) {
            realSubject = new RealSubject();
        }
        sale();
        realSubject.sellBook();
        give();
    }

    public void sale() {
        System.out.println("打折");
    }

    public void give() {
        System.out.println("送優惠券");
    }
}

public class Main {
    public static void main(String[] args) {
        //靜態代理（我們自己靜態定義的代理類)
        ProxySubject proxySubject = new ProxySubject();
        proxySubject.sellBook();

        //動態代理(通過程序動態生成代理類，該代理類不是我們自己定義的。而是由程序自動生成)
        RealSubject realSubject = new RealSubject();
        MyHandler myHandler = new MyHandler();
        myHandler.setProxySubject(realSubject);
        Subject subject = (Subject) Proxy.newProxyInstance(realSubject.getClass().getClassLoader(),
                realSubject.getClass().getInterfaces(), myHandler);
        subject.sellBook();

    }
}

public class MyHandler implements InvocationHandler {
    private RealSubject realSubject;

    public void setProxySubject(RealSubject realSubject) {
        this.realSubject = realSubject;
    }

    /**
     * @param proxy  　指代我們所代理的那個真實對象
     * @param method   指代的是我們所要調用真實對象的某個方法的Method對象
     * @param args   　指代的是調用真實對象某個方法時接受的參數
     * @return
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        sale();
        proxy = method.invoke(realSubject, args);
        give();
        return proxy;
    }

    public void sale() {
        System.out.println("打折");
    }

    public void give() {
        System.out.println("送優惠券");
    }
}

　　

享元模式 享元的目的是為了減少不會要額內存消耗，將多個對同一對象的訪問集中起來，不必為每個訪問者創建一個單獨的對象，以此來降低內存的消耗。 
public class FlyWeight {

    static class MyString {
        private String myChar;

        public MyString(String myChar) {
            this.myChar = myChar;
        }


        public void display() {
            System.out.println(myChar);
        }
    }

    static class MyCharacterFactory {

        private Map<String, MyString> pool;

        public MyCharacterFactory() {
            pool = new HashMap<>();
        }

        public MyString getMyCharacte(String strig) {
            MyString myString = pool.get(strig);
            if (myString == null) {
                myString = new MyString(strig);
                pool.put(strig, myString);
            }
            return myString;
        }
    }

    public static void main(String[] args) {
        MyCharacterFactory myCharacterFactory = new MyCharacterFactory();
        MyString a = myCharacterFactory.getMyCharacte("a");
        MyString b = myCharacterFactory.getMyCharacte("b");
        MyString a1 = myCharacterFactory.getMyCharacte("a");
        MyString d = myCharacterFactory.getMyCharacte("d");

        if (a == a1) {
            System.out.println("true");
        }

    }
}

　　

相關源碼：https://github.com/peiniwan/DesignPattern.git

用最簡單的例子說明設計模式（三）之責任鏈、建造者、適配器、代理模式、享元模式

相關推薦

用最簡單的例子說明設計模式（三）之責任鏈、建造者、適配器、代理模式、享元模式

def dap CA 抽象 創建 tcl cte clas eth 責任鏈模式 一個請求有多個對象來處理，這些對象是一條鏈，但具體由哪個對象來處理，根據條件判斷來確定，如果不能處理會傳遞給該鏈中的下一個對象，直到有對象處理它為止 使用場景 1)有多個對象可以處理同

跟我學設計模式視頻教程——管擦者模式（下），責任鏈模式（上）

tar eight color font content 設計模式 name -m ack 課程視頻 觀察者模式（下） 責任鏈模式（上） 課程筆記 課程筆記 課程代碼 課程代碼 新課程火熱報名中 課程介紹

23種設計模式（11）：責任鏈模式

cli 傳遞 處理請求 nco 所有 lean 實現 簡單明了 concrete 定義：使多個對象都有機會處理請求，從而避免了請求的發送者和接收者之間的耦合關系。將這些對象連成一條鏈，並沿著這條鏈傳遞該請求，直到有對象處理它為止。 類型：行為類模式。 類圖： 首先來看

Java設計模式（三）之建立型模式：單例模式

一、概念： java中單例模式是一種常見的設計模式，單例模式的寫法有好幾種，這裡主要介紹三種：懶漢式單例、餓漢式單例、登記式單例。 單例模式有以下特點： （1）單例類只能有一個例項； （2）單例類必須自己建立自己的唯一例項； （3）單例類必須給所有其他物件提供這一例項。 單例

設計模式（六）：責任鏈模式

責任鏈設計模式是行為設計模式之一。 責任鏈模式用於在軟體設計中實現鬆散耦合，其中來自客戶端的請求被傳遞到物件鏈以處理它們。然後鏈中的物件將自己決定誰將處理請求以及是否需要將請求傳送到鏈中的下一個物件。 JDK中的責任鏈模式示例 讓我們看一下JDK中責任鏈模式的例子，然後我們將繼續實現這種模式的真例項子。我們

Mybatis原始碼---重寫一個最簡單的Mybatis架構實現（三）

   前兩篇文章裡，我們實現了一個簡單的Mybatis。只要願意，如果完善了後續的資料庫操作，我們完全可以用它來替換本來的Mybatis。在本篇文章裡，我們要做的是完成我們自定義Mybatis與Spring或SpringBoot整合時的自動配置。首先，我們在來熟悉一下在XML

設計模式（C#）——12責任鏈模式

推薦閱讀：  我的CSDN  我的部落格園  QQ群：704621321 前言        在開發遊戲過程中，當玩家

深入探索Java設計模式（三）之裝飾器模式

裝飾器模式使你可以在執行時使用類似於物件組成的技術來裝飾類。這在我們希望例項化具有新職責的物件而無需對基礎類進行任何程式碼更改的情況下尤其有用。本文是在學習完優銳課JAVA架構VIP課程—【框架原始碼專題】中《學習原始碼中的優秀設計模式》後寫下的學習感悟。探討了這種模式，並向你展示瞭如何使用提供的Java程式

Java設計模式（一）之建立型模式：工廠模式（簡單工廠模式+工廠方法模式）

在面向物件程式設計中, 最通常的方法是一個new操作符產生一個物件例項,new操作符就是用來構造物件例項的。但是在一些情況下, new操作符直接生成物件會帶來一些問題。舉例來說，許多型別物件的建立需要一系列的步驟：你可能需要計算或取得物件的初始位置；選擇生成哪個子物件例項；或在你生成你需要的物件

可複用面向物件軟體基礎——設計模式（一）之總覽

一、設計模式特點 反覆使用 分類編目 經驗總結 二、設計模式宗旨 程式碼重用 使程式碼易於理解 保證程式碼可靠性 三、設計模式分類（23+2） 建立型（5種） 結構型（7種） 行為型（11種） 其他（2種） （1）建立型模式 工廠

java設計模式（三）模板模式

pro str pan style coff pub 調用 類定義 ted 　　抽象類中公開定義了執行它的方法的方式，子類可以按需求重寫方法實現，但調用將以抽象類中定義的方式進行，典型應用如銀行辦理業務流程、沖泡飲料流程。下面給出簡單例子，用沸水沖泡飲料，分為四步：將水煮沸

設計模式（三）裝飾者模式Decorator

不知道 operation 總結 界面 都是 per @override stat override 　　裝飾者模式針對的問題是：對一個結構已經確定的類，在不改變該類的結構的情況下，動態增加一些功能。 　　一般來說，都是對一些已經寫好的架構增加自己的功能，或者應對多種情況，

設計模式（三）---抽象工廠模式

ava des 模式 println 5.5 mage test 抽象工廠 urn 1、 簡介：為創建一組相關或相互依賴的對象提供一個接口，無需指定它們的具體類。抽象工廠模式通常是用於創創建一族產品，並且這族產品分不同的等級；不同的具體工廠類生產不同等級的一族產品。 2、

多線程：多線程設計模式（三）：Master-Worker模式

fonts strong stat bre not 多線程 too () 部分 Master-Worker模式是常用的並行模式之一，它的核心思想是，系統有兩個進程協作工作：Master進程，負責接收和分配任務；Worker進程，負責處理子任務。當Worker進程將子任務處理

CentOS7 +vsftpd+mysql （三）之 MySql 虛用戶模式

create status success start -m figure sys conf wrapper CentOS7 +vsftpd+mysql （三）之 MySql 虛用戶模式 上篇中通過文本文件用戶列表方式對FTP用戶進行用戶管理很不方便，接下來我們用上數據庫存

設計模式（三） 工廠模式

初始化 重要 不能 還需 new 不同 參數 裏的 作用 概述： 屬於創建型設計模式，需要生成的對象叫做產品 ，生成對象的地方叫做工廠 。 使用場景： 在任何需要生成復雜對象的地方，都可以使用工廠方法模式。 直接用new可以完成的不需要用工廠模式 下面將介紹五種工廠

設計模式（三）- 狀態模式

.get TP 導致 做到 ring bubuko 對象 狀態 一個 [toc] 狀態模式 當一個對象的內在狀態改變時允許改變其行為，這個對象看起來像是改變了其類。 在平常開發自己也會遇到好多方法過長，裏面的判斷語句太多，導致後續修改十分麻煩。今天看到狀態模式的介紹，覺

設計模式（三）：適配器模式

strong imp 引入 兩個 依賴 提高 復用 三方庫 透明度 介紹 意圖：將類的接口轉換為客戶期望的另一個接口。適配器模式使得原本由於接口不兼容而不能一起工作的那些類可以一起工作。是作為兩個不兼容的接口之間的橋梁。 主要解決：主要解決在軟件系統中，常常要將一些&quo

Java設計模式（五）之建立型模式：原型模式

一、定義： 用原型例項指定建立物件的種類，並通過拷貝這些原型建立新的物件。 UML類圖： 原型模式主要用於物件的複製，它的核心是就是類圖中的原型類Prototype。Prototype類需要具備以下兩個條件： （1）實現Cloneable介面：在java語言有一個Cloneab

Java設計模式（四）之建立型模式：建造者模式

一、定義： 建造者模式將一個複雜物件的構建與表示分離，使得同樣的構建過程可以建立不同的表示。 建造者模式的UML結構圖： 建造者模式主要包含四個角色：        Builder：抽象建造者。它宣告為建立一