设计模式之-----抽象工厂模式

今天来学习抽象工厂模式，所谓的抽象工厂，其实和工厂模式有相似之处，在介绍抽象工厂之前，先了解两个概念：产品族和产品等级

我不要官方的话解释，那样太晦涩难懂，我先给大家看一张图，看完之后我想大家能对这个概念有个了解。



这是我用Visio画的，从这个图看，是不是很直观的看出他们的定义呢？

由不同的产品等级的产品构成了一个产品组。他们之间大概就是这个关系。

然后回到抽象工厂模式，我们根据代码，来看一看是一个怎样的步骤，用文字叙述半天也不如直接看代码来的快。我还是用上边的例子。

先看包结构：



我们首先要做的，就是新建一个抽象类（接口也可以）

package com.abstractfactory.abs.product;

/**
* 所有产品的抽象类
* @author ZHENGWEI
* @date Jul 28, 2015
*/
public abstract class Product {

/**
* 显示产品的名称
*/
public abstract void show();
}

因为这个例子有四个实际的产品，那么我们新建四个类，继承上边的抽象类（或实现接口）

package com.abstractfactory.product;

import com.abstractfactory.abs.product.Product;

/**
* 福建的香蕉
* @author ZHENGWEI
* @date Jul 28, 2015
*/
public class ProductFuJianBanana extends Product {

@Override
public void show() {
System.out.println("福建的香蕉");
}

}

package com.abstractfactory.product;

import com.abstractfactory.abs.product.Product;

public class ProductFuJianMango extends Product {

@Override
public void show() {
System.out.println("福建的芒果");
}

}

package com.abstractfactory.product;

import com.abstractfactory.abs.product.Product;

/**
* 海南的香蕉
* @author ZHENGWEI
* @date Jul 28, 2015
*/
public class ProductHaiNanBanana extends Product{

@Override
public void show() {
System.out.println("海南的香蕉");
}

}

package com.abstractfactory.product;

import com.abstractfactory.abs.product.Product;

/**
* 海南的芒果
* @author ZHENGWEI
* @date Jul 28, 2015
*/
public class ProductHaiNanMango extends Product {

@Override
public void show() {
System.out.println("海南的芒果");
}

}

好了，四个类写完了，之后我们在建一个抽象类（接口也可以）

package com.abstractfactory.abs.creater;

import com.abstractfactory.abs.product.Product;

/**
* 根据产品族来区分
* @author ZHENGWEI
* @date Jul 28, 2015
*/
public abstract class ProductCreater {

/**
* 生产香蕉，这里不对产品等级区分
* @return
*/
public abstract Product createProductBanana();

/**
* 生产芒果，这里不对产品等级区分
* @return
*/
public abstract Product createProductMango();
}

然后，根据产品族，来将四个实例划分一下

package com.abstractfactory.creater;

import com.abstractfactory.abs.creater.ProductCreater;
import com.abstractfactory.abs.product.Product;
import com.abstractfactory.product.ProductFuJianBanana;
import com.abstractfactory.product.ProductFuJianMango;

/**
* 只生产福建的产品
* @author ZHENGWEI
* @date Jul 28, 2015
*/
public class CreateByFuJian extends ProductCreater {

/**
* 生产福建的香蕉
*/
@Override
public Product createProductBanana() {
return new ProductFuJianBanana();
}

/**
* 生产福建的芒果
*/
@Override
public Product createProductMango() {
return new ProductFuJianMango();
}

}

package com.abstractfactory.creater;

import com.abstractfactory.abs.creater.ProductCreater;
import com.abstractfactory.abs.product.Product;
import com.abstractfactory.product.ProductHaiNanBanana;
import com.abstractfactory.product.ProductHaiNanMango;

/**
* 只生产海南的产品
* @author ZHENGWEI
* @date Jul 28, 2015
*/
public class CreateByHaiNan extends ProductCreater {

/**
* 生产海南的香蕉
*/
@Override
public Product createProductBanana() {
return new ProductHaiNanBanana();
}

/**
* 生产海南的芒果
*/
@Override
public Product createProductMango() {
return new ProductHaiNanMango();
}

}

到现在，抽象工厂已经写完了，是不是很简单啊？最后来个测试类

package com.abstractfactory.main;

import com.abstractfactory.abs.creater.ProductCreater;
import com.abstractfactory.creater.CreateByFuJian;
import com.abstractfactory.creater.CreateByHaiNan;

public class AbstractFactoryMain {

public static void main(String[] args) {
//福建
ProductCreater createrF = new CreateByFuJian();
createrF.createProductBanana().show();
createrF.createProductMango().show();

//海南
ProductCreater createrH = new CreateByHaiNan();
createrH.createProductBanana().show();
createrH.createProductMango().show();
}

}

最后结果：



那么我们回头思考一下，这个模式有没有缺点呢？当然有，假设一下，现在我们新增了一个西瓜，怎么修改呢？我们肯定要修改之前的ProductCreater抽象工厂，可是这样一来，就违反了开闭原则。

再来看，我们新增一个产品族，广东，这个时候，我们不必修改任何代码，只需要增加广东的相关实现即可，这个方面，又很好的实现了开闭原则。

所以我们在选择这个模式的时候，一定要有一个明确的，长远的考虑，如果我们要频繁增加产品等级，建议还是不要使用这个模式。反之亦然。