qileilove
          

          blog已經(jīng)轉(zhuǎn)移至github,大家請訪問 http://qaseven.github.io/
          
			
          
				
					
	
          
		
          
			java中的工廠模式 
		
          
		
          舉兩個例子以快速明白Java中的工廠模式：

          女媧摶土造人
          話說：“天地開辟，未有人民，女媧摶土為人。”女媧需要用土造出一個個的人，但在女媧造出人之前，人的概念只存在于女媧的思想里面。
          女媧造人，這就是簡單工廠模式的應用。

          　　首先，在這個造人的思想里面，有幾個重要的角色：女媧本身、抽象的人的概念和女媧所造出的一個個具體的人。
          　　1.）女媧是一個工廠類，也就是簡單工廠模式的核心角色。
          

                  2.）具休的一個個的人，包括張三，李四等。這些人便是簡單工廠模式里面的具體產(chǎn)品角色
          　　3.）抽象的人是最早只存在于女媧的頭腦里的一個想法，女媧按照這個想法造出的一個個具體的人，便都符合這個抽象的人的定義。換言之，這個抽象的想法規(guī)定了所有具體的人必須都有的接口（特征或者功能）
          　　　其UML類圖出下所示：
          　　　　
          理解了上面的這些東西，再來理解下面的例子，對照理解，相信看完這篇文章，便對java簡單工廠模式有一個很好的理解：


          有一個農(nóng)場公司，專門向市場銷售各類水果，在這個系統(tǒng)里需要描述下列水果：
          　　　　　葡萄　Grape
          　　　　　草莓　Stuawberry
          　　　　　蘋果　Apple
          水果與其他植物不同，最終可以采摘食用，那么一個自然的做法是建立一個各種水果都適用的接口，以便與其他農(nóng)場里的植物區(qū)分開來，

          此時，則是為水果類聲明了一個接口，表現(xiàn)在代碼上：
          

           1public interface Fruit{
           2    //生長
           3     void grow();
           4     //收獲
           5     void harvest();
           6     //種植
           7     void plant();
           8}
           9
          10

          水果接口規(guī)定出所有的水果必須實現(xiàn)的接口，包括任何水果類必須具備的方法plant(),grow(),和harvest();

          Apple類是水果類的一種，因此它實現(xiàn)了水果接口所聲明的所有方法。另處，由于蘋果是多年生植物，因此多出一個treeAge性質(zhì)，描述蘋果的樹齡。代碼如下所示：
          

          package fac;

          public class Apple implements Fruit{//通過implements實現(xiàn)接口Fruit
              private int treeAge;
              
                        public void grow(){
                  log(          "Apple is growing");
              }
              
                        public void harvest(){
                  log(          "Apple has been harvested");
              }
              
                        public void plant(){
                  log(          "Apple ha been planted");
              }
              
                        public static void log(String msg){
                  System.out.println(msg);
              }
              
                        public int getTreeAge(){
                            return treeAge;
              }
              
                        public void setTreeAge(int treeAge){
                            this.treeAge=treeAge;
              }
          }

          同理，葡萄　Grape：
          

          package fac;

          public class Grape implements Fruit{
                        private boolean seedless;
                        public void grow(){
                  log(          "Grape is growing.");
              }
              
                        public void harvest(){
                  log(          "Grape has been harvested");
              }
              
                        public void plant(){
                  log(          "Grape ha been planted");
              }
              
                        public static void log(String msg){
                  System.out.println(msg);
              }

                        public boolean isSeedless() {
                            return seedless;
              }

                        public void setSeedless(boolean seedless) {
                            this.seedless = seedless;
              }
              

          }

          草莓　Stuawberry：
          

          package fac;

          public class Strawberry implements Fruit{
                        public void grow(){
                  log(          "Strawberry is growing");
              }
              
                        public void harvest(){
                  log(          "Strawberry has been harvested");
              }
              
                        public void plant(){
                  log(          "Strawberry has been planted");
              }
              
                        public static void log(String msg){
                  System.out.println(msg);
              }
          }


          農(nóng)場園丁也是系統(tǒng)的一部分，由一個類來代表，F(xiàn)ruitGardener類，代碼如下：
          

          package fac;

          public class FruitGardener{
                        public static Fruit factory(String which)throws Exception{
                            if(which.equalsIgnoreCase("apple")){
                                return new Apple();
                  }          else if(which.equalsIgnoreCase("strawberry")){
                                return new Strawberry();
                  }          else if (which.equalsIgnoreCase("grape")){
                                return new Grape();
                  }          else{
                                throw new Exception("Bad fruit request");
                  }
              }
          }
          這時有人來果園玩，和園丁說，給我們介紹下你的水果吧。于是園丁：
          

          package fac;

          public class People {

                        public static void main(String[] args) throws Exception {
                  FruitGardener fg          =new FruitGardener();
                  Fruit ap          =fg.factory("Apple");
                  ap.grow();
                  Fruit gp          =fg.factory("Grape");
                  gp.plant();
                  
                  Fruit dd          =fg.factory("ddd");//拋出Bad fruit request異常
              }              

          }
          


          （注：以上代碼在JDK5.0，Myeclise3.2下編譯通過）
          

           
          

           類比兩個例子，園丁就相當于女媧，而水果就相當于具體的人，接口水果類就相當于存在于類女媧思想里的人的抽象概念。

          由以上兩個例子可得出，簡單工廠模式需要由以下角色組成：
          　　　　　　接口
                                  接口的實現(xiàn)類（簡單工廠模式里面的具體產(chǎn)品角色）
                                  工廠

          理解了以下兩個例子，再來看第三個例子：
          注意對比以下三個實例的不同
          實例１：
          

          package org.jzkangta.factorydemo01;
          //定義接口
          interface Car{
                        public void run();
                        public void stop();
          }
          //具體實現(xiàn)類
          class Benz implements Car{
                        public void run(){
                  System.out.println(          "Benz開始啟動了。。。。。");
              }
                        public void stop(){
                  System.out.println(          "Benz停車了。。。。。");
              }
          }
          //具體實現(xiàn)類
          class Ford implements Car{
                        public void run(){
                  System.out.println(          "Ford開始啟動了。。。");
              }
                        public void stop(){
                  System.out.println(          "Ford停車了。。。。");
              }
          }
          //工廠
          class Factory{
                        public static Car getCarInstance(){
                            return new Ford();
              }
          }
          public class FactoryDemo01 {

                        public static void main(String[] args) {
                  Car c          =Factory.getCarInstance();
                  c.run();
                  c.stop();

              }

          }

          實例二：
          

          package fac;


          //定義接口
          interface Car{
                        public void run();
                        public void stop();
          }
          //具體實現(xiàn)類
          class Benz implements Car{
                        public void run(){
                  System.out.println(          "Benz開始啟動了。。。。。");
              }
                        public void stop(){
                  System.out.println(          "Benz停車了。。。。。");
              }
          }

          class Ford implements Car{
                        public void run(){
                  System.out.println(          "Ford開始啟動了。。。");
              }
                        public void stop(){
                  System.out.println(          "Ford停車了。。。。");
              }
          }
          //工廠
          class Factory{
                        public static Car getCarInstance(String type){
                  Car c          =null;
                            if("Benz".equals(type)){
                      c          =new Benz();
                  }
                            if("Ford".equals(type)){
                      c          =new Ford();
                  }
                            return c;
              }
          }


          public class FactoryDemo02 {

                        public static void main(String[] args) {
                  Car c          =Factory.getCarInstance("Benz");
                            if(c!=null){
                      c.run();
                      c.stop();
                  }          else{
                      System.out.println(          "造不了這種汽車。。。");
                  }
                  

              }

          }


          實例三：
          

          interface Car{
                        public void run();
                        public void stop();
          }

          class Benz implements Car{
                        public void run(){
                  System.out.println(          "Benz開始啟動了。。。。。");
              }
                        public void stop(){
                  System.out.println(          "Benz停車了。。。。。");
              }
          }

          class Ford implements Car{
                        public void run(){
                  System.out.println(          "Ford開始啟動了。。。");
              }
                        public void stop(){
                  System.out.println(          "Ford停車了。。。。");
              }
          }

          class Toyota implements Car{
                        public void run(){
                  System.out.println(          "Toyota開始啟動了。。。");
              }
                        public void stop(){
                  System.out.println(          "Toyota停車了。。。。");
              }
          }

          class Factory{
                        public static Car getCarInstance(String type){
                  Car c          =null;
                            try {
                      c          =(Car)Class.forName("org.jzkangta.factorydemo03."+type).newInstance();//利用反射得到汽車類型　
                  }           catch (InstantiationException e) {
                                // TODO Auto-generated catch block
                      e.printStackTrace();
                  }           catch (IllegalAccessException e) {
                                // TODO Auto-generated catch block
                      e.printStackTrace();
                  }           catch (ClassNotFoundException e) {
                                // TODO Auto-generated catch block
                      e.printStackTrace();
                  }
              
                            return c;
              }
          }
          public class FactoryDemo03 {

                        public static void main(String[] args) {
                  Car c          =Factory.getCarInstance("Toyota");
                            if(c!=null){
                      c.run();
                      c.stop();
                  }          else{
                      System.out.println(          "造不了這種汽車。。。");
                  }
                  

              }

          }



          對比三個實例：
          實例一，雖然實現(xiàn)了簡單工廠，但每次只能得到一種汽車，如果我們想換一種，就得修改工廠，太不方便，而實例二則改變了這種情況，便得我們可以按照我們的需要更換汽車，但我們所更換的汽車必須是實現(xiàn)類中有的，如果我們想要增加一種汽車的時候，我們還是得更改工廠，通過改進，實例三利用反射機制，得到汽車類型，這樣當我們需要增加一種新的汽車時，就無需要再修改工廠，而只需要增加要實現(xiàn)的類即可。也就是說要增加什么樣的汽車直接增加這個汽車的類即可，而無需改變工廠。從而達到了工廠分離的效果。 
          
		
          
			posted on 2011-09-23 13:38 順其自然EVO 閱讀(163) 評論(0)  編輯  收藏  
		
          
	
          
	
	


	


          
	    
    

          

				
			
          
			
          
				
					
          
	
          
		
          <2011年9月>
          
	
          日一二三四五六
          28293031123
          45678910
          11121314151617
          18192021222324
          2526272829301
          2345678
          

          

					

          導航
          

					

          統(tǒng)計
          
	
					
					

          常用鏈接
          


          留言簿(55)
          


		
          隨筆分類
          
		
				
			
	
		
          隨筆檔案
          
		
				
			
	
		
          文章分類
          
		
				
			
	
		
          文章檔案
          
		
				
			
	



          搜索
          



          最新評論
	
          



          閱讀排行榜
          



          評論排行榜
          


				
			
          			
			

	

    



          
        
	




主站蜘蛛池模板：
仁寿县|
通海县|
澄江县|
太仆寺旗|
荃湾区|
蒙城县|
军事|
梅河口市|
岳池县|
旬邑县|
深泽县|
莆田市|
南丰县|
广水市|
永城市|
宁津县|
乐陵市|
泉州市|
上虞市|
古田县|
孙吴县|
青田县|
广宗县|
昌宁县|
德阳市|
泸水县|
胶南市|
横峰县|
泰来县|
绥芬河市|
奉节县|
集贤县|
永州市|
从江县|
澜沧|
金秀|
大冶市|
合作市|
麟游县|
长治县|
晋城|