Java设计模式之【工厂模式】(简单工厂模式,工厂方法模式,抽象工厂模式)

2018-08-21 来源: 渡劫锦官城 发布在  https://www.cnblogs.com/javafucker/p/9511603.html

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

相关文章