抽象工厂模式

　　– 简单工厂模式：用来生产同一等级结构中的任意产品。（对于增加新的产品，需要修改已有代码）

　　– 工厂方法模式：用来生产同一等级结构中的固定产品。（支持增加任意产品）

　　– 抽象工厂模式：用来生产不同产品族的全部产品。（对于增加新的产品，无能为力；支持增加产品族）

抽象工厂的结构：

抽象工厂：提供创建产品的接口，可以创建多个不同等级的产品。
具体工厂：完成具体产品的创建。
抽象产品：定义产品规范，描述特性和功能。
具体产品：实现具体的产品。

　　抽象工厂：

 1 public interface Make {
 2     /**
 3      * 造酒的接口，制造52度的酒
 4      * @return Liqueur
 5      */
 6     public Liqueur makeLiqueur52();
 7 
 8     /**
 9      * 造酒的接口，制造42度的酒
10      * @return Liqueur
11      */
12     public Liqueur makeLiqueur42();
13 }

　　具体工厂：制造闷倒驴工厂

 1 /**
 2  * 制造闷倒驴工厂（代表闷倒驴这一族）
 3  */
 4 public class MakeMdlFactory implements Make{
 5 
 6     /**
 7      * 制造52度闷倒驴
 8      * @return 52度闷倒驴味道
 9      */
10     @Override
11     public Liqueur makeLiqueur52() {
12         return new Mdl52();
13     }
14 
15     /**
16      * 制造42度闷倒驴
17      * @return 42度闷倒驴味道
18      */
19     @Override
20     public Liqueur makeLiqueur42() {
21         return new Mdl42();
22     }
23 }

　　具体工厂：制造跑舌头工厂

 1 /**
 2  * 制造跑舌头工厂（代表跑舌头这一族）
 3  */
 4 public class MakePstFactory implements Make {
 5 
 6     /**
 7      * 制造52度跑舌头
 8      * @return 52度跑舌头味道
 9      */
10     @Override
11     public Liqueur makeLiqueur52() {
12         return new Pst52();
13     }
14 
15     /**
16      * 制造42度跑舌头
17      * @return 42度跑舌头味道
18      */
19     @Override
20     public Liqueur makeLiqueur42() {
21         return new Pst42();
22     }
23 }

　　抽象产品：接口

1 public interface Liqueur {
2     public void taste();//酒味
3 }

　　抽象产品：闷倒驴抽象类

1 /**
2  * 闷倒驴抽象类
3  */
4 public abstract class Mdl implements Liqueur {
5     public abstract void taste();
6 }

　　抽象产品：跑舌头抽象类

1 /**
2  * 跑舌头抽象类
3  */
4 public abstract class Pst implements Liqueur {
5     public abstract void taste();
6 }

　　具体产品：42度闷倒驴

/**
 * 42度闷倒驴
 */
public class Mdl42 extends Mdl {
    @Override
    public void taste() {
        System.out.println("42度闷倒驴，辣的");
    }
}

　　具体产品：52度闷倒驴

1 /**
2  * 52度闷倒驴
3  */
4 public class Mdl52 extends Mdl {
5     @Override
6     public void taste() {
7         System.out.println("52度闷倒驴，特别辣");
8     }
9 }

　　具体产品：42度跑舌头

1 /**
2  * 42度跑舌头
3  */
4 public class Pst42 extends Pst {
5     @Override
6     public void taste() {
7         System.out.println("42度跑舌头，苦的");
8     }
9 }

　　具体产品：52度跑舌头

1 /**
2  * 52度跑舌头
3  */
4 public class Pst52 extends Pst {
5     @Override
6     public void taste() {
7         System.out.println("52度跑舌头，特别苦");
8     }
9 }

　　测试：

 1 public class LiqueurTest {
 2 
 3     public static void main(String[] args){
 4         Make mdlFactory = new MakeMdlFactory();
 5         Liqueur mdl42 = mdlFactory.makeLiqueur42();
 6         Liqueur mdl52 = mdlFactory.makeLiqueur52();
 7         mdl42.taste();
 8         mdl52.taste();
 9 
10         Make pstFactory = new MakePstFactory();
11         Liqueur pst42 = pstFactory.makeLiqueur42();
12         Liqueur pst52 = pstFactory.makeLiqueur52();
13         pst42.taste();
14         pst52.taste();
15     }
16 }

　　结果：

1 42度闷倒驴，辣的
2 52度闷倒驴，特别辣
3 42度跑舌头，苦的
4 52度跑舌头，特别苦

　　与工厂方法模式相比，抽象工厂模式中的具体工厂不只是创建一种具体对象，它负责创建一组（族）具体对象。

　　总结：用工厂模式主要是代替new操作，将创建对象统一管理和控制，从而将调用者与实现类解耦。

设计模式之美—抽象工厂模式

抽象工厂模式

抽象工厂的结构：

猜你喜欢