设计模式之抽象工厂模式

　　简单工厂模式的主要解决了产品的扩展问题，而抽象工厂模式主要解决的是产品系列的问题，按照我的理解是：简单工厂模式更倾向于获取单个简单的产品，如生产一个苹果，生产一个桔子。而抽象工厂模式倾向于解决稍微复杂的一些问题，比如，我要获取一个菜单，菜单的内容有：荤菜和酒（假设每个菜单都只有这两种选择，菜单可看做是一个系列），这是我们就需要抽象工厂模式。下面我们用一个水果和肉的组合来简单的说明一下抽象设计模式。

1 package com.cnblogs.ipolaris.abstractfac.test;
2 /**
3  * 所有水果的父类
4  * @author iPolaris
5  *
6  */
7 public abstract class Fruit {
8     public abstract void printType();
9 }

 1 package com.cnblogs.ipolaris.abstractfac.test;
 2 /**
 3  * 
 4  * @author iPolaris
 5  *
 6  */
 7 public class Apple extends Fruit {
 8 
 9     @Override
10     public void printType() {
11         System.out.println("This is an apple");
12 
13     }
14 
15 }

 1 package com.cnblogs.ipolaris.abstractfac.test;
 2 /**
 3  * 
 4  * @author iPolaris
 5  *
 6  */
 7 public class Orange extends Fruit {
 8 
 9     @Override
10     public void printType() {
11         System.out.println("This is an Oranage!");
12     }
13 
14 }

 

1 package com.cnblogs.ipolaris.abstractfac.test;
2 /**
3  * 所有肉的父类
4  * @author iPolaris
5  *
6  */
7 public abstract class Meat {
8     public abstract void printMeatType();
9 }

 

 1 package com.cnblogs.ipolaris.abstractfac.test;
 2 /**
 3  * 
 4  * @author iPolaris
 5  *
 6  */
 7 public class Fish extends Meat {
 8 
 9     @Override
10     public void printMeatType() {
11         System.out.println("fish");
12 
13     }
14 
15 }

 

package com.cnblogs.ipolaris.abstractfac.test;
/**
 * 
 * @author iPolaris
 *
 */
public class Pig extends Meat {

    @Override
    public void printMeatType() {
        System.out.println("pig");

    }

}

定义完了基本的产品，下面就是写生产产品系列的工厂

 1 package com.cnblogs.ipolaris.abstractfac.test;
 2 /**
 3  * 
 4  * @author iPolaris
 5  *
 6  */
 7 public abstract class MenuFactory {
 8     public abstract Fruit getFruit();
 9     public abstract Meat getMeat();
10 }

系列一是苹果和鱼肉的组合

 1 package com.cnblogs.ipolaris.abstractfac.test;
 2 
 3 public class MenuOneFactory extends MenuFactory {
 4 
 5     @Override
 6     public Fruit getFruit() {
 7         return new Apple();
 8     }
 9 
10     @Override
11     public Meat getMeat() {
12         return new Fish();
13     }
14 
15 }

系列二是橘子和猪肉的组合

 1 package com.cnblogs.ipolaris.abstractfac.test;
 2 /**
 3  * 
 4  * @author iPolaris
 5  *
 6  */
 7 public class MenuTwoFactory extends MenuFactory {
 8 
 9     @Override
10     public Fruit getFruit() {
11         // TODO Auto-generated method stub
12         return new Orange();
13     }
14 
15     @Override
16     public Meat getMeat() {
17         // TODO Auto-generated method stub
18         return new Pig();
19     }
20 
21 }

 

 1 package com.cnblogs.ipolaris.abstractfac.test;
 2 /**
 3  * 
 4  * @author iPolaris
 5  *
 6  */
 7 public class AbstractFacTest {
 8     public static void main(String[] args){
 9         MenuFactory factory = new MenuOneFactory();
10         Fruit f1 = factory.getFruit();
11         f1.printType();
12         Meat m1 = factory.getMeat();
13         m1.printMeatType();
14     }
15 }

运行的结果为：

This is an apple

fish

当想得到另一个菜单时，将MenuOneFactory()换成MenuTwoFactory()，这样就达到了将复杂的实例化过程独立出来，使用户不用关系复杂的生产过程而得到实例。当有新的组合出现时（水果与肉），只要在建一个MenuFactory的子类，生成想要得到的组合类型。

总体来说，工厂设计模式主要有一下几部分组成：

1) 抽象工厂角色： 这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java 中它由抽象类或者接口来实现。

2) 具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。

3) 抽象产品角色：它是具体产品继承的父类或者是实现的接口。在 java 中一般有抽象类或者接口来实现。

4) 具体产品角色：具体工厂角色所创建的对象就是此角色的实例。在 java 中由具体的类

来实现。