Java设计模式之【工厂模式】（简单工厂模式，工厂方法模式，抽象工厂模式）
工厂模式出现的原因
在java中，创建一个对象最简单的方法就是使用new关键字。但在一些复杂的业务逻辑中，创建一个对象不只需要new一行代码就成了，可能需要一些列的初始化设置，或先创建一些辅助对象来创建这个对象。
在这种场景中，如果需要多次创建这种对象，那每次都要写很多代码。工厂模式的产生就是为了解决这种问题。
工厂模式厉害之处就在于：你不需要知道创建对象的细节就可以轻松的创建你想要的对象，并且产品和工厂是解耦的。
3种工厂模式介绍
1、简单工厂模式
1个具体工厂类，1个抽象产品类，多个具体产品类
每个工厂可以创建多个产品实例，当需要创建新产品的时候，需要修改工厂类，不符合java开闭原则
用户需要什么类型的产品，告诉工厂类，工厂类就创建什么类型的产品实例
2、工厂方法模式
1个抽象工厂类，多个具体工厂类，1个抽象产品类，多个具体产品类
每个工厂只能创建1个产品实例，当需要创建新产品的时候，需要扩展抽象工厂类，而不需要修改，符合java开闭原则
用户需要什么类型的产品，就从什么类型的工厂生产
3、抽象工厂模式
1个抽象工厂类，多个具体工厂类，多个抽象产品类，多个抽象产品类
每个工厂可以创建多个产品实例，当需要创建新产品的时候，需要扩展抽象工厂类，而不需要修改，符合java开闭原则
用户需要什么类型的产品，就从什么类型的工厂生产
用于生产一组相关或者相互依赖的产品
下面以工厂生产宝马车为例子开始具体介绍这3种工厂模式
一、简单工厂模式
需求：用户需要宝马车，并希望工厂根据自己提出的类型可以生产不同类型的宝马车
public abstract class BMW {}
public class BMW320 extends BMW {}
public class BMW520 extends BMW {}
public class BMWFactory {
BMW createBMW(Integer type){
if(type == 320){
return new BMW320();
}else if(type == 520){
return new BMW520();
}else{
return null;
}
}
}
public class Customer {
public static void main(String[] args) {
BMWFactory bmwFactory = new BMWFactory();
BMW myBMW320 = bmwFactory.createBMW(320); //告诉工厂自己需要什么类型的产品
BMW myBMW520 = bmwFactory.createBMW(520);
}
}
特点：产品和工厂完全耦合，当需要生产新产品的时候，必须修改工厂类的create()方法，违背了java对扩展开放，对修改关闭的原则
二、工厂方法模式
需求：我不希望只有一个工厂来生产所有的宝马车，我希望每种宝马车都由其对应的工厂来生产
public abstract class BMW {}
public class BMW320 extends BMW {}
public class BMW520 extends BMW {}
public abstract class BMWFactory {
abstract BMW createBMW();
}
public class BMW320Factory extends BMWFactory {
@Override
BMW createBMW() {
return new BMW320();
}
}
public class BMW520Factory extends BMWFactory {
@Override
BMW createBMW() {
return new BMW520();
}
}
public class Customer {
public static void main(String[] args) {
BMWFactory bmw320Factory = new BMW320Factory();
BMWFactory bmw520Factory = new BMW520Factory();
BMW bmw320 = bmw320Factory.createBMW(); //需要什么类型的产品，就从什么类型的工厂来生成
BMW bmw520 = bmw520Factory.createBMW();
}
}
类结构图
特点：产品和工厂完全解耦，当需要生产新产品的时候，只需要扩展新工厂。弊端也很明显，由于每种工厂只生产1中产品，随着新产品越来越多，新工厂也会越来越多
三、抽象工厂模式
需求：用户希望在不同类型的宝马车上可以有不同类型的引擎或空调，如宝马320中安装引擎A和空调A，宝马520中安装引擎B和空调B
引擎类
public abstract class Engine {
abstract public String show();
}
public class EngineA extends Engine {
@Override
public String show() {
return "EngineA";
}
}
public class EngineB extends Engine {
@Override
public String show() {
return "EngineB";
}
}
空调类
public abstract class AirCondition {
abstract public String show();
}
public class AirConditionA extends AirCondition {
@Override
public String show() {
return "AirConditionA";
}
}
public class AirConditionB extends AirCondition {
@Override
public String show() {
return "AirConditionB";
}
}
宝马车类
public abstract class BMW {
private Engine engine;
private AirCondition aircondition;
public Engine getEngine() {
return engine;
}
public void setEngine(Engine engine) {
this.engine = engine;
}
public AirCondition getAircondition() {
return aircondition;
}
public void setAircondition(AirCondition aircondition) {
this.aircondition = aircondition;
}
public abstract String show();
}
public class BMW320 extends BMW {
@Override
public String show() {
return "我是BMW320，我的引擎：" + getEngine().show() + "，我的空调：" + getAircondition().show();
}
}
public class BMW520 extends BMW {
@Override
public String show() {
return "我是BMW520，我的引擎：" + getEngine().show() + "，我的空调：" + getAircondition().show();
}
}
工厂类
public abstract class BMWFactory {
abstract BMW createBMW();
abstract Engine createEngine();
abstract AirCondition createAirCondition();
}
public class BMW320Factory extends BMWFactory {
@Override
BMW createBMW() {
BMW bmw320 = new BMW320();
Engine engineA = createEngine();
AirCondition airConditionA = createAirCondition();
bmw320.setEngine(engineA);
bmw320.setAircondition(airConditionA);
return bmw320;
}
@Override
Engine createEngine() {
return new EngineA();
}
@Override
AirCondition createAirCondition() {
return new AirConditionA();
}
}
public class BMW520Factory extends BMWFactory {
@Override
BMW createBMW() {
BMW bmw520 = new BMW520();
Engine engineB = createEngine();
AirCondition airConditionB = createAirCondition();
bmw520.setEngine(engineB);
bmw520.setAircondition(airConditionB);
return bmw520;
}
@Override
Engine createEngine() {
return new EngineB();
}
@Override
AirCondition createAirCondition() {
return new AirConditionB();
}
}
用户类
public class Customer {
public static void main(String[] args) {
BMWFactory bmw320Factory = new BMW320Factory();
BMW bmw320 = bmw320Factory.createBMW();
System.out.println(bmw320.show());
BMWFactory bmw520Factory = new BMW520Factory();
BMW bmw520 = bmw520Factory.createBMW();
System.out.println(bmw520.show());
}
}
类结构图
运行结果
我是BMW320，我的引擎：EngineA，我的空调：AirConditionA
我是BMW520，我的引擎：EngineB，我的空调：AirConditionB
工厂方法模式和抽象工厂模式比较
工厂方法模式中，只有一个抽象产品类，每个工厂只能生产对应类型的产品实例
抽象工厂模式中，有多个抽象产品类，每个工厂可以生产多种类型的产品实例
总结
无论是哪种工厂模式，它们在形式和特点上都是相似的，他们的特点都是为了使产品和工厂解耦。在使用时不必在意具体是工厂方法模式还是抽象工厂模式，因为有时你会发现，明明使用的是工厂方法模式，当新需求来临，对代码稍加扩展或修改，加入一个新产品或方法后，由于产品构成了不同等级的产品族，就变成抽象工厂模式了。而在抽象工厂模式中，当减少一个产品或方法使得工厂提供的产品不再构成产品族后，它就演变成了工厂方法模式。
所以在使用工厂模式时，只需要关心是否降低了耦合度就ok了。
我的博客即将搬运同步至腾讯云+社区，邀请大家一同入驻：https://cloud.tencent.com/developer/support-plan?invite_code=2biv3j8ly5xc8