移动架构之简单工厂模式

发表于 | 分类于 | |

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

使用场景

在创建对象的时候，提供创建对象的功能，而不用关心其具体实现细节
这样做的好处在于降低了客户端与模块之间的耦合性，使得模块可以更好的扩展

理解实例

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
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();
		}
	}
}

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

1
2
3
4
5
6
7
public class Test {

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

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

常见工厂模式例子

在简单工厂模式中，有一个比较重要的思想就是将对象的实现延迟到子类中去，这样可以有效降低代码的耦合，使得新功能更加容易添加
下面举一个例子，首先有一个接口，里面定义方法，这里我就定义一个只有一个方法的接口，讲一下思路

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

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

1
2
3
4
5
6
7
public class ConcreteProduct implements Product{

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

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

1
2
3
4
5
6
7
public abstract class Creator {
	protected abstract Product factoryMethod();
	public void get() {
		Product product = factoryMethod();
		product.use("test");
	}
}

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

1
2
3
4
5
6
7
public class ConcreteCreator extends Creator {

	@Override
	protected Product factoryMethod() {
		return new ConcreteProduct();
	}
}

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

1
2
3
4
5
6
7
public class Test {

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

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

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

在使用简单工厂模式的时候，其创建对象的过程依旧繁琐，没有体现对调用者的友好，那么在这个基础之上，出现了抽象工厂模式
其实现步骤都是类似的，首先需要一个接口

1
2
3
public interface IApi {
	public void use();
}

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

1
2
3
4
5
6
public class PNGApi implements IApi {
	@Override
	public void show() {
		System.out.println("Test for PNGApi");
	}
}

1
2
3
4
5
6
public class JPEGApi implements IApi {
	@Override
	public void show() {
		System.out.println("Test for JPEGApi");
	}
}

需要一个抽象工厂

1
2
3
public interface IFactory {
	IApi createApi();
}

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

1
2
3
4
5
6
public class PNGFactory implements IFactory{
	@Override
	public IApi createApi() {
		return new PNGApi();
	}
}

1
2
3
4
5
6
public class JPEGFactory implements IFactory{
	@Override
	public IApi createApi() {
		return new JPEGApi();
	}
}

然后在在测试中调用

1
2
3
4
5
6
public class Test {
	public static void main(String[] args) {
		IFactory factory = new PNGFactory();
		factory.createApi().show();
	}
}

Donate comment here