什么是工厂模式
大家在开发中应该都使用过或者看到过SqlSessionFactory或者BeanFactory,这就是使用工厂模式来生产对象。工厂模式用于封装和管理对象的创建,分离对象的创建者和调用者,实现与对象解耦的目的。
工厂模式可以分为:
- 简单工厂
- 工厂方法
- 抽象工厂
简单工厂通过接收的参数的不同来返回不同的对象实例,涉及到的角色有:
- 抽象产品
- 具体产品
- 具体工厂
- 调用者
// 抽象产品
public interface Car {
void run();
}// 具体产品1
public class Audi implements Car {
@Override
public void run() {
System.out.println("audi run");
}
}// 具体产品2
public class Benz implements Car{
@Override
public void run() {
System.out.println("benz run");
}
}// 具体工厂,用于生成产品
public class SimpleFactory {
// 方式1,根据传入的参数生成对应的产品对象
public static Car getCar(String type){
if ("audi".equals(type)){
return new Audi();
} else if ("benz".equals(type)){
return new Benz();
} else {
return null;
}
}// 方式2,直接调用生成对应的产品对象的方法
public static Car getAudi(){
return new Audi();
}public static Car getBenz(){
return new Benz();
}
}// 调用者
public class SimpleFactoryTest {
public static void main(String[] args) {
// 没有使用简单工厂,那么客户端就需要和接口Car以及其实现类打交道
//Car audi = new Audi();
//Car benz = new Benz();
//audi.run();
//benz.run();
// 使用简单工厂,方式1
Car audi = SimpleFactory.getCar("audi");
Car benz = SimpleFactory.getCar("benz");
audi.run();
benz.run();
System.out.println("============");
// 使用简单工厂,方式2
Car audi1 = SimpleFactory.getAudi();
Car benz1 = SimpleFactory.getBenz();
audi1.run();
benz1.run();
}
}
类图如下:
文章图片
可以看到,如果再增加一种产品,则需要修改工厂类,故这种工厂模式适用于产品对象较少,且产品固定的需求 。其实我们在一般的项目中使用简单工厂就足够了。
工厂方法
为了避免简单工厂不满足开闭原则的缺点,增加产品而不需要去修改工厂类,可以使用工厂方法模式,增加产品的同时通过增加一个对应的工厂类来生产对应的产品,涉及的角色有:
- 抽象产品
- 具体产品
- 抽象工厂
- 具体工厂
- 调用者
// 抽象产品
public interface Car {
void run();
}// 具体产品1
public class Audi implements Car {
@Override
public void run() {
System.out.println("audi run");
}
}// 具体产品2
public class Benz implements Car {
@Override
public void run() {
System.out.println("benz run");
}
}// 抽象工厂
public interface CarFactory {
Car createCar();
}// 具体工厂1
public class AudiFactory implements CarFactory {
@Override
public Car createCar() {
return new Audi();
}
}// 具体工厂2
public class BenzFactory implements CarFactory {
@Override
public Car createCar() {
return new Benz();
}
}// 调用者
public class FactoryMethodTest {
public static void main(String[] args) {
Car audi = new AudiFactory().createCar();
Car benz = new BenzFactory().createCar();
audi.run();
benz.run();
}
}
类图如下:
文章图片
可以看到,如果新增加一种具体产品,就需要为其增加一个具体工厂类用于生产该产品。
抽象工厂
抽象工厂用于生产一族产品。涉及的角色有:
- 抽象产品
- 具体产品
- 抽象工厂
- 具体工厂
- 调用者
// 抽象产品A
public interface Engine {
void autoStart();
}// 具体产品A1
public class HighEngine implements Engine {
@Override
public void autoStart() {
System.out.println("高端发动机有自动启停功能");
}
}// 具体产品A2
public class LowEngine implements Engine {
@Override
public void autoStart() {
System.out.println("低端发动机没有自动启停功能");
}
}// 抽象产品B
public interface Tyre {
void monitor();
}// 具体产品B1
public class HighTyre implements Tyre {
@Override
public void monitor() {
System.out.println("高端轮胎有胎压监控功能");
}
}// 具体产品B2
public class LowTyre implements Tyre {
@Override
public void monitor() {
System.out.println("低端轮胎无监控胎压功能");
}
}// 抽象工厂
public interface CarFactory {
Engine createEngine();
Tyre createTyre();
}// 具体工厂A1B1
public class HighCarFactory implements CarFactory {
@Override
public HighEngine createEngine() {
return new HighEngine();
}@Override
public HighTyre createTyre() {
return new HighTyre();
}
}// 具体工厂A2B2
public class LowCarFactory implements CarFactory {
@Override
public LowEngine createEngine() {
return new LowEngine();
}@Override
public LowTyre createTyre() {
return new LowTyre();
}
}// 调用者
public class AbstractFactoryTest {
public static void main(String[] args) {
CarFactory highCar = new HighCarFactory();
highCar.createEngine().autoStart();
highCar.createTyre().monitor();
}
}
类图如下:
文章图片
可以看到通过具体工厂A1B1和A2B2可以生产出不同的产品族,在产品固定的情况下,可以通过新增具体工厂类,来组合生成不同的产品族,比如A1B2或者A2B1。但是如果要增加新的产品的话,比如增加产品C,那就需要去修改抽象工厂和具体工厂,就不适合了。
【设计模式二(工厂模式)】欢迎关注我的公众号,一起学习技术。
文章图片
推荐阅读
- Java|求所有质因子(Java)
- 并发CAS机制你真的理解了嘛((深入到操作系统分析))
- Java基础|Java8 -- Lambda表达式
- Java并发编程 - 线程
- 程序员|薪水被应届生倒挂了,很不爽,我应该跳槽吗()
- 微信8.0安卓版来了
- Java面试题整理|历时两个月拿到阿里P7整个面试过程和offer(仅供参考)
- 大数据|《2021 年 Go 官方开发者调查报告》
- 活动专栏|新学期,新FLAG | 尽人事,听天命,守得云开见月明