简单工厂模式是属于创建型模式，又叫做静态工厂方法（Static Factory Method）模式，但不属于23种GOF设计模式之一。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式，可以理解为是不同工厂模式的一个特殊实现

使用场景

在创建对象的时候，提供创建对象的功能，而不用关心其具体实现细节

这样做的好处在于降低了客户端与模块之间的耦合性，使得模块可以更好的扩展

理解实例

在创建创建对象的时候，不用关心其细节实现，直接传递参数创建对象，这样的方法抽象出来就是简单工厂的来源

例如现在有三个（A，B，C）实现某接口的对象，要通过简单工厂能狗实例化出来，那么在这种情况下就应该在工厂里面实现对象的创建，而使用者并不用关心其具体实现，那么可以简单用下面的例子来表示

public class Factory {
    		public static final int CLASSATYPE = 0;	public static final int CLASSBTYPE = 1;	public static final int CLASSCTYPE = 2;		public static TestApi create(int type) {
    		switch (type) {
    		case CLASSATYPE:			return new ClassA();		case CLASSBTYPE:			return new ClassB();		case CLASSCTYPE:			return new ClassC();		default:			return new ClassA();		}	}}

而在创建的时候则不需要知道具体细节，按照调用方法传递参数即可，这是利用面向对象的多态来实现调用子类对象的方法

public class Test {
    	public static void main(String[] args) {
    		TestApi api = Factory.create(Factory.CLASSATYPE);		System.out.println(api.getClass().getName());	}}

这种设计思想在Android中很是常见，例如Bitmap创建，xml解析等都使用到了工厂模式的思想，这里需要注意一点，一般工厂里面创建的类大多数情况下都是默认权限，在其他包名下的类是无法访问的

常见工厂模式例子

在简单工厂模式中，有一个比较重要的思想就是将对象的实现延迟到子类中去，这样可以有效降低代码的耦合，使得新功能更加容易添加

下面举一个例子，首先有一个接口，里面定义方法，这里我就定义一个只有一个方法的接口，讲一下思路

public interface Product {
    	public void use(String str);}

然后需要很多类来继承这个接口，也就是这个接口具体的实现

public class ConcreteProduct implements Product{
    	@Override	public void use(String str) {
    		System.out.println(str);			}}

接下来就是要有一个工厂方法，用来实例化对象，而这里的对象是不确定的，为了程序的拓展性，这里只是定义了一个抽象方法

public abstract class Creator {
    	protected abstract Product factoryMethod();	public void get() {
    		Product product = factoryMethod();		product.use("test");	}}

在子类中将抽象方法实现，返回具体的对象实例

public class ConcreteCreator extends Creator {
    	@Override	protected Product factoryMethod() {
    		return new ConcreteProduct();	}}

那么在具体使用的时候直接使用便可

public class Test {
    	public static void main(String[] args) {
    		ConcreteCreator creator = new ConcreteCreator();		creator.get();	}}

其思路其实就是有一个抽象接口，然后有很多具体实现类，然后有一个创建器抽象类，具体的创建器在其子类中实现

工厂模式拓展-抽象工厂模式

在使用简单工厂模式的时候，其创建对象的过程依旧繁琐，没有体现对调用者的友好，那么在这个基础之上，出现了抽象工厂模式

其实现步骤都是类似的，首先需要一个接口

public interface IApi {
    	public void use();}

然后是实现这个接口的具体类，这里设置一个PNGApi和一个JPEGApi类

public class PNGApi implements IApi {
    	@Override	public void show() {
    		System.out.println("Test for PNGApi");	}}

public class JPEGApi implements IApi {
    	@Override	public void show() {
    		System.out.println("Test for JPEGApi");	}}

需要一个抽象工厂

public interface IFactory {
    	IApi createApi();}

让后是实现这个抽象工厂的类

public class PNGFactory implements IFactory{
    	@Override	public IApi createApi() {
    		return new PNGApi();	}}

public class JPEGFactory implements IFactory{
    	@Override	public IApi createApi() {
    		return new JPEGApi();	}}

然后在在测试中调用

public class Test {
    	public static void main(String[] args) {
    		IFactory factory = new PNGFactory();		factory.createApi().show();	}}