工厂模式——Factory Pattern

工厂模式就是实现了创建者与调用者的分离，核心是实例化对象时用工厂方法代替new操作，将选择实现类、创建对象统一管理和控制，从而将调用者与实现类解耦。详细又可以分为一下三类：

• 简单工厂模式【Simple Factory】
• 工厂方法模式【Factory Method】
• 抽象工厂模式【Abstract Method】

应用场景包括一下几种常见的：

1. JDK中Calendar的getInstance()方法
2. JDBC中Connection对象的获取
3. hihernate中SessionFactory对象创建session
4. 反射中Class对象的newInstance()方法
   

简单工厂模式

下面用一段简单的代码来描述一下简单工厂模式：

/**
 * 电脑
 * @author acer
 */
public interface Computer {
    public void open();//开机
}

public class Acer implements Computer{
    @Override
    public void open() {
        System.out.println("宏碁电脑开机了");
    }
}

public class Dell implements Computer{
    @Override
    public void open() {
        System.out.println("戴尔开机了");
    }
}

创建工厂方法：

/**
 * 创建电脑的工厂类
 * @author acer
 */
public class ComputerSimpleFactory {
	/**
	 * 简单工厂方法1
	 * @param type
	 * @return
	 */
	public static Computer createComputer(String type){
		if("Acer".equals(type)) {
			return new Acer();
		}else if("Dell".equals(type)) {
			return new Dell();
		}else {
			return null;
		}
	}
	
	/**
	 * 简单工厂方法2
	 */
	public static Computer createAcer(){
		return new Acer();
	}
	
	public static Computer createDell(){
		return new Dell();
	}
}

测试类

public class Client1 {

	public static void main(String[] args) {
		//没有简单工厂方法时
		Computer acer = new Acer();
		Computer dell = new Dell();
		acer.open();
		dell.open();
		
		//有简单工厂方法时
		Computer acer1 = ComputerSimpleFactory.createComputer("Acer");
		Computer dell1 = ComputerSimpleFactory.createComputer("Dell");
		acer1.open();
		dell1.open();
	}
}

可以发现使用了工厂方法之后类之间的耦合度降低了。

简单工厂模式又叫静态工厂方法，工厂类一般使用静态方法，通过接受的不同的参数来返回不同的对象实例。不过对于扩展的话，只能通过修改代码来实现。但是这样做又不符合COP(开闭原则)。所以为了避免这种缺点，于是又创建了工厂方法模式。但是在实际项目中使用简单工厂模式比较多。

工厂方法模式

/**
 * 电脑
 * @author acer
 */
public interface Computer {
	public void open();//开机
}

public class Acer implements Computer{
    @Override
    public void open() {
        System.out.println("宏碁电脑开机了");
    }
}

public class Dell implements Computer{
    @Override
    public void open() {
        System.out.println("戴尔开机了");
    }
}

下面是工厂方法模式，建立一个工厂方法接口，所有类的工厂类都实现该接口：

public interface FactoryMethod {
    //创建电脑的方法
    public Computer createComputer();
}

/**
 * acer电脑的工厂
 * @author acer
 */
public class AcerFactory implements FactoryMethod{
    @Override
    public Computer createComputer() {
        return new Acer();
    }
}

/**
 * Dell电脑的工厂类
 * @author acer
 */
public class DellFactory implements FactoryMethod {
    @Override
    public Computer createComputer() {
        return new Dell();
    }
}

测试类：

public class Client {
	public static void main(String[] args) {
		Computer acer1 = new AcerFactory().createComputer();
		Computer dell1 = new DellFactory().createComputer();
		acer1.open();
		dell1.open();
	}
}

这样工厂方法模式可以看出来，符合开闭原则。每添加一个类，只要相应的建立它的工厂类就可以。但是这样的做法会使系统中类的数量增加，在一定程度上增加了系统的复杂度。

抽象工厂模式

用来生产不同产品族的全部产品（对于增加新的产品无能为力）。抽象工厂模式是工厂方法模式的升级版本，在有多个业务品种、业务分类时，通过抽象工厂模式产生需要的对象是一种非常好的解决办法。就是说希望一个工厂可以提供多个产品的时候应该使用抽象工厂方法。在此之前需要理解一下产品族。比如:电脑CPU分为四核的和八核的，那么八核cpu和四核的cpu属于一个产品族。

电脑cpu的接口，以及定义的cpu产品族中的产品：

/**
 * cpu
 * @author acer
 */
public interface CPU {
	public void run();
}

class FourCoreCPU implements CPU{
	@Override
	public void run() {
		System.out.println("运行效率一般");
	}
}

class EightCoreCPU implements CPU{
	@Override
	public void run() {
		System.out.println("运行速度杠杠的");
	}
}

电脑内存的接口，以及定义的内存产品族中的产品：

public interface Memory {
	public void save();
}

class GBMemory implements Memory{
	@Override
	public void save() {
		System.out.println("内存大小一般");	
	}
}
class TBMemory implements Memory{
	@Override
	public void save() {
		System.out.println("内存相当大了");		
	}
}

定义抽象工厂，该接口包含了一组方法来生产产品，具体工厂必须实现这个接口：

public interface ComputerFactory {
	public CPU createCPU();
	public Memory createMemory();
}

定义俩个具体工厂：

public class GoodComputerFac implements ComputerFactory{

	@Override
	public CPU createCPU() {
		return new EightCoreCPU();
	}

	@Override
	public Memory createMemory() {
		return new TBMemory();
	}
}

public class LowComputerFac implements ComputerFactory{
	@Override
	public CPU createCPU() {
		return new FourCoreCPU();
	}

	@Override
	public Memory createMemory() {
		return new GBMemory();
	}
}

推荐一篇博客，写的非常好：点击打开链接