上一篇说到了工厂模式，那么学习了工厂模式，抽象工厂也得学习一下。实际上，抽象工厂模式实际上就是在工厂模式的基础上再嵌套一层工厂模式而已，通过父工厂制造子工厂。只是，也并不完全是嵌套一层，各个工厂会被抽象成一个集多个工厂共同点的抽象类。通过工厂制造器，创建出该抽象工厂的子类。
好比如说，一个博客页面有个换肤系统。那么假如有两套风格，黑和白。那么，我选择了黑色风格的，实际这步就相当通过换肤系统这个工厂制造器，创建出一个黑色主题的工厂，该黑色主题的工厂内可以生产各种黑色风格的产品，比如黑色头像挂饰，黑色背景，黑色的xxx等，然后通过这些黑色主题产品完成了整个换肤操作。白色主题也如此。
好吧，上次以水果工厂作为一个类，那么这次要创建一个蔬菜工厂，水果和蔬菜这两类都属于种植物，那么我们就可以根据这一共同点抽象出一个种植物抽象类，即种植物工厂。
首先，创建产品类，包括上次的水果，和现在的蔬菜，他们都实现了水果类接口和蔬菜类接口：
水果系列：
|
1
2
3
|
public interface Fruit { void printInfo(); } |
|
1
2
3
4
5
6
7
|
public class Apple implements Fruit{ @Override public void printInfo() { // TODO Auto-generated method stub System.out.println("苹果"); } } |
|
1
2
3
4
5
6
7
|
public class Banana implements Fruit{ @Override public void printInfo() { // TODO Auto-generated method stub System.out.println("香蕉"); } } |
|
1
2
3
4
5
6
7
|
public class Orange implements Fruit{ @Override public void printInfo() { // TODO Auto-generated method stub System.out.println("橙子"); } } |
接着是蔬菜系列：
|
1
2
3
|
public interface Vegetable { public void printInfo(); } |
|
1
2
3
4
5
6
7
|
public class Tomato implements Vegetable{ @Override public void printInfo() { // TODO Auto-generated method stub System.out.println("西红柿"); } } |
|
1
2
3
4
5
6
7
|
public class Cabbage implements Vegetable{ @Override public void printInfo() { // TODO Auto-generated method stub System.out.println("白菜"); } } |
|
1
2
3
4
5
6
7
|
public class Eggplant implements Vegetable{ @Override public void printInfo() { // TODO Auto-generated method stub System.out.println("茄子"); } } |
然后，是它们各自的工厂类：
水果工厂：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
public class FruitFactory extends PlantFactory{ public static final int APPLE=1; public static final int BANANA=2; public static final int ORANGE=3; @Override public Fruit getFruit(int fruitType){ if(fruitType==APPLE){ return new Apple(); } if(fruitType==BANANA){ return new Banana(); } if(fruitType==ORANGE){ return new Orange(); } return null; } @Override Vegetable getVegetable(int vegetableType) { // TODO Auto-generated method stub return null; } } |
蔬菜工厂：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
public class VegetableFactory extends PlantFactory { public static final int CABBAGE=1; public static final int TOMATO=2; public static final int EGGPLANT=3; @Override Fruit getFruit(int fruitType) { // TODO Auto-generated method stub return null; } @Override public Vegetable getVegetable(int vegetableType) { // TODO Auto-generated method stub if(vegetableType==CABBAGE){ return new Cabbage(); } if(vegetableType==TOMATO){ return new Tomato(); } if(vegetableType==EGGPLANT){ return new Eggplant(); } return null; } } |
可以看到，它们都是属于种植物这一类，所以都是继承了种植工厂类
|
1
2
3
4
|
public abstract class PlantFactory { abstract Fruit getFruit(int fruitType); abstract Vegetable getVegetable(int vegetableType); } |
最后，提供一个工厂生产器，即生产工厂的工厂：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
public class Plantation { public static final int FRUIT=1; public static final int VEGETABLE=2; public static PlantFactory getFactory(int factoryType){ if(factoryType==FRUIT){ return new FruitFactory(); } if(factoryType==VEGETABLE){ return new VegetableFactory(); } return null; } } |
好吧，写个main测试下：
|
1
2
3
4
5
6
7
8
9
10
11
|
public static void main(String[] args) { // TODO Auto-generated method stub FruitFactory fruitFactory=(FruitFactory)Plantation.getFactory(Plantation.FRUIT); Apple apple=(Apple) fruitFactory.getFruit(FruitFactory.APPLE); apple.printInfo(); VegetableFactory vegetableFactory=(VegetableFactory)Plantation.getFactory(Plantation.VEGETABLE); Tomato tomato=(Tomato) vegetableFactory.getVegetable(VegetableFactory.TOMATO); tomato.printInfo(); } |
结果：
|
1
2
|
苹果西红柿 |
虽然工厂设计模式在获取产品类时很方便，但实际上产品的需求越严格，那么内部系统则越发庞大复杂，对于生产一些小产品来说，使用这么复杂庞大的系统反而浪费资源。
总结
以上就是本文关于Java设计模式笔记之抽象工厂代码示例的全部内容。代码是一个人主观意志的客观反映。。。胡扯了，参考别人写的代码，另外，多看看源码也是有好处的，学习别人实现某个功能的设计思路，来提高自己的编程水平。有什么问题可以随时留言，欢迎大家交流讨论。
原文链接：http://blog.csdn.net/qq_18870023/article/details/51274230
