目录

定义

使用场景

UML

模式1

模式2

模式3

简单工厂模式静态工厂模式

简单实现

Android源码中的工厂方法

总结

优点

缺点

工厂方法模式也是创建型模式。

工厂模式根据抽象程度可以分为三种：简单工厂模式，工厂方法模式，抽象工厂模式。

定义

定义一个用于创建对象的接口，让子类决定实例化哪一个类。

使用场景

任何需要生成复杂对象的地方，都可以使用工厂方法模式。用new就能创建的对象不需要使用工厂模式，因为使用工厂模式就要增加一个工厂类，增加了系统复杂度。

UML

模式1

抽象的产品：

public abstract class Product {

public abstract void method();

}

具体的产品：

public class ConcreteProductA extends Product {

@Override

public void method() {

System.out.println("产品A");

}

}

public class ConcreteProductB extends Product {

@Override

public void method() {

System.out.println("产品B");

}

}

抽象的工厂：

public abstract class Factory {

public abstract Product createProduct();

}

具体的工厂：

public class ConcreteFactory extends Factory {

@Override

public Product createProduct() {

return new ConcreteProductA();

}

}

客户端使用:

public class Client {

public static void main(String[] args) {

Factory factory = new ConcreteFactory();

Product product = factory.createProduct();

product.method();

}

}

这样就生产出来一个ConcreteProductA。

如果想生产ConcreteFactory，在ConcreteFactory里修改为返回ConcreteFactory就行了。

public class ConcreteFactory extends Factory {

@Override

public Product createProduct() {

return new ConcreteProductB();

}

}

模式2

通过反射来了解要生产哪个产品

抽象工厂：

public abstract class Factory {

public abstract T createProduct(Class clz);

}

具体工厂：

public class ConcreteFactory extends Factory {

@Override

public T createProduct(Class clz) {

Product product = null;

try {

product= (Product) Class.forName(clz.getName()).newInstance();

} catch (InstantiationException e) {

e.printStackTrace();

} catch (IllegalAccessException e) {

e.printStackTrace();

} catch (ClassNotFoundException e) {

e.printStackTrace();

}

return (T) product;

}

}

客户端调用：

public class Client {

public static void main(String[] args) {

Factory factory = new ConcreteFactory();

Product product = factory.createProduct(ConcreteProductB.class);

product.method();

}

}

这样，客户端调用的时候，传入什么产品就生产什么产品。

模式3

可以为每个产品都创建一个具体的工厂类，如：

public class ConcreteFactoryA extends Factory {

@Override

public Product createProduct() {

return new ConcreteProductA();

}

}

public class ConcreteFactoryB extends Factory {

@Override

public Product createProduct() {

return new ConcreteProductA();

}

}

要生产哪个就调用哪个工厂。

这种叫多工厂方法模式。

简单工厂模式(静态工厂模式)

当确定工厂类只有一个的时候，

public class Factory{

public static Product createProduct(){

return new ConcreteProductA();

//return new ConcreteProductB();

}

}

简单实现

以汽车举个例子，

抽象的汽车厂：

public abstract class AodiFactory {

public abstract T createAudiCar(Class clz);

}

具体的汽车生产工厂：

public class AodiCarFactory extends AodiFactory {

@Override

public T createAudiCar(Class clz) {

AodiCar aodiCar = null;

try {

aodiCar = (AodiCar) (Class.forName(clz.getName())).newInstance();

} catch (Exception e) {

e.printStackTrace();

}

return (T) aodiCar;

}

}

抽象的汽车：

public abstract class AodiCar {

public abstract void diver();

public abstract void selfNav();

}

具体的汽车：

public class AodiQ3 extends AodiCar {

@Override

public void diver() {

System.out.println("Q3启动");

}

@Override

public void selfNav() {

System.out.println("Q3导航");

}

}

public class AodiQ5 extends AodiCar {

@Override

public void diver() {

System.out.println("Q5启动");

}

@Override

public void selfNav() {

System.out.println("Q5导航");

}

}

客户端调用：

public class Client {

public static void main(String[] args) {

AodiFactory aodiFactory = new AodiCarFactory();

AodiCar Q3 = aodiFactory.createAudiCar(AodiQ3.class);

Q3.diver();

Q3.selfNav();

AodiCar Q5 = aodiFactory.createAudiCar(AodiQ5.class);

Q5.diver();

Q5.selfNav();

}

}

Android源码中的工厂方法

书中举例是Activity的onCreate()方法，理由是：在不同的Activity的onCreate方法中调用setContentView会根据设置的不同的布局文件而产生不同的布局，所以可以看做是一个工厂。

个人觉得有点牵强吧。。。不知道你们怎么看呢？

有个很明显的BitmapFactory，应该是符合简单工厂模式的：

package android.graphics;

public class BitmapFactory {

public static Bitmap decodeFile(String pathName, Options opts) {

Bitmap bm = null;

......

return bm;

}

//有很多静态方法返回一个Bitmap对象。

}

总结

优点

降低了对象之间的耦合度，代码结构清晰，对调用者隐藏了产品的生产过程，生产过程改变后，调用者不用做什么改变，易于修改。

易于拓展，要增加工厂和产品都非常方便，直接实现接口，不用修改之前的代码。

缺点

缺点应该就是会让系统结构复杂化了，如果是非常简单的结构就不需要使用这种模式了。