• <ins id="pjuwb"></ins>
    <blockquote id="pjuwb"><pre id="pjuwb"></pre></blockquote>
    <noscript id="pjuwb"></noscript>
          <sup id="pjuwb"><pre id="pjuwb"></pre></sup>
            <dd id="pjuwb"></dd>
            <abbr id="pjuwb"></abbr>

            積木

            No sub title

              C++博客 :: 首頁 :: 聯(lián)系 :: 聚合  :: 管理
              140 Posts :: 1 Stories :: 11 Comments :: 0 Trackbacks

            常用鏈接

            留言簿(1)

            我參與的團隊

            搜索

            •  

            最新評論

            閱讀排行榜

            評論排行榜

            #

            Facade模式

             (Facade模式)門面模式與Proxy模式其實還是有點相似的。也是主要實現(xiàn)一種功能的封裝。Facade模式,主要是將幾個有相關(guān)性的功能操作,封裝到一起,由統(tǒng)一的接口提供。
            使用時,通過該接口即可完成所有相關(guān)的功能。此有個好處,就是提高解耦性與增加高聚性。實現(xiàn)中,查處問題也相對方便。
             簡單,代碼不就給了。

            posted @ 2011-05-20 00:39 Jacc.Kim 閱讀(337) | 評論 (0)編輯 收藏

             

            十:Flyweight模式(即:享元模式)

             說的直觀點,F(xiàn)lyweight模式其實就是實現(xiàn)一個對象緩存池。取對象,優(yōu)先從該池中取出。而它們的區(qū)別在于:從前者中取東西時,如果不存在。則可以新產(chǎn)生一個,并返回。
            而從后者中取時,存在就返回,不存在,就返回為空。
             由上面的解釋,不難想象,該模式的實現(xiàn):
            class Flyweight
            {
            public:
             ...
            };

            class SubFlyweightObjX : public Flyweight
            {
            ...
            };

            class SubFlyweightObjY : public Flyweight
            {
            ...
            };

            //Flyweight類的結(jié)構(gòu)
            class FlyweightBuffFactory
            {
            public:
             Flyweight* GetFlyweight(...condition...)
             {
              for (vector<Flyweight* >::iterator iter = m_vBuffer.begin(); iter != m_vBuffer.end(); iter++)
              {
               if (iter.xxx = condition)
                return (Flyweight*)iter;//注:如果此句不行用這句:return (Flyweight*)(&(*iter));
              }
              Flyweight* pReturn = new xxx;
              m_vBuffer.push_back(pReturn);
              return pReturn;
             }

            private:
             vector<Flyweight* > m_vBuffer;
            };

            posted @ 2011-05-20 00:38 Jacc.Kim 閱讀(256) | 評論 (0)編輯 收藏

            Proxy模式

             代理模式其,思想倒類似于封裝的概念。主要是將某功能操作通過另一對象,來全權(quán)處理。對
            被代理的對象,它不管你是如何處理。它只要結(jié)果。比如:對數(shù)據(jù)的提取。原本可能要經(jīng)過N個對象共
            同配合,最終取得數(shù)據(jù)。此時,可以用一個代理對象,來全權(quán)處理之。又比如說:我們上網(wǎng),打開網(wǎng)頁,
            可以通過windows的網(wǎng)絡(luò)功能模塊,去解析,并最終打開網(wǎng)頁。同時也可以通過代理,解析并最終打開網(wǎng)
            頁。

             下面是參考代碼
            class Subject
            {
            public:
             virtual void Request() = 0;
            protected:
             Subject(){}
            };

            class ImplSubject
            {
            public:
             virtual void Request(){ //....}
            };

            class Proxy
            {
            public:
             Proxy(){}
             Proxy(Subject* sub){m_pSub = sub;}
            private:
             Subject* m_pSub;
             void Request(){ m_pSub->Request();}
            };

            int main(int argc, char* argv[])
            {
             Subject* sub = new ImplSubject();
             Proxy* p = new Proxy(sub);
             p->Request();
             return 0;
            }

            posted @ 2011-05-20 00:38 Jacc.Kim 閱讀(445) | 評論 (0)編輯 收藏

            九:Decorator模式(即:裝飾模式)

             (注2)假設(shè)有這樣的一個問題存在(其實現(xiàn)實開發(fā)中,非常經(jīng)常遇到):基類BasicClassX有N個的派生類。因為它們沒有功能接口void UnknowFunction(void);
            按正常的。我們的處理方法,(1) 可以通過直接修改BasicClassX基類,在此添加virtual void UnknowFunction(void);虛接口并實現(xiàn),然后所有derived
            class中均可見。(2) 又或是在BasicClassX基類,添加了純虛接口,然后在具體某派生類中進行了實現(xiàn)。在實現(xiàn)使用中,用該derived class來處理。
             (注3)但這樣做會有這樣的問題存在:a) 會有可能讓繼承的深度,變的很深。系統(tǒng)的類將變的很多,很復(fù)雜。b) 類的結(jié)構(gòu)也將變的復(fù)雜化。(因為現(xiàn)
            在是增加個接口,以后要是又有其他的接口功能需要添加了???) c) 無形中,會加重基類的負擔(dān)。因為必須得保證擴展該接口,否則基類看不到該接
            口。
             (注1)為了解決上面的問題。Decorator模式就可以幫助我們很輕松地解決。我們實現(xiàn)一個Decorator類。該類,只要引用一個BasicClassX指針對象即可。
            然后在Decorator類中,擴展功能接口,這樣,新擴展的功能就與BasicClassX的相關(guān)類,無任何關(guān)系。只是在BasicClassX相關(guān)類需要該擴展接口的地方,
            使用Decorator類來處理即可。就相當于BasicClassX的對象(或是它的derived class object)委托Decorator來實現(xiàn)處理一樣。但又同時像是將BasicClassX
            對象與Decorator對象進行組合在一起使用。從而達到新接口的擴展作用。Decorator模式就是這么回事。
             下面簡要提煉下Decorator類的設(shè)計
             SubClassA : BasicClassX;
             SubClassB : BasicClassX;
             SubClassC : SubClassA;
             ...
             SubClassN : ... : BasicClassX;

             class Decorator : BasicClassX
             {
             public:
              Decorator(BasicClassX* pBObj){m_pBOjb = pBObj;}
              void DoOperate(void)
              {
               m_pBObj->DoOperator();
               // do new interface
               this->DoNewInterfaceFunction();
              }
              //new extened interface function
              void DoNewInterfaceFunction(void){//do something...}
              // new extened other interface function
              ...
              
              //write down other code in here you knowned.
              ...
             private:
              BasicClassX* m_pBObj;
             }
             個人認為,Decorator模式,你說它有用。它確實有用。說它沒用。其實它也沒用。為啥這樣說了?因為它完全可以通過,繼承,或者直接修改原有的類體系來
            實現(xiàn)。但它的存在,也確實會讓系統(tǒng)的思路清晰些。至少代碼相對不會那么亂。

            posted @ 2011-05-20 00:35 Jacc.Kim 閱讀(246) | 評論 (0)編輯 收藏

            設(shè)計模式學(xué)習(xí)總結(jié)之六

            八:Composite模式(即:復(fù)合模式)

             復(fù)合模式旨在將遞歸處理,轉(zhuǎn)化為一種順序處理。明顯地,遞歸處理,相對較耗資源。也相對較為抽象些。而用一個Composite類對象來轉(zhuǎn)化處理
            遞歸處理。將顯得直觀些。它與Decorator模式的區(qū)別是:Composite模式,旨在構(gòu)造一個類。這個類,將原本是遞歸組織的樹狀結(jié)構(gòu),轉(zhuǎn)換為直觀地轉(zhuǎn)化為
            順序結(jié)構(gòu)。即:它重要于轉(zhuǎn)化表現(xiàn)。而Decorator模式(即:修飾模式),其重要簡化管理原本系統(tǒng)類體系結(jié)構(gòu)。不至于將類繼承體系越來越深。同時,不
            至于讓原本設(shè)計好的類,越來越復(fù)雜化。同時又可以為原本類體系添加新的功能(即:書上所述的新的職責(zé))。

             下面簡要看下該模式的代碼結(jié)構(gòu):

            class ClassNode
            {
            public:
             //寫下構(gòu)造函數(shù)等
             ...
            public:
             virtual void Operation(void);
             virtual void Add(ClassNode* pNode);
             virtual void Remove(ClassNode* pNode);
             virtual ClassNode* GetNode(int iIndex);
            }

            //Composite類
            class Composite : public ClassNode
            {
            public:
             typedef vector<ClassNode* > NODELISTVEC;
            public:
             void Operation(void)
             {
              for (NODELISTVEC::iterator iter = m_vNodeList.begin(); iter != m_vNodeList.end(); iter++)
               iter->Operation();
             }
             void Add(ClassNode* pNode){//do something...}
             void Remove(ClassNode* pNode){//do something...}
             ClassNode* GetNode(int iIndex){//do something...}
            private:
             NODELISTVEC m_vNodeList;
            }

            //調(diào)用
            int main(int argc, char* argv[])
            {
             Composite* MyCompositeForNodes = new ...;
             ClassNode* xxx = new ...;//創(chuàng)建節(jié)點。當然這里只是為了演示,所以只創(chuàng)建一個節(jié)點。一棵樹有可能有N個節(jié)點。
             MyCom,positeForNodes.Add(xxx );
             ...
             MyCompositeForNodes.Operation();
            }

            //個人認為,該模式,很怪啊。。因為通過這樣轉(zhuǎn)換后,原本的父子關(guān)系就被破壞掉了。
            //如果有大俠理解的深的話,,還請不吝補充下。。不盛感激。

            posted @ 2011-05-18 00:46 Jacc.Kim 閱讀(268) | 評論 (0)編輯 收藏

            設(shè)計模式學(xué)習(xí)總結(jié)之五

            七:Decorator模式(即:裝飾模式)

             (注2)假設(shè)有這樣的一個問題存在(其實現(xiàn)實開發(fā)中,非常經(jīng)常遇到):基類BasicClassX有N個的派生類。因為它們沒有功能接口void UnknowFunction(void);
            按正常的。我們的處理方法,(1) 可以通過直接修改BasicClassX基類,在此添加virtual void UnknowFunction(void);虛接口并實現(xiàn),然后所有derived
            class中均可見。(2) 又或是在BasicClassX基類,添加了純虛接口,然后在具體某派生類中進行了實現(xiàn)。在實現(xiàn)使用中,用該derived class來處理。
             (注3)但這樣做會有這樣的問題存在:a) 會有可能讓繼承的深度,變的很深。系統(tǒng)的類將變的很多,很復(fù)雜。b) 類的結(jié)構(gòu)也將變的復(fù)雜化。(因為現(xiàn)
            在是增加個接口,以后要是又有其他的接口功能需要添加了???) c) 無形中,會加重基類的負擔(dān)。因為必須得保證擴展該接口,否則基類看不到該接
            口。
             (注1)為了解決上面的問題。Decorator模式就可以幫助我們很輕松地解決。我們實現(xiàn)一個Decorator類。該類,只要引用一個BasicClassX指針對象即可。
            然后在Decorator類中,擴展功能接口,這樣,新擴展的功能就與BasicClassX的相關(guān)類,無任何關(guān)系。只是在BasicClassX相關(guān)類需要該擴展接口的地方,
            使用Decorator類來處理即可。就相當于BasicClassX的對象(或是它的derived class object)委托Decorator來實現(xiàn)處理一樣。但又同時像是將BasicClassX
            對象與Decorator對象進行組合在一起使用。從而達到新接口的擴展作用。Decorator模式就是這么回事。
             下面簡要提煉下Decorator類的設(shè)計
             SubClassA : BasicClassX;
             SubClassB : BasicClassX;
             SubClassC : SubClassA;
             ...
             SubClassN : ... : BasicClassX;

             class Decorator : BasicClassX
             {
             public:
              Decorator(BasicClassX* pBObj){m_pBOjb = pBObj;}
              void DoOperate(void)
              {
               m_pBObj->DoOperator();
               // do new interface
               this->DoNewInterfaceFunction();
              }
              //new extened interface function
              void DoNewInterfaceFunction(void){//do something...}
              // new extened other interface function
              ...
              
              //write down other code in here you knowned.
              ...
             private:
              BasicClassX* m_pBObj;
             }
             個人認為,Decorator模式,你說它有用。它確實有用。說它沒用。其實它也沒用。為啥這樣說了?因為它完全可以通過,繼承,或者直接修改原有的類體系來
            實現(xiàn)。但它的存在,也確實會讓系統(tǒng)的思路清晰些。至少代碼相對不會那么亂。

            posted @ 2011-05-17 01:16 Jacc.Kim 閱讀(303) | 評論 (0)編輯 收藏

            設(shè)計模式學(xué)習(xí)總結(jié)之四

            六:Bridge模式(即:橋接模式)

             講之前,先聲明:由于本人電腦不是很好,沒法裝上vc環(huán)境運行。因此以下代碼,僅是手工輸入,在環(huán)境中未必能編譯通過。
            但以下,僅僅只是介紹一種思想。僅供參考。同時,如果說明有誤之處,歡迎指正。另外,則于一次性手工輸入下面那么多東東,確實
            不容易,所以Delphi的具體實現(xiàn)。就不在此列出。如有興趣用Delphi實現(xiàn)的朋友,也可以找本人交流,本人盛感榮幸。
            (當然如果是C++的朋友也同樣、甚至更加歡迎)

             看了這么多次的橋接模式,這次總算明白了。要想理解橋接模式,個人認為,還是有必要同抽象及其實現(xiàn)進行一下比較。
             1) 抽象及實現(xiàn)。我相信,跟不同的人說話,都會有訣竅在里頭。同是coder,相信,最默契的溝通,還是code吧。我們來看下抽象及其實現(xiàn)的代碼。
            //抽象基類聲明
            class AbstractClassX
            {
            private:
             //xxx
            protected:
             //xxx
            public:
             //xxx
             void DoSomething(void) = 0;
             //xxx
            }

            //AbstractClassX的具體實現(xiàn) ClassXImplX1
            class ClassXImplX1 : public AbstractClassX
            {
            ....
            public:
             void DoSomething(void){ // do something with method 1... }
            }

            //AbstractClassX的具體實現(xiàn) ClassXImplX2
            class ClassXImplX2 : public AbstractClassX
            {
            ....
            public:
             void DoSomething(void){ // do something with method 2... }
            }

             在實際應(yīng)用中,我們用的是抽象類。而實際上實例化的,卻是某具體子類。這種實現(xiàn)被我們多數(shù)人所使用。而它實際上解決的只是這么一類問題,即:同一行為的不同表現(xiàn)。當
            然大多數(shù)需求,用此就可以了。
             但現(xiàn)在假如說有這么一種情況:假如說,上面的處理僅僅只適用于平臺A,而用戶卻希望同時,它也要能夠在平臺B上也能夠一樣的操作。那當如何?
            很明顯的,此種需要,并不是行為上的需求,因為不論是在平臺A上還是平臺B上,都要執(zhí)行相同的操作。而且表示也是一樣的。該需要的實現(xiàn)。實際上是需要我們重新封裝個抽象層,
            來專門處理平臺B上的該行為。而實際的實現(xiàn),卻還是跟平臺A上的一樣。其實我們仔細一想。其實平臺A了的抽象(即:AbstractClassX)與平臺B上的抽象(假如為:AbstractClassY),
            其實它們是類似的。因為需要處理的功能一樣。因此,我們就想,如果將這種抽象與實現(xiàn)具體分離開來。在抽象中,留個具體實現(xiàn)的抽象引用(此其實就是該模式所指的Bridge----即:橋
            通過該橋,將抽象與具體的實現(xiàn)連接起來。因此,我想該模式的名稱就是因此得來的吧)。那樣。抽象可以不受限制的擴展,實現(xiàn)也同樣可以不受限制的擴展。這樣,系統(tǒng)的框架就不需要
            更改,其不妙哉?!因此就有了如下的code

            //******************************************************************
            //* 抽象聲明及抽象部分的實現(xiàn)
            //******************************************************************
            //抽象的抽象基類聲明
            class AbstractClass
            {
            private:
             //xxx
            protected:
             AbstractImpl* m_pAIObj; //具體的抽象實現(xiàn)的抽象對象(這話很ao口,但理解了這話,也就理解了該模式。可以大言不慚地說,該模式的秘密就在這句話上)
             //xxx
            public:
             //xxx
             void DoSomething(void) = 0;
             //xxx
            }

            //平臺A上的抽象的具體實現(xiàn)(注意:此實現(xiàn)子類,是針對抽象的)
            class AbstractClassA : public AbstractClass
            {
            private:
             //xxx
            protected:
             //xxx
            public:
             //xxx
             void DoSomething(void) { m_pAIObj.DoSomething(); }
             //xxx
            }

            //平臺B上的抽象的具體實現(xiàn)(注意:此實現(xiàn)子類,是針對抽象的)
            class AbstractClassB : public AbstractClass
            {
            private:
             //xxx
            protected:
             //xxx
            public:
             //xxx
             void DoSomething(void) { m_pAIObj.DoSomething(); }
             //xxx
            }

            //******************************************************************
            //* 實現(xiàn)的抽象聲明及其實現(xiàn)
            //******************************************************************
            //實現(xiàn)部分的抽象基類聲明
            class AbstractImplClass
            {
            private:
             //xxx
            protected:
             //xxx
            public:
             //xxx
             void DoSomething(void) = 0;
             //xxx
            }

            //具體算法1的具體實現(xiàn)
            class ImplX : public AbstractImplClass
            {
            private:
             //xxx
            protected:
             //xxx
            public:
             //xxx
             void DoSomething(void) { // do something... }
             //xxx
            }

            //具體算法1的具體實現(xiàn)
            class ImplY : public AbstractImplClass
            {
            private:
             //xxx
            protected:
             //xxx
            public:
             //xxx
             void DoSomething(void) { // do something... }
             //xxx
            }

            //******************************************************************
            //* 實際應(yīng)用方面
            //******************************************************************

            int main(int argc, char* argv[])
            {
             AbstractImplClass* pImplObj = new ImplX();//或new ImplY();等等。
             //下面注意下:因為上面的代碼中,本人為了簡寫,并沒有明確寫出抽象部分的具體構(gòu)造函數(shù)。
             //相信,是程序員,看完下面這行都懂得,上面的抽象部分的聲明,應(yīng)該聲明一個什么樣的
             //構(gòu)造函數(shù)吧。
             AbstractClass* pAbstractObj = new AbstractClassA(pImplObj);//或new AbstractClassB(pImplObj);等等。

             //do other something...

             //在此補充一點:有上面的設(shè)計,系統(tǒng)的框架將都無需修改。不論是實現(xiàn)的具體算法改變了,還是
             //抽象的需求變動。程序都無需要修改框架代碼,,僅僅只需要寫個具體的實現(xiàn)類(不管是實現(xiàn)的實現(xiàn)類,還是
             //抽象的實現(xiàn)類)即可。這就是橋接模式。
            }

            posted @ 2011-05-16 00:42 Jacc.Kim 閱讀(227) | 評論 (0)編輯 收藏

            設(shè)計模式學(xué)習(xí)總結(jié)之三

            五:Prototype模式(即:原型模式)

             此模式其實很簡單,主要就是通過“克隆”的技術(shù),來產(chǎn)生出新的對象來。其與抽象工廠模式以及Builder模式的區(qū)別是:抽象工廠模式式,主要用來產(chǎn)生多個有相互依賴關(guān)系的對象的創(chuàng)建。
            而構(gòu)建模式則主要用來處理一個復(fù)雜模塊的一步步構(gòu)建工作。原型模式,則注重通過自身,來復(fù)制出一份與自身一樣的實例對象來。原型本身也有點類似一個抽象工廠。
             原型模式常用的接口一般有:Clone(); Asign(); 還有拷貝構(gòu)造函數(shù)。(對Delphi來說,主要還是前兩種方法)

             前面一至五,可被歸納為:創(chuàng)建型模式

            posted @ 2011-05-15 15:48 Jacc.Kim 閱讀(263) | 評論 (0)編輯 收藏

            設(shè)計模式學(xué)習(xí)總結(jié)之二

            三:Singleton模式(單實例模式)

             顧名思義,即單例模式。其主要思想就是在項目中,僅創(chuàng)建一個實例對象。該對象的抽象,除了通過指定的獲取實例接口外,再沒其他辦法可以初始化。
            此可以保證整個系統(tǒng)生命周期內(nèi),僅會有一個實例存在。可以想象一下,它是可以與先前說的工廠模式或抽象工廠模式結(jié)合使用的。因為一般來說,工廠可能只會
            有一個(至少對某種邏輯處理來說是這樣的)。
             在C++中,實現(xiàn)單例模式,相對比較直觀及合理。將該實例定義成static成員即可。并提供獲取及釋放該成員的接口。而在delphi中,(就本來的了解來說)
            似乎并沒有直觀的靜態(tài)成員這一說法。但可以定義一個全局變量,并提供獲取與釋放變量的接口來模擬。(但,畢竟沒辦法同類型的實例被創(chuàng)建出來,所以最好要加
            詳細注釋說明。告知其他組員,此為單實例)

             參考的c++實現(xiàn):
             class CA
             {
             private:
              CA(){}
             private:
              static CA* m_pAObj;
             public:
              virtual ~CA(){}
              static CA* GetAObj(void)
              {
               if (m_pAObj == NULL)
                m_pAObj = new CA();
               return m_pAObj;
              }
              static void SafeReleaseAObj(void)
              {
               if (m_pAObj != NULL)
                delete m_pAObj;
               m_pAObj = NULL;
              }
             };
             static CA* CA::m_pAObj = NULL;

             參考的Delphi實現(xiàn):
             unit xxx
             interface
             uses
               xxx,...,yyy;
             type
               TMyClass = class
               //xxxx
               end;
             var
               gAObj: TMyClass;//此為全局的單實例對象。
             function GetAObj: TMyClass;
             procedure SafeReleaseAObj;
             implemention//這個單詞忘了是不是這么寫。反應(yīng)是實現(xiàn)的那個單詞。。
             procedure SafeReleaseAObj;
             begin
               if Assigned(gAObj) then
                 FreeAndNil(gAObj);
             end;
             funciton GetAObj: TMyClass;
             begin
               if not Assigned(gAObj) then
                 gAObj = TMyClass.Create;
               Result := gAObj;
             end;

             //說明:以上僅是臨時寫的,并未在程序中編譯測試。但思路肯定不會錯。可供參考用。
             
            四:Builder模式(即:構(gòu)建模式)

             往往在實際項目的開發(fā)過程中會發(fā)現(xiàn),某些模塊的功能過于復(fù)雜。此時,我們自然就會想到將其進行進一步的劃分。如:細分成DA,DB,...,DN。然后由該模塊的某個管理角色進行協(xié)調(diào)運作。
            這樣,Builder模式將可用在此設(shè)計上。其思想,就是將復(fù)雜問題進一步細化。

            posted @ 2011-05-15 15:31 Jacc.Kim 閱讀(311) | 評論 (0)編輯 收藏

            設(shè)計模式學(xué)習(xí)總結(jié)之一

             設(shè)計模式其實只是一種程序設(shè)計的思想準則。通過該思想準則來指導(dǎo)我們的程序開發(fā)行為,盡量讓開發(fā)的程序更加穩(wěn)健、高效、思路清晰、少bug......
            開發(fā)一程序項目,往往并不只限于單一地使用某一模式。往往會多種模式同時使用。

             其實,設(shè)計模式在具體項目中的應(yīng)用開發(fā)中。要說要用xxx/xxx模式來搭框架開發(fā)等等,這些都是不對的。因為個人認為,設(shè)計模式的應(yīng)用,是隨著項目的
            不同而定的。因為不同的項目有著不同的解決方案。而不同的解決方案,將決定著,需要使用哪xxx/哪xxx模式來處理會比較好,此時才能說,確定了項目
            的框架等等。
             比如說:本來需要開發(fā)一個本地資源管理的項目。如果你一開始就給它定了一定要用單實例模式來搭框架實現(xiàn)。那我們就不明白了這個實例,在框架中,
            到底它應(yīng)該是什么。反過來,正常的,我們應(yīng)該根據(jù)這個項目的需要來確定應(yīng)該用到的模式。就拿該例子來說。我們可以對資源方面,使用抽象工棧模式
            在資源與展現(xiàn)及其處理方面,我們可以應(yīng)用觀察模式(即:所謂的observer模式)。如此一來,我很明確了,該系統(tǒng)大置的框架。這正應(yīng)了剛開始的一句話
            :設(shè)計模式只是一種程序設(shè)計的思想準則,它只是用來指導(dǎo)程序開發(fā)的行為。

             當然想懂得設(shè)計模式的東東,確實還是離不開面向?qū)ο螅ǖ乃枷耄o思想更解的越深刻,學(xué)起設(shè)計模式的將相對越輕松,也更解的會更深刻些(當然,
            學(xué)習(xí)它將是個不斷迭代的過程的)。反過來,對設(shè)計模式理解的越深刻,對oo的理解及應(yīng)用與設(shè)計,也將大大有益。

            一:Factory模式(工廠模式)

             所謂的Factory模式,即:它能類似工廠一樣,不斷地產(chǎn)生(即:創(chuàng)建)“產(chǎn)品”出來。但它所創(chuàng)建出來的那些“產(chǎn)品”,一般是抽象類的產(chǎn)品。舉例:
            假如有抽象類AbstractBasicClass。我們要想使用它,必須得有它的實現(xiàn)類。按正常來說,我們可以直接通過其具體的子類實例化一個產(chǎn)品出來。但這樣會
            有個問題,當AbstractBasicClass擁有N種不同的實現(xiàn)子類時,那我們到底要使用哪種具體子類來實例化,并且,各個不同的具體實現(xiàn)子類的命名,也將是
            個可怕的問題。因此這樣的維護將變得十分復(fù)雜。而Factory的設(shè)計就可以起來很好的一個維護作用。其實Factory模式的設(shè)計,還有一個好處,就是使得實例
            化得到了推遲(到了后期----一般指執(zhí)行期)。

            二:AbstractFactory模式(抽象工廠模式)

             上面Factory模式,其實針對的是一類類的情況,即:處理的上上面的AbstractBasicClass這一類類的情況。而實際項目中,卻往往需要處理N種的這樣抽象類、
            的情況。此時,我們將這N種類的產(chǎn)品創(chuàng)建都歸到一個Factory中時,此時的Factory即為一個AbstractFactory了。因此說,F(xiàn)actory與AbstractFactory只不過
            是處理的類各類的個數(shù)差異罷了。其思想是類似的。
             但一般來說AbstractFactory所產(chǎn)生出來的種抽象類,其實它們之間,一般來說,或多或少,會是有一定的關(guān)系的。比如:一個Abstractfactory產(chǎn)生出兩個
            抽象類的產(chǎn)品A和B。則A可能就需要B的某些功能,反之類似。

             小結(jié):Factory與AbstractFactory的設(shè)計,最終的目的都只是為了使用系統(tǒng)抽象類的維護更加簡單些。

            posted @ 2011-05-15 12:14 Jacc.Kim 閱讀(473) | 評論 (0)編輯 收藏

            僅列出標題
            共14頁: First 6 7 8 9 10 11 12 13 14 
            国产免费久久精品丫丫| 国产成人99久久亚洲综合精品| 久久这里都是精品| 一本色道久久综合狠狠躁篇| 国产一区二区久久久| 久久水蜜桃亚洲av无码精品麻豆| 亚洲欧美成人综合久久久| 国产精品一久久香蕉国产线看| 久久97精品久久久久久久不卡| 久久精品国产福利国产秒| 久久人人爽人人爽人人片AV不| 国内精品综合久久久40p| 99精品伊人久久久大香线蕉| 一级做a爰片久久毛片免费陪| 亚洲国产精品一区二区久久hs| 一级做a爰片久久毛片人呢| 亚洲欧美国产日韩综合久久| 青青热久久国产久精品| 久久久久久伊人高潮影院| 狠狠久久亚洲欧美专区| 久久永久免费人妻精品下载| 久久99国产精品久久99| 久久99国产精品尤物| 日本欧美久久久久免费播放网| 亚洲国产成人久久综合野外| 91久久香蕉国产熟女线看| 久久99精品国产99久久6男男| 久久亚洲春色中文字幕久久久| 久久久国产99久久国产一| 久久无码专区国产精品发布| 国产一区二区精品久久岳| 人人狠狠综合久久亚洲| 三级三级久久三级久久| 久久精品国产亚洲AV不卡| 精品国产乱码久久久久久郑州公司| 久久久久se色偷偷亚洲精品av| 亚洲狠狠婷婷综合久久久久| 国产成人精品综合久久久久| 久久精品国产精品亚洲精品| 久久人妻少妇嫩草AV无码蜜桃| 久久一日本道色综合久久|