工厂方法模式，抽象工厂模式，简单实例分析

为了更好地理解这两个模式，自己假设了如下场景，可能有些牵强，但应该还好。嘿嘿。

 

Acer，Lenovo两家本本制造商，假设原来有一OEM两个牌子的本本都做，这时，无论你想买那种牌子的，都可以直接向OEM购买。

可是后来该OEM商发现，如果一次同时做很多个牌子的本本，有些不利于管理，而且，如果以后要加入新的品牌的话，要有许多设备上的改动，等等原因，于是，它决定衍生出些子厂，每个子厂只做一种牌子的本本，而OEM核心总部，只负责制定规范，即，每个子厂要完成的所有任务。

 

该OEM的初始状态，就是静态工厂方法的场景，自己负责一切生产任务，根据外界的需求，去制造本本。

后来，为了便于管理，和把引入新品牌后产生的变动降到最低，采取了工厂方法模式。即，核心的工厂不再负责创建等具体动作，把这些派发给自己的子工厂。而核心工厂，仅负责制定规范。

 

1.工厂方法模式

 

首先，定义产品接口，Laptop，当然，也可以是个抽象类。

点击(此处)折叠或打开

1. package factoryMethod;
   
2. 
   
3. abstract public class Laptop {
   
4.     
   
5.     private String mark;
   
6. 
   
7.     public Laptop(String str){
   
8.         
   
9.         this.mark = str;
   
10.         
    
11.     }
    
12.     
    
13.     abstract public String getId();
    
14.     
    
15.     public void echoMark(){
    
16.         
    
17.         System.out.println("this is a "+mark+" Laptop");
    
18.         
    
19.     }
    
20. 
    
21. }

有了产品接口，我们就可以去定义那个核心工厂接口

点击(此处)折叠或打开

1. package factoryMethod;
   
2. 
   
3. public interface LaptopFactory {
   
4.     
   
5.     public Laptop produce();
   
6.     
   
7.     public void service();
   
8. 
   
9. }

如代码所示，核心工厂规定了它子类要完成的行为，即，制造本本，和售后服务。

下面，是具体产品类，比如Acer品牌的本本

点击(此处)折叠或打开

1. package factoryMethod;
   
2. 
   
3. public class AcerLaptop extends Laptop {
   
4. 
   
5.     
   
6.     private static final String mark = "Acer";
   
7.     protected static int initId;
   
8.     
   
9.     public AcerLaptop() {
   
10.         super(AcerLaptop.mark);
    
11.         AcerLaptop.initId = 10001;
    
12.     }
    
13. 
    
14.     public String getId() {
    
15. 
    
16.         return "Acer--"+(AcerLaptop.initId++);
    
17. 
    
18.     }
    
19. 
    
20. }

再来个Lenovo的本本

点击(此处)折叠或打开

1. package factoryMethod;
   
2. 
   
3. public class LenovoLaptop extends Laptop {
   
4. 
   
5.     private static final String mark = "Lenovo";
   
6.     protected static int initId;
   
7.     
   
8.     public LenovoLaptop() {
   
9. 
   
10.         super(LenovoLaptop.mark);
    
11.         LenovoLaptop.initId = 20001;
    
12.     }
    
13. 
    
14.     public String getId() {
    
15. 
    
16.         return "Lenovo--"+(LenovoLaptop.initId++);
    
17. 
    
18.     }
    
19. 
    
20. }

其实Laptop定义的抽象方法没什么具体意义，该例子只为描述工厂方法模式。

 

下面，来定义具体工厂，Acer的，和Lenovo的，里面的方法同样没什么太大意义，只为测试。

 

 

点击(此处)折叠或打开

1. package factoryMethod;
   
2. 
   
3. public class AcerFactory implements LaptopFactory {
   
4. 
   
5.     @Override
   
6.     public Laptop produce() {
   
7.         
   
8.         return new AcerLaptop();//生产Acer的本本
   
9.         
   
10.     }
    
11. 
    
12.     @Override
    
13.     public void service() {
    
14.         
    
15.         System.out.println("welcom to Acer hotline ");
    
16. 
    
17.     }
    
18. 
    
19. }

点击(此处)折叠或打开

1. public class LenovoFactory implements LaptopFactory{
   
2.     
   
3.     public Laptop produce(){
   
4.         
   
5.         return new LenovoLaptop();//生产lenovo的本本
   
6.         
   
7.     }
   
8.     
   
9.     public void service(){
   
10.         
    
11.         System.out.println("welcom to Lenovo hotline ");
    
12.         
    
13.     }
    
14. 
    
15. }

来一个测试类。

点击(此处)折叠或打开

1. package factoryMethod;
   
2. 
   
3. public class Client {
   
4. 
   
5.         public static void main(String[] args) {
   
6.             
   
7.             LenovoFactory lf = new LenovoFactory();
   
8.             AcerFactory af= new AcerFactory();
   
9.             Laptop lt1 = lf.produce();
   
10.             Laptop lt2 = lf.produce();
    
11.             Laptop lt3 = af.produce();
    
12.             Laptop lt4 = af.produce();
    
13.             
    
14.             
    
15.             lf.service();
    
16.             System.out.println(lt1.getId());
    
17.             System.out.println(lt2.getId());
    
18.             System.out.println("--------------");
    
19.             af.service();
    
20.             System.out.println(lt3.getId());
    
21.             System.out.println(lt4.getId());
    
22. 
    
23.         }
    
24. }

打印结果如下

点击(此处)折叠或打开

1. welcom to Lenovo hotline 
   
2. Lenovo--20001
   
3. Lenovo--20002
   
4. --------------
   
5. welcom to Acer hotline 
   
6. Acer--10001
   
7. Acer--10002

过了一段时间，该OEM决定除了做本本，也做手机。而且OEM核心工厂决定改变下现有策略，每个子工厂做同一品牌的两个产品，例如，子工厂A做Acer的手机和本本。

这时，有了同族产品的概念，即某些产品是一个产品族的，这里就是指同一个品牌的。

 

为了完成这一变更，就要是用抽象工厂方法了。这个要比前一个复杂一些，所以先画了一个uml图。

 

 

 

-工厂接口，AbstractFatory，指定了子类要实现的制造本本，制造手机的方法

-具体工厂类，AcerFactory，LenovoFactory，均实现了上述方法，每个具体工厂负责一个产品族。

-MobilePhone抽象类，指定Phone产品的一些属性特征，Laptop同理。

-Phone与Laptop属于不同等级的产品，但是同一品牌的Phone和Laptop是同一产品族的产品，在此例中。

 

这里就不再罗列代码了，uml图可以比较清晰的说明每个角色间的关系。

总结起来，引用百度百科的一句话，抽象工厂模式使用同一个 工厂等级结构负责不同产品等级结构产品对象的创建。

 

----------------------------------------------------------------------------