设计模式

设计模式之工厂模式

1.     简单工厂模式

这种模式简单，使用与业务逻辑简单的情景中使用！

使用说明：利用一个工厂类来创建相应的产品，如蔬菜工厂会生产土豆，西红柿…..等，不过土豆，西红柿都会实现蔬菜的特性！

下面是简单工厂的UML图：

 

代码如下所示：

   食物总的接口：

package com.dai.factory.simplefactory;
 
/**
 *
 * @author戴礼明
 *日期： 2016-4-22
 *content：食物接口
 */
public interface Food {
 
    public void color();
   
    public void shape();
     
}

土豆类的实现：

package com.dai.factory.simplefactory;
 
/**
 *
 * @author戴礼明
 *日期： 2016-4-22
 *content：土豆
 */
public class Potato implements Food{
 
    private String name;
   
    public Potato() {
       // TODO Auto-generatedconstructor stub
    }
   
    public Potato(String name) {
     this.name=name;
    }
   
    public void color() {
        System.out.println("我是"+name+",我的颜色是土黄色的！");
    }
 
    public void shape() {
        System.out.println("我是"+name+"，我的形状是圆的！");
    }
}

西红柿类的实现：

 

package com.dai.factory.simplefactory;
 
/**
 *
 * @author戴礼明
 *日期： 2016-6-3
 *content：西红柿
 */
public class Tomato  implements Food{
   
    private String name;
 
   
    public Tomato(String name) {
       super();
       this.name = name;
    }
 
    public void color() {
        System.out.println("我是"+name+"，颜色是红色的！");
    }
 
    public void shape() {
        System.out.println("我是"+name+"，是圆的！");
    }
}

 

食物工厂类：

 

 1    package com.dai.factory.simplefactory;
 2 /**
 3  *
 4  * @author戴礼明
 5  *日期： 2016-6-3
 6  *content：食物工厂类
 7  */
 8 public class FoodFactory {
 9  
10      /**
11       * 创建食物
12       * @param object
13       * @return
14       */
15    
16     public Food createFood(String object){
17        if("potato".equals(object)){
18             return new Potato("土豆");
19        }else if("tomato".equals(object)){
20            return new Tomato("西红柿");
21        }
22        return null;
23     }
24    
25 }

 

测试类：

 1 package com.dai.factory.simplefactory;
 2 
 3 /**
 4  * 
 5  * @author 戴礼明
 6  *日期： 2016-6-3
 7  *content：简单工厂测试
 8  */
 9 public class SimpleFactory {
10 
11     public static void main(String[] args) {
12         FoodFactory factory=new FoodFactory();
13         
14         Food t=factory.createFood("tomato");
15         t.color();
16         Food t1=factory.createFood("potato");
17         t1.color();
18     }
19     
20 }

 





 


2. 工厂方法


说明：


一抽象产品类派生出多个具体产品类；一抽象工厂类派生出多个具体工厂类；每个具体工厂类只能创建一个具体产品类的实例。


即定义一个创建对象的接口（即抽象工厂类），让其子类（具体工厂类）决定实例化哪一个类（具体产品类）。“一对一”的关系。


 


UML图如下所示：



 


食物接口：




 1 package com.dai.factory.factorymethod;
 2 
 3 /**
 4  * 
 5  * @author 戴礼明
 6  *日期： 2016-4-22
 7  *content：食物接口
 8  */
 9 public interface Food {
10 
11     public void color();
12     
13     public void shape();
14      
15 }




 


土豆类的实现：




 1 package com.dai.factory.factorymethod;
 2  
 3 /**
 4  *
 5  * @author戴礼明
 6  *日期： 2016-4-22
 7  *content：食物接口
 8  */
 9 public interface Food {
10  
11     public void color();
12    
13     public void shape();
14      
15 }
16  




 


西红柿类的实现：




 1 package com.dai.factory.factorymethod;
 2  
 3 /**
 4  *
 5  * @author戴礼明
 6  *日期： 2016-4-22
 7  *content：食物接口
 8  */
 9 public interface Food {
10  
11     public void color();
12    
13     public void shape();
14      
15 }
16  




 


抽象工厂接口：




 1 package com.dai.factory.factorymethod;
 2  
 3 /**
 4  *
 5  * @author戴礼明
 6  *日期： 2016-4-22
 7  *content：食物接口
 8  */
 9 public interface Food {
10  
11     public void color();
12    
13     public void shape();
14      
15 }




 


土豆工厂：




 1 package com.dai.factory.factorymethod;
 2 /**
 3  *
 4  * @author戴礼明
 5  *日期： 2016-6-3
 6  *content：食物工厂类
 7  */
 8 public class PotatoFactoryimplements Factory{
 9  
10      /**
11       * 创建食物
12       * @param object
13       * @return
14       */
15     public Food createFood(){
16         return new Potato();
17     }
18    
19 }
20  




 


西红柿工厂：




 1 package com.dai.factory.factorymethod;
 2 /**
 3  * 
 4  * @author 戴礼明
 5  *日期： 2016-6-3
 6  *content：食物工厂类
 7  */
 8 public class TomatoFactory implements Factory{
 9  
10      /**
11       * 创建食物
12       * @param object
13       * @return
14       */
15     public Food createFood(){
16          return new Tomato();
17     }
18     
19 }




 


测试类：




 1 package com.dai.factory.factorymethod;
 2  
 3  
 4 /**
 5  *
 6  * @author戴礼明
 7  *日期： 2016-6-3
 8  *content：工厂方法测试
 9  */
10 public class SimpleFactory {
11  
12     public static void main(String[] args) {
13      // Factory factory=new TomatoFactory();
14       Factory factory=new PotatoFactory();
15      factory.createFood().color();
16         
17     }
18    
19 }




 


3.     抽象工厂


说明：抽象工厂模式也有四种角色：抽象工厂、具体工厂、抽象产品和具体产品


UML图如下所示：


 


 


 


 


代码如下所示：


 


水果接口：




 1 package com.dai.factory.abstractfactory;
 2  
 3 /**
 4  *
 5  * @author戴礼明
 6  *日期： 2016-6-3
 7  *content：水果抽象类
 8  */
 9 public interface Fruits {
10  
11      public void fruitsName();
12    
13 }




 


蔬菜接口： 




 1 package com.dai.factory.abstractfactory;
 2  
 3 /**
 4  *
 5  * @author戴礼明
 6  *日期： 2016-6-4
 7  *content：蔬菜接口
 8  */
 9 public interface Vegetables {
10  
11      public void getName();
12    
13 }




 


橘子：




package com.dai.factory.abstractfactory;
 
/**
 *
 * @author戴礼明
 *日期： 2016-6-4
 *content：橘子具体实现类
 */
public class Orange implements Fruits{
 
     
 
    public void fruitsName() {
        System.out.println("工厂生产了橘子");
    }
 
}




 


香蕉：




package com.dai.factory.abstractfactory;
 
/**
 *
 * @author戴礼明
 *日期： 2016-6-4
 *content：香蕉具体实现类
 */
 
public class Banana implements Fruits{
 
    public void fruitsName() {
        System.out.println("生产的是香蕉");
    }
 
   
 
}




 


土豆：




 1 package com.dai.factory.abstractfactory;
 2  
 3 /**
 4  *
 5  * @author戴礼明
 6  *日期： 2016-4-22
 7  *content：土豆
 8  */
 9 public class Potato implements Vegetables{
10  
11     public void getName() {
12      System.out.println("工厂生产了土豆！");
13     }
14  
15 }




 


西红柿：






 1 package com.dai.factory.abstractfactory;
 2  
 3  
 4 /**
 5  *
 6  * @author戴礼明
 7  *日期： 2016-6-3
 8  *content：西红柿
 9  */
10 public class Tomato  implements Vegetables{
11  
12  
13     public void getName() {
14      System.out.println("工厂生产了西红柿！");
15     }
16    
17  
18  
19    
20 }






工厂接口：




package com.dai.factory.abstractfactory;
 
/**
 *
 * @author戴礼明
 *日期： 2016-6-4
 *content：工厂接口
 */
public interface Factory {
 
    public Fruits friutsFactory();
   
    public VegetablesVegetablesFactory();
   
}




 


工厂A：




 1 package com.dai.factory.abstractfactory;
 2 /**
 3  *
 4  * @author戴礼明
 5  *日期： 2016-6-4
 6  *content：工厂A生产香蕉，土豆
 7  */
 8  
 9 public class FactoryA implements Factory{
10  
11     public Fruits friutsFactory() {
12        return new Banana();
13     }
14  
15     public Vegetables VegetablesFactory() {
16        return new Potato();
17     }
18  
19  
20  
21 }
22  




 


工厂B：




 1 package com.dai.factory.abstractfactory;
 2  
 3 /**
 4  *
 5  * @author戴礼明
 6  *日期： 2016-6-4
 7  *content：工厂B生产橘子，西红柿
 8  */
 9 public class FactoryB implements Factory{
10  
11     public Fruits friutsFactory() {
12        return new Orange();
13     }
14  
15     public Vegetables VegetablesFactory() {
16        return new Tomato();
17     }
18  
19  
20  
21 }




 


测试： 




package com.dai.factory.abstractfactory;
 
/**
 *
 * @author戴礼明
 *日期： 2016-6-4
 *content：抽象工厂测试方法
 */
public class TestAbstractFactory {
 
    public static void main(String[] args) {
       Factory factory=new FactoryB();
       factory.friutsFactory().fruitsName();
       factory.VegetablesFactory().getName();
    }
   
   
}




 总结：


抽象工厂模式相对于工厂方法模式来说，每个具体工厂可以生产一族产品（即多种产品）；而工厂方法模式是具体工厂生产相应的具体产品，只能生产一种产品。当产品族中只有一种产品时抽象工厂模式退化成工厂方法模式。






            

            
posted @ 
2016-06-04 08:58 
戴桥冰 
阅读(92) 
评论(0) 
 
收藏 
举报