Java设计模式-工厂方法模式

定义

工厂方法模式是一种结构简单的模式,它是创建型设计模式之一。它定义一个用于创建对象的接口,让子类决定实例化哪个类。

实例

首先我们来看一下关于工厂方法模式的模板:

1、抽象产品类

1
2
3
4
5
6
7
public abstract class Product {
/**
* 产品类的抽象方法,由具体的产品类实现该方法
*/
public abstract void method();
}

2、具体产品A

1
2
3
4
5
6
7
public class ConcreteProductA extends Product {
@Override
public void method() {
System.out.print("我是具体的产品A");
}
}

3、具体产品B

1
2
3
4
5
6
7
public class ConcreteProductB extends Product {
@Override
public void method() {
System.out.print("我是具体的产品B");
}
}

4、抽象工厂类

1
2
3
4
5
6
7
8
9
10
public abstract class Factory {
/**
* 抽象工厂方法
* 具体生产什么由子类去实现
*
* @return
*/
public abstract Product createProduct();
}

5、具体工厂类

1
2
3
4
5
6
7
8
public class ConcreteFactory extends Factory {
//产生具体产品A,可替换成B
@Override
public Product createProduct() {
return new ConcreteProductA();
}
}

6、客户测试类

1
2
3
4
5
6
7
8
public class Client {
public static void main(String[] args) {
Factory factory = new ConcreteFactory();
Product p = factory.createProduct();
p.method();
}
}

7、打印结果

以上就是一个简单的工厂方法模板代码,这几个角色都很简单,主要分为四大模块:

  1. 抽象工厂,其为工厂方法模式的核心
  2. 具体工厂,实现了具体的业务逻辑
  3. 抽象产品,是工厂方法模式所创建产品的父类
  4. 具体产品,实现了抽象产品的某个产品的对象。

在上面的Client类中构造了一个工厂对象,并通过其生产了一个产品对象这里我们得到的产品对象是ConcreteProductA的实例,如果想得到ConcreteProductB的实例,直接更改ConcreteFactory中的逻辑即可:

1
2
3
4
5
6
7
8
public class ConcreteFactory extends Factory {
//生成B产品
@Override
public Product createProduct() {
return new ConcreteProductB();
}
}

这种方式比较常见,需要哪一款产品就生成哪一款产品,有时候可以通过反射的方式更简洁的来生成具体产品对象,此时,在工厂方法的参数列表中传入一个Class类来决定是哪一款产品类。

反射实现工厂方法模式

1
2
3
4
5
6
7
8
9
10
11
12
public abstract class RefFactory {
/**
* 抽象工厂方法
* 具体生成什么产品由子类去实现
*
* @param clz
* @param <T>
* @return
*/
public abstract <T extends Product> T createProduct(Class<T> clz);
}

对于具体的工程类,我们通过反射获取类的实例即可。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class RefConcreteFactory extends RefFactory {
/**
* 具体工厂类,通过反射来获取类的实例
*
* @param clz
* @param <T>
* @return
*/
@Override
public <T extends Product> T createProduct(Class<T> clz) {
Product p = null;
try {
p = (Product) Class.forName(clz.getName()).newInstance();
} catch (Exception e) {
e.printStackTrace();
}
return (T) p;
}
}

对于客户测试类,可通过以下代码实现:

1
2
3
4
5
6
7
8
9
10
public class Client {
public static void main(String[] args) {
RefFactory factory = new RefConcreteFactory();
//传入具体产品的Class,这里我们传入产品B的Class
Product p = factory.createProduct(ConcreteProductB.class);
p.method();
}
}

打印结果

如预期结果一样,需要哪一个类的对象就传入哪一个类的类型即可,这种方式比较简洁、动态。

像上面这种方式又称为简单工厂模式或者静态工厂模式,它是工厂模式的一个弱化版本。工厂模式完全符合设计原则,其降低了对象之间的耦合度,而且工厂模式依赖于对象的架构,其将实例化的任务交由子类去完成,有非常好的扩展性。

以上内容来自于《Android源码设计模式解析与实战》


关于作者:

1. 博客 http://crazyandcoder.github.io/

2. github https://github.com/crazyandcoder

3. 掘金 https://juejin.im/user/56b96af96240b8005865df59/share