隨筆-35 
評論-97 
文章-0 
trackbacks-0

          
	

          

          
	
					


          
	
	
          Abstract Factory 模式的意圖：
          

          需要為特定的客戶（或者對某種情況）提供對象組
          
Abstract Factory 模式將問題（根據職責）分解為：

          1.誰在使用我們的特定對象（Client）
          2.誰來決定使用哪些對象（AbstractFactory）
          

          類圖（非標準類圖，為了給結合例子，稍稍修改）：
          

          代碼如下：
          

          在例子中，線索是這樣的。比如你要買一件襯衫（addi的）和一條西庫（nike的），牌子有nike的，還有addi的。約定對應關系如下：
          

          AbstractFactory   －－－  衣服生產商
          AbstractProductB  －－－  西褲
          AbstractProductA  －－－  襯衫
          ConcreteFactory1  －－    nike生產商
          ConcreteFactory2  －－    addi生產商
          ConcreteProductA1 －－    ××的襯衫
          ConcreteProductB1 －－    ××的褲子
          （在這里ConcreteProductA1、ConcreteProductB1為ConcreteFactory1的產品）
          ConcreteProductA2 －－    ××的襯衫
          ConcreteProductB2 －－    ××的褲子
          （在這里ConcreteProductA2、ConcreteProductB2為ConcreteFactory2的產品）
          

           
          

          這里沒有對類進行具體細化的命名，只作簡單的約定，你可以根據需要修改名稱。
          

          抽象工廠：
          

          public interface AbstractFactory {
                        /**
               *  Creates abstract product
                         */
              AbstractProductA createProductA();

                        /**
               *  Creates abstract product
                         */
              AbstractProductB createProductB();
          }
          

          抽象產品A：
          

          public class AbstractProductA
          {
          }
          
抽象產品B：

          public class AbstractProductB
          {
          }
          

          生產1產品的工廠：
          

          public class ConcreteFactory1 implements AbstractFactory {

          private  String name;

                        public ConcreteProductA1 createProductA() {
                            return new ConcreteProductA1(name);
              }
              
                        public ConcreteProductB1 createProductB() {
                            return new ConcreteProductB1(name);
              }

                        public ConcreteFactory1(String name)
                        {
                            super();
                            this.name = name;
              }
          }
          

          生產2產品的工廠：
          

          public class ConcreteFactory2 implements AbstractFactory
          {
                        private  String name;

                        public ConcreteProductA2 createProductA()
                        {
                            return new ConcreteProductA2(name);
              }

                        public ConcreteProductB2 createProductB()
                        {
                            return new ConcreteProductB2(name);
              }

                        public ConcreteFactory2(String name)
                        {
                            super();
                            this.name = name;
              }
          }
          

          具體產品A1：
          

          public class ConcreteProductA1 extends AbstractProductA {

                        public ConcreteProductA1(String name)
                        {
                  System.out.println(name          + "的襯衫");
              }
          }
          

           
          

          具體產品B1：
          

          public class ConcreteProductB1 extends AbstractProductB
          {
                        public ConcreteProductB1(String name)
                        {
                  System.out.println(name          + "的褲子");
              }
          }
          

           
          

          具體產品A2：
          

          public class ConcreteProductA2 extends AbstractProductA
          {
                        public ConcreteProductA2(String name)
                        {
                  System.out.println(name          + "的襯衫");
              }
          }
          

           
          

          具體產品B2：
          

          public class ConcreteProductB2 extends AbstractProductB
          {
                        public ConcreteProductB2(String name)
                        {
                  System.out.println(name          + "的褲子");
              }
          }
          

           
          

          測試Client：
          

          public class Client
          {
                        /**
               * @directed true
                         */
                        private AbstractFactory abstractFactory;//衣服生產商
              /**
               *           @link aggregation
                         */
                        private AbstractProductB abstractProductB;//西褲
              /**
               *           @link aggregation
                         */
                        private AbstractProductA abstractProductA;//襯衫
              
                        public static void main(String[] args)
                        {
                  Client client           = new Client();
                  client.buySomething();
              }
              
                        public void buySomething(){
                            //找到nike生產商
                  abstractFactory  = new ConcreteFactory1("nike生產商");
                            //買一件西褲（nike）
                  abstractProductB = abstractFactory.createProductB();//生產西褲
                  
                            //找到addi生產商
                  abstractFactory  = new ConcreteFactory2("addi生產商");//生產襯衫
                            //買一件襯衫（addi）
                  abstractProductA=abstractFactory.createProductA();//生成襯衫
                  
                  abstractFactory           = null;
              }
          }
          

           
          

          結果輸出：
          

          nike生產商的褲子
          addi生產商的襯衫
          

	
          posted on 2007-06-05 18:45 三告習習 閱讀(1713) 評論(3)  編輯  收藏  所屬分類: DesignPattern 
          

          







          
	    
    


          
評論:

          
	

		
          
			
          
			# re: [設計模式篇] Abstract Factory 模式讀書筆記與舉例
				2007-06-05 19:20 | 劉甘泉
          
				
          又是設計模式，其實也就那么一回事，知道大概的模式的概念就好

          在編程的時候不要刻意的去迎合模式，要去迎合抽象就可以了  回復  更多評論
            
          
			
          
			
			
		
          
	
		
          
			
          
			# re: [設計模式篇] Abstract Factory 模式讀書筆記與舉例
				2007-06-06 16:59 | pass86
          
				
              /** *//**
               *  Creates abstract product
               */
              AbstractProductA createProductA();

              /** *//**
               *  Creates abstract product
               */
              AbstractProductB createProductB();
          這兩個接口應該保持不變吧，返回值也一樣，
          ConcreteFactory1
          ConcreteFactory2
          中返回值是它們的之類，用java-1.4.0-gcj-1.4.2.0編譯不成功，必須繼承的接口也要寫成返回AbstractProductA或者AbstractProductB。  回復  更多評論
            
          
			
          
			
			
		
          
	
		
          
			
          
			# re: [設計模式篇] Abstract Factory 模式讀書筆記與舉例
				2008-02-03 18:02 | 啊
          
				
          抽象工廠好象還是偶合了一些東西吧？

          我覺得不太靈活  回復  更多評論
            
          
			
          
			
			
		
          
	








          





          


          

	
          
		
          
				
		
	
		
          
		
		
          只有注冊用戶登錄后才能發表評論。
          
		
          
			
		
          
			
		
          
		
		
          
		


          

		          		
		
          
		
          			
		
		
		
		
          
		
          
		
		
          
		
          
			網站導航:
		
		
          
		
          
			


		
          	
		
          
			 
		
          
		
          
			
		
          
		
          
			
				
		
          		
	
          	

          



          

				

          







    







        
	




主站蜘蛛池模板：
峨边|
宣武区|
抚远县|
宜宾县|
盐城市|
宜黄县|
德州市|
汝南县|
枞阳县|
余姚市|
承德市|
靖安县|
洪洞县|
体育|
资中县|
木兰县|
万全县|
怀化市|
普陀区|
丰都县|
莲花县|
饶平县|
休宁县|
桂林市|
巴楚县|
怀安县|
郴州市|
田东县|
布尔津县|
额尔古纳市|
怀仁县|
泰州市|
古田县|
萝北县|
商河县|
海盐县|
奈曼旗|
甘谷县|
万源市|
万年县|
东光县|