avatar

目录
工厂方法模式

个人博客

http://www.milovetingting.cn

工厂方法模式

模式介绍

工厂方法模式是创建型设计模式之一。

模式定义

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

使用场景

在任何需要生成复杂对象的地方,都可以使用工厂方法模式。用new就可以完成创建的对象无需使用工厂方法模式。

简单实现

定义抽象类Product

java
1
2
3
4
5
6
7
8
public abstract class Product {

/**
* 抽象方法,具体由子类实现
*/
public abstract void method();

}

定义实现类ProductA,ProductB

java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class ProductA extends Product {

@Override
public void method() {
System.out.println("productA:method");
}

}

public class ProductB extends Product {

@Override
public void method() {
System.out.println("productB:method");
}

}

定义抽象工厂Factory

java
1
2
3
4
5
6
7
8
9
10
public abstract class Factory {

/**
* 抽象工厂方法,具体由子类实现
*
* @return
*/
public abstract Product createProduct();

}

定义实现类FactoryA,FactoryB

java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class FactoryA extends Factory {

@Override
public Product createProduct() {
return new ProductA();
}

}

public class FactoryB extends Factory {

@Override
public Product createProduct() {
return new ProductB();
}

}

调用

java
1
2
3
4
5
public static void main(String[] args) {
Factory factory = new FactoryA();
Product product = factory.createProduct();
product.method();
}

输出:

Code
1
productA:method
java
1
2
3
4
5
public static void main(String[] args) {
Factory factory = new FactoryB();
Product product = factory.createProduct();
product.method();
}

输出:

Code
1
productB:method

这种方式,在Product的子类增加的时候,需要增加Product的实现以及Factory的实现。可以利用反射的方式更简洁地扩展,增加Product的子类时,不需要再增加Factory的子类

java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public abstract class AbstractFactory {

/**
* 抽象工厂方法,具体由子类实现
*
* @param clz
* @return
*/
public abstract <T extends Product> T createProduct(Class<T> clz);

}

public class FactoryImpl extends AbstractFactory {

@Override
public <T extends Product> T createProduct(Class<T> clz) {
Product product = null;
try {
product = (Product) Class.forName(clz.getName()).newInstance();
} catch (Exception e) {
e.printStackTrace();
}
return (T) product;
}

}

调用

java
1
2
3
4
5
public static void main(String[] args) {
AbstractFactory factory = new FactoryImpl();
Product product = factory.createProduct(ProductA.class);
product.method();
}

输出结果:

Code
1
productA:method

调用

java
1
2
3
4
5
public static void main(String[] args) {
AbstractFactory factory = new FactoryImpl();
Product product = factory.createProduct(ProductB.class);
product.method();
}

输出结果:

Code
1
productB:method

小结

总的来说,工厂方法模式是一个很好的设计模式,但是缺点也是难以避免的,每次我们为工厂方法模式添加新的产品时就要编写一个新的产品类,同时还要引入抽象层,这必然会导致类结构的复杂化,所以在某些情况比较简单时,是否要使用工厂方法 模式,需要设计者权衡利弊。

文章作者: milovetingting
文章链接: http://www.milovetingting.cn/2020/01/14/%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F/%E5%B7%A5%E5%8E%82%E6%96%B9%E6%B3%95%E6%A8%A1%E5%BC%8F/
版权声明: 本博客所有文章除特别声明外,均采用 CC BY-NC-SA 4.0 许可协议。转载请注明来自 milovetingting

评论