设计模式之工厂模式

定义

工厂模式使用频率非常高，在日常开发中总能见到它。工厂模式是定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法让一个类的实例化延迟到子类。
工厂方法通用的类图：

在工厂方法中，抽象产品类Product负责定义产品的共性，实现对事物最抽象的定义；Creator为抽象创建类，也就是抽象工厂，具体如何创建产品类是由具体的实现工厂ConcreteCreator完成的。

场景模拟

小明搬了新家，儿子要写作业了发现除了作业本其他都没有。。。他决定开个家具加工厂，自己生产板凳，桌子还有铅笔，供儿子写作业用。如何来完成这一过程呢？接着往下看代码。。

//抽象产品类
public interface Furniture {
	public void getName();
	public void affect();
}
//具体产品类
//板凳
public class Bench implements Furniture {

	@Override
	public void getName() {
		System.out.println("我是板凳，嘿嘿");
	}

	@Override
	public void affect() {
		System.out.println("板凳作用是供人休息");
	}

}
//桌子
public class Desk implements Furniture {
	@Override
	public void getName() {
		System.out.println("生产出来书桌啦，嘿嘿嘿");
	}

	@Override
	public void affect() {
		System.out.println("书桌可以用于写作业使用");
	}

}
//铅笔
public class Pencil implements Furniture {

	@Override
	public void getName() {
		System.out.println("生产出来铅笔了，嘻嘻");
	}

	@Override
	public void affect() {
		System.out.println("可以用铅笔写作业");
	}


}
//抽象工厂类
public abstract class AbstractfurnitureFactory {
	public abstract <T extends Furniture> T createfurniture(Class<T> c);
}
//具体工厂类
public class FurnitureFactory extends AbstractfurnitureFactory {

	@Override
	public <T extends Furniture> T createfurniture(Class<T> c) {
		Furniture furniture=null;
		try {
			furniture=(T)Class.forName(c.getName()).newInstance();
		} catch (Exception e) {
			System.out.println("木头家具生成错误！");
		}
		return (T)furniture;
	}

}
//最后写个实现类
public class Student {

	public static void main(String[] args) {
		AbstractfurnitureFactory factory=new FurnitureFactory();
		System.out.println("---生产一批板凳---");
		Furniture bench=factory.createfurniture(Bench.class);
		bench.getName();
		bench.affect();
		System.out.println("---生产一批桌子---");
		Furniture desk=factory.createfurniture(Desk.class);
		desk.getName();
		desk.affect();
		System.out.println("---生产一批铅笔---");
		Furniture pencil=factory.createfurniture(Pencil.class);
		pencil.getName();
		pencil.affect();
		System.out.println("开始写作业了，再打扰我就跟你们一块玩");
		
	}

}

来来来，运行一下看看

哇，家具的生产过程就展示出来了呢。小明的儿子小小明终于能愉快的写作业了。。

工厂方法模式的扩展

工厂方法有很多扩展，与其他设计模式结合使用效果更佳。下面介绍4中扩展

1. 缩小为简单工厂模式

所谓简单工厂模式就是把抽象工厂类给去掉，同时把createfurniture方法设置成静态类型，简化了类的创建过程。代码仅需变工厂类和实现类就行了

//工厂类变更
public class FurnitureFactory {

	public static <T extends Furniture> T createfurniture(Class<T> c) {
		Furniture furniture=null;
		try {
			furniture=(T)Class.forName(c.getName()).newInstance();
		} catch (Exception e) {
			System.out.println("木头家具生成错误！");
		}
		return (T)furniture;
	}

}
//实现类变成
public class Student {

	public static void main(String[] args) {
		System.out.println("---生产一批板凳---");
		Furniture bench=FurnitureFactory.createfurniture(Bench.class);
		bench.getName();
		bench.affect();
		System.out.println("---生产一批桌子---");
		Furniture desk=FurnitureFactory.createfurniture(Desk.class);
		desk.getName();
		desk.affect();
		System.out.println("---生产一批铅笔---");
		Furniture pencil=FurnitureFactory.createfurniture(Pencil.class);
		pencil.getName();
		pencil.affect();
		System.out.println("开始写作业了，再打扰我就跟你们一块玩");
	}
}

该模式是工厂方法模式的弱化，因为简单称为简单工厂模式，或静态工厂模式。在实际项目中，采用该方法的案例还是挺多的，其缺点是工厂类的扩展比较困难，不符合开闭原则，但它仍然是一个非常实用的设计模式。

2.升级成多个工厂类

当在做一个相当复杂的项目时，经常遇到初始化一个对象很麻烦的情况，所有的产品类都放在一个工厂方法中进行初始化，会使代码结构不清晰。为了解决这个问题，我们就为每个产品定义一个工厂，然后由调用者决定调用哪个工厂方法关联。这叫多工厂模式，还以小小明写作业为例，来看看代码怎么发生变化吧。

//抽象工厂类，不需要泛型
public abstract class AbstractfurnitureFactory {
	public abstract Furniture  createfurniture();
}
//具体工厂类
public class BenchFactory extends AbstractfurnitureFactory{

	@Override
	public Furniture createfurniture() {
		// TODO Auto-generated method stub
		return new Bench();
	}
}
public class DeskFactory extends AbstractfurnitureFactory{

	@Override
	public Furniture createfurniture() {
		// TODO Auto-generated method stub
		return new Desk();
	}
}
public class PencilFactory extends AbstractfurnitureFactory{
	@Override
	public Furniture createfurniture() {
		// TODO Auto-generated method stub
		return new Pencil();
	}
}
//实现类
public class Student {

	public static void main(String[] args) {
		System.out.println("---生产一批板凳---");
		Furniture bench=(new BenchFactory()).createfurniture();
		bench.getName();
		bench.affect();
		System.out.println("---生产一批桌子---");
		Furniture desk=(new DeskFactory()).createfurniture();
		desk.getName();
		desk.affect();
		System.out.println("---生产一批铅笔---");
		Furniture pencil=(new PencilFactory()).createfurniture();
		pencil.getName();
		pencil.affect();
		System.out.println("开始写作业了，再打扰我就跟你们一块玩");
		
	}

}

这样定眼一看，每个产品类都对应了一个创建类，好处是创建类职责清晰，结构简单，但是增加了扩展难度。因为要扩展一个产品类，就需要建立一个对应的工厂类，一个产品类对应一个工厂类，维护时也需要考虑两个对象之间的关系。

3.替代单例模式

public class SingletonFactory {
	private static Singleton singleton;
	static {
		try {
			Class cl=Class.forName(Singleton.class.getName());
			//获得无参构造
			Constructor constructor=cl.getDeclaredConstructor();
			//设置无参构造可访问
			constructor.setAccessible(true);
			singleton=(Singleton)constructor.newInstance();
		} catch (Exception e) {
			// TODO: handle exception
		}
	}
	public static Singleton getSingleton() {
		return singleton;
	}
}

通过获得类构造器，然后设置访问权限，生成一个对象，然后提供外部访问，确保内存中的对象唯一。