工厂模式包括3种形式：简单工厂、工厂方法、抽象工厂。
工厂模式的目的：将类的实例生成，跟类接口的具体实现分离，实现解耦。这些类通常是具有继承和多态特点的约束关系，以便可以在抽象层调用统一的接口。
-
简单工厂
简单工厂是最简单的一种工厂模式，一般就是在工厂类的静态方法中，根据传入的参数生成相应的产品实现类的对象。
在产品类的种类单一，且个数比较少的场景下可以考虑使用简单工厂。
以下的工厂模式介绍，均以电子厂商，手机、平板电脑等产品作为例子说明。
抽象产品类：
public abstract class Product {
/**
* 打印产品的描述信息
*/
public abstract void printDesc();
}
具体产品——手机：
public class Phone extends Product {
@Override
public void printDesc() {
System.out.println("我是手机");
}
}
具体产品——平板电脑：
public class Tablet extends Product {
@Override
public void printDesc() {
System.out.println("我是平板电脑");
}
}
简单工厂类：
public class SimpleFactory {
// 产品类型：手机
public static final int TYPE_PHONE = 0;
// 产品类型：平板电脑
public static final int TYPE_TABLET = 1;
/**
* 根据类型参数生产产品
*
* @param type 产品类型
* @return 具体产品
*/
public static Product createProduct(int type) {
Product product = null;
switch (type) {
case TYPE_PHONE:
product = new Phone();
break;
case TYPE_TABLET:
product = new Tablet();
break;
default:
break;
}
return product;
}
}
客户端调用：
public class Client {
public static void main(String[] args) {
// 产品
Product product = null;
// 生产手机
product = SimpleFactory.createProduct(SimpleFactory.TYPE_PHONE);
product.printDesc();
// 生产平板电脑
product = SimpleFactory.createProduct(SimpleFactory.TYPE_TABLET);
product.printDesc();
}
}
可以看到简单工厂是比较简单的一种模式，其实跟static方法差不多。
-
工厂方法
简单工厂方式虽然使用简单，但是其实并没有实现真正的解耦。比如后面如果增加了一种新的产品笔记本电脑，那么还是需要修改SimpleFactory的代码，增加一个case或if判断，这与设计模式的六大法则之一的“开闭原则”是相违背的，因此可以考虑改用工厂方法模式。
工厂方法的核心思想是：为每一类产品都定义一个工厂类。这样做的好处是显而易见的，如果以后需要增加一类产品，那么同时也增加一个相应的工厂类，这样就不需要修改原来工厂类的接口了，而是新增。这就符合“对修改关闭，对增加开放”的原则。
相对于原来的SimpleFactory，我们先定义一个抽象的产品工厂类：
public abstract class ProductFactory {
// 产品可以是手机、平板电脑或其他新增的
public abstract Product createProduct();
}
对于手机产品，新增一个手机工厂类：
public class PhoneFactory extends ProductFactory {
@Override
public Product createProduct() {
return new Phone();
}
}
对于平板电脑，新增一个平板电脑工厂类：
public class TabletFactory extends ProductFactory {
@Override
public Product createProduct() {
return new Tablet();
}
}
客户端调用：
public class Client {
public static void main(String[] args) {
// 产品工厂
ProductFactory factory = null;
// 产品
Product product = null;
// 生产手机
factory = new PhoneFactory();
product = factory.createProduct();
product.printDesc();
// 生产平板电脑
factory = new TabletFactory();
product = factory.createProduct();
product.printDesc();
}
}
这样如果以后新增产品类型，只需要增加一个Product的子类和一个ProductFactory的实现类即可。
-
抽象工厂
我们看下简单工厂，只是对Product类进行了抽象（其实这种情况不抽象也可以，只要产品类有统一的接口），工厂类是static的方法。工厂方法对Product类和Factory类都进行了抽象，但它们是一对一的关系，即一个Product必定要由一个Factory来生成。
抽象工厂是一种抽象层次更高的模式，它跟工厂方法一样，对Product类和Factory类都进行抽象，只不过对于这两个抽象，都是和具体工厂本身挂钩的，或者说抽象的时候，考虑的不再是单一的产品，而是多种产品的聚合。
以上面工厂方法的例子，它的工厂是对产品进行抽象的：手机工厂、平板电脑工厂。比如现在有两个公司：苹果和三星，那么对抽象工厂模式来说，它的工厂是对这两个公司抽象的：苹果工厂、三星工厂，而这两个工厂，对外的接口都有两个：生产手机、生产平板电脑。可以这样认为，有多少类产品，在工厂类中就要定义多少个接口。
工厂方法是产品-->工厂类的映射，而抽象工厂是产品-->工厂类的接口的映射，这样做的话，工厂类本身可以携带更多的信息：苹果的工厂类，三星的工厂类，不再是某类特定产品的工厂类。
抽象产品类——手机：
public abstract class Phone {
// 打印手机信息
public abstract void printPhone();
}
抽象产品类——平板电脑：
public abstract class Tablet {
// 打印平板电脑信息
public abstract void printTablet();
}
抽象工厂类：
public abstract class AbsFactory {
/**
* 生产手机
*/
public abstract Phone createPhone();
/**
* 生产平板电脑
*/
public abstract Tablet createTablet();
}
对于苹果和三星两家公司，分别定义具体的产品类和具体的工厂类。
苹果手机：
public class ApplePhone extends Phone {
public void printPhone() {
System.out.println("我是苹果手机");
}
}
苹果平板电脑：
public class AppleTablet extends Tablet {
@Override
public void printTablet() {
System.out.println("我是苹果平板电脑");
}
}
三星手机：
public class SamsungPhone extends Phone {
@Override
public void printPhone() {
System.out.println("我是三星手机");
}
}
三星平板电脑：
public class SamsungTablet extends Tablet {
@Override
public void printTablet() {
System.out.println("我是三星平板电脑");
}
}
苹果工厂：
public class AppleFactory extends AbsFactory {
@Override
public Phone createPhone() {
return new ApplePhone();
}
@Override
public Tablet createTablet() {
return new AppleTablet();
}
}
三星工厂：
public class SamsungFactory extends AbsFactory {
@Override
public Phone createPhone() {
return new SamsungPhone();
}
@Override
public Tablet createTablet() {
return new SamsungTablet();
}
}
可见这两个具体的工厂，都有生产手机和平板电脑的能力了。
接下来是客户端调用：
public class Client {
public static void main(String[] args) {
// 工厂
AbsFactory factory = null;
// 手机
Phone phone = null;
// 平板电脑
Tablet tablet = null;
// 生产苹果公司的手机和平板电脑
factory = new AppleFactory();
phone = factory.createPhone();
phone.printPhone();
tablet = factory.createTablet();
tablet.printTablet();
// 生产三星公司的手机和平板电脑
factory = new SamsungFactory();
phone = factory.createPhone();
phone.printPhone();
tablet = factory.createTablet();
tablet.printTablet();
}
}
看下后面需求变化的情况：
- 如果增加一个新的公司比如Google，需要增加以下3个类：
GooglePhone、GoogleTablet、GoogleFactory - 如果增加一类新产品笔记本电脑，需要增加以下的类：
抽象产品：Notebook
苹果笔记本：AppleNotebook
三星笔记本：SamsungNotebook
可见新增的这些类，都没有改变原来类的接口，也不会对既有的类造成影响，因为仅仅是新增，并没有做修改。
不过这里面也有一个问题，随着产品类或者公司的增多，需要新增加的类也会越来越多，虽然不会造成指数级的上升，不过3x3还是会比2x2多了不少，因此随着时间的推移，最后也许会感叹简单工厂其实挺好使的^_^
