侧边栏壁纸
  • 累计撰写 98 篇文章
  • 累计创建 20 个标签
  • 累计收到 3 条评论

设计模式--工厂模式

林贤钦
2020-04-29 / 0 评论 / 12 点赞 / 623 阅读 / 0 字
温馨提示:
本文最后更新于 2020-05-09,若内容或图片失效,请留言反馈。部分素材来自网络,若不小心影响到您的利益,请联系我们删除。

工厂模式(Factory Pattern)

  • 工厂模式是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。
  • 在工厂模式中,我们在创建对象时不会对客户端暴露创建逻辑,并且是通过使用一个共同的接口来指向新创建的对象。
  • 工厂模式其主要功能都是帮助我们把对象的实例化部分抽取了出来,目的是降低系统中代码耦合度,并且增强了系统的扩展性。
  • 工厂模式分为简单工厂模式,工厂方法模式和抽象工厂模式。

1. 简单工厂模式(SimpleFactoryPattern)

简单工厂模式最大的优点在于实现对象的创建和对象的使用分离,

将对象的创建交给专门的工厂类负责

上图中的AbstractProduct就是专门生产product的工厂类

通过AbstractProduct我们只需要调用方法传递参数就可以获得我们需要的对象product。

组成(角色)关系作用
抽象产品(AbstractProduct)具体产品的父类描述产品的公共接口
具体产品(Product1、Product2)抽象产品的子类;工厂类创建的目标类描述生产的具体产品
工厂(Factory)被外界调用根据传入不同参数从而创建不同具体产品类的实例

实例概况

  • 背景:

小成有一个塑料生产厂,用来做塑料加工生意

  • 目的:

最近推出了3个产品,小成希望使用简单工厂模式实现3款产品的生产

使用步骤

步骤1. 创建抽象产品类,定义具体产品的公共接口

abstract class Product{
    public abstract void Show();
}

步骤2. 创建具体产品类(继承抽象产品类),定义生产的具体产品

//具体产品类A
class  ProductA extends  Product{

    @Override
    public void Show() {
        System.out.println("生产出了产品A");
    }
}

//具体产品类B
class  ProductB extends  Product{

    @Override
    public void Show() {
        System.out.println("生产出了产品C");
    }
}

//具体产品类C
class  ProductC extends  Product{

    @Override
    public void Show() {
        System.out.println("生产出了产品C");
    }
}

步骤3. 创建工厂类,通过创建静态方法从而根据传入不同参数创建不同具体产品类的实例

class  Factory {
    public static Product Manufacture(String ProductName){
        //工厂类里用switch语句控制生产哪种商品;
        //使用者只需要调用工厂类的静态方法就可以实现产品类的实例化。
        switch (ProductName){
            case "A":
                return new ProductA();
            case "B":
                return new ProductB();
            case "C":
                return new ProductC();
            default:
                return null;
        }
    }
}

步骤4. 外界通过调用工厂类的静态方法,传入不同参数从而创建不同具体产品类的实例

//工厂产品生产流程
public class SimpleFactoryPattern {
    public static void main(String[] args){
        Factory mFactory = new Factory();

        //客户要产品A
        try {
		//调用工厂类的静态方法 & 传入不同参数从而创建产品实例
            mFactory.Manufacture("A").Show();
        }catch (NullPointerException e){
            System.out.println("没有这一类产品");
        }

        //客户要产品B
        try {
            mFactory.Manufacture("B").Show();
        }catch (NullPointerException e){
            System.out.println("没有这一类产品");
        }

        //客户要产品C
        try {
            mFactory.Manufacture("C").Show();
        }catch (NullPointerException e){
            System.out.println("没有这一类产品");
        }
    }
}

优点

  • 将创建实例的工作与使用实例的工作分开,使用者不必关心类对象如何创建,实现了解耦;
  • 把初始化实例时的工作放到工厂里进行,使代码更容易维护。 更符合面向对象的原则 & 面向接口编程,而不是面向实现编程。

缺点

  • 工厂类集中了所有实例(产品)的创建逻辑,一旦这个工厂不能正常工作,整个系统都会受到影响;
  • 违背“开放 - 关闭原则”,一旦添加新产品就不得不修改工厂类的逻辑,这样就会造成工厂逻辑过于复杂。
  • 简单工厂模式由于使用了静态工厂方法,静态方法不能被继承和重写,会造成工厂角色无法形成基于继承的等级结构。

2. 工厂方法模式(Factory Method)

通过定义一个抽象的核心工厂类,并定义创建产品对象的接口,创建具体产品实例的工作延迟到其工厂子类去完成。

和简单工厂模式中工厂负责生产所有产品相比,工厂方法模式将生成具体产品的任务分发给具体的产品工厂。

Factory Method

样做的好处是核心类只关注工厂类的接口定义,而具体的产品实例交给具体的工厂子类去创建。

当系统需要新增一个产品是,无需修改现有系统代码,只需要添加一个具体产品类和其对应的工厂子类,使系统的扩展性变得很好,符合面向对象编程的开闭原则ocp

组成(角色)关系作用
抽象产品(AbstractProduct)具体产品的父类描述产品的公共接口
具体产品(Product1、Product2)抽象产品的子类;工厂类创建的目标类描述生产的具体产品
具体工厂子类(Concrete Factory1、Concrete Factory2)抽象工厂的子类;被外界调用描述具体工厂、实现FactoryMethod工厂方法创建产品的实例
抽象工厂(AbstractFactory)具体工厂的父类描述具体工厂的公共接口

实例概况

  • 背景:

小成有一间塑料加工厂(仅生产A类产品);随着客户需求的变化,客户需要生产B类产品;

  • 冲突:

改变原有塑料加工厂的配置和变化非常困难,假设下一次客户需要再发生变化,再次改变将增大非常大的成本;

  • 解决方案:

小成决定置办塑料分厂B来生产B类产品;

使用步骤

步骤1: 创建抽象工厂类,定义具体工厂的公共接口

abstract class Factory{
    public abstract Product Manufacture();
}

步骤2: 创建抽象产品类 ,定义具体产品的公共接口;

abstract class Product{
    public abstract void Show();
}

步骤3: 创建具体产品类(继承抽象产品类), 定义生产的具体产品;

//具体产品A类
class  ProductA extends  Product{
    @Override
    public void Show() {
        System.out.println("生产出了产品A");
    }
}

//具体产品B类
class  ProductB extends  Product{

    @Override
    public void Show() {
        System.out.println("生产出了产品B");
    }
}

步骤4:创建具体工厂类(继承抽象工厂类),定义创建对应具体产品实例的方法;

//工厂A类 - 生产A类产品
class  FactoryA extends Factory{
    @Override
    public Product Manufacture() {
        return new ProductA();
    }
}

//工厂B类 - 生产B类产品
class  FactoryB extends Factory{
    @Override
    public Product Manufacture() {
        return new ProductB();
    }
}

步骤5:外界通过调用具体工厂类的方法,从而创建不同具体产品类的实例

//生产工作流程
public class FactoryPattern {
    public static void main(String[] args){
        //客户要产品A
        FactoryA mFactoryA = new FactoryA();
        mFactoryA.Manufacture().Show();

        //客户要产品B
        FactoryB mFactoryB = new FactoryB();
        mFactoryB.Manufacture().Show();
    }
}

工厂方法模式是简单工厂模式的进一步抽象和推广。由于使用了面向对象的多态性,工厂方法模式保持了简单工厂模式的优点,而且克服了它的缺点。

在工厂方法模式中,核心的工厂类不再负责所有产品的创建,而是将具体创建工作交给子类去做。这个核心类仅仅负责给出具体工厂必须实现的接口,而不负责产品类被实例化这种细节,这使得工厂方法模式可以允许系统在不修改工厂角色的情况下引进新产品。

优点

  • 更符合开-闭原则
    新增一种产品时,只需要增加相应的具体产品类和相应的工厂子类即可

简单工厂模式需要修改工厂类的判断逻辑

  • 符合单一职责原则
    每个具体工厂类只负责创建对应的产品

简单工厂中的工厂类存在复杂的switch逻辑判断

  • 不使用静态工厂方法,可以形成基于继承的等级结构。

简单工厂模式的工厂类使用静态工厂方法

总结

工厂模式可以说是简单工厂模式的进一步抽象和拓展,在保留了简单工厂的封装优点的同时,让扩展变得简单,让继承变得可行,增加了多态性的体现。


缺点

  • 添加新产品时,除了增加新产品类外,还要提供与之对应的具体工厂类

系统类的个数将成对增加,在一定程度上增加了系统的复杂度;同时,有更多的类需要编译和运行,会给系统带来一些额外的开销;

  • 由于考虑到系统的可扩展性,需要引入抽象层

在客户端代码中均使用抽象层进行定义,增加了系统的抽象性和理解难度,且在实现时可能需要用到DOM、反射等技术,增加了系统的实现难度。

  • 虽然保证了工厂方法内的对修改关闭

但对于使用工厂方法的类,如果要更换另外一种产品,仍然需要修改实例化的具体工厂类;

  • 一个具体工厂只能创建一种具体产品

3. 抽象工厂模式(Abstract Factory)

抽象工厂模式(Abstract Factory Pattern)

围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。

意图

提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类。

上面两种模式不管工厂怎么拆分抽象,都只是针对一类产品Phone(AbstractProduct),如果要生成另一种产品PC,应该怎么表示呢?


组成(角色)关系作用
抽象产品族(AbstractProduct)抽象产品的父类描述抽象产品的公共接口
抽象产品(Product)具体产品的父类描述具体产品的公共接口
具体产品(Concrete Product)抽象产品的子类;工厂类创建的目标类描述生产的具体产品
抽象工厂(Creator)具体工厂的父类描述具体工厂的公共接口
具体工厂(Concrete Creator)抽象工厂的子类;被外界调用描述具体工厂;实现FactoryMethod工厂方法创建产品的实例

实例概况

  • 背景:

小成有两间塑料加工厂(A厂仅生产容器类产品;B厂仅生产模具类产品);随着客户需求的变化,A厂所在地的客户需要也模具类产品,B厂所在地的客户也需要容器类产品;

  • 冲突:

没有资源(资金+租位)在当地分别开设多一家注塑分厂

  • 解决方案:

在原有的两家塑料厂里增设生产需求的功能,即A厂能生产容器+模具产品;B厂间能生产模具+容器产品。

使用步骤

步骤1: 创建抽象工厂类,定义具体工厂的公共接口

abstract class Factory{
   public abstract AbstractProduct ManufactureContainer();
   public abstract AbstractProduct ManufactureMould();
}

步骤2: 创建抽象产品族类 ,定义具体产品的公共接口;

abstract class AbstractProduct{
    public abstract void Show();
}

步骤3: 创建抽象产品类 ,定义具体产品的公共接口;

//容器产品抽象类
abstract class ContainerProduct extends AbstractProduct{
    @Override
    public abstract void Show();
}

//模具产品抽象类
abstract class MouldProduct extends AbstractProduct{
    @Override
    public abstract void Show();
}

步骤4: 创建具体产品类(继承抽象产品类), 定义生产的具体产品;

//容器产品A类
class ContainerProductA extends ContainerProduct{
    @Override
    public void Show() {
        System.out.println("生产出了容器产品A");
    }
}

//容器产品B类
class ContainerProductB extends ContainerProduct{
    @Override
    public void Show() {
        System.out.println("生产出了容器产品B");
    }
}

//模具产品A类
class MouldProductA extends MouldProduct{

    @Override
    public void Show() {
        System.out.println("生产出了模具产品A");
    }
}

//模具产品B类
class MouldProductB extends MouldProduct{

    @Override
    public void Show() {
        System.out.println("生产出了模具产品B");
    }
}

步骤5:创建具体工厂类(继承抽象工厂类),定义创建对应具体产品实例的方法;

//A厂 - 生产模具+容器产品
class FactoryA extends Factory{

    @Override
    public Product ManufactureContainer() {
        return new ContainerProductA();
    }

    @Override
    public Product ManufactureMould() {
        return new MouldProductA();
    }
}

//B厂 - 生产模具+容器产品
class FactoryB extends Factory{

    @Override
    public Product ManufactureContainer() {
        return new ContainerProductB();
    }

    @Override
    public Product ManufactureMould() {
        return new MouldProductB();
    }
}

步骤6:客户端通过实例化具体的工厂类,并调用其创建不同目标产品的方法创建不同具体产品类的实例

//生产工作流程
public class AbstractFactoryPattern {
    public static void main(String[] args){
        FactoryA mFactoryA = new FactoryA();
        FactoryB mFactoryB = new FactoryB();
        //A厂当地客户需要容器产品A
        mFactoryA.ManufactureContainer().Show();
        //A厂当地客户需要模具产品A
        mFactoryA.ManufactureMould().Show();

        //B厂当地客户需要容器产品B
        mFactoryB.ManufactureContainer().Show();
        //B厂当地客户需要模具产品B
        mFactoryB.ManufactureMould().Show();

    }
}

优点

  • 降低耦合
    抽象工厂模式将具体产品的创建延迟到具体工厂的子类中

这样将对象的创建封装起来,可以减少客户端与具体产品类之间的依赖,从而使系统耦合度低,这样更有利于后期的维护和扩展;

  • 更符合开-闭原则
    新增一种产品类时,只需要增加相应的具体产品类和相应的工厂子类即可

简单工厂模式需要修改工厂类的判断逻辑

  • 符合单一职责原则
    每个具体工厂类只负责创建对应的产品

简单工厂中的工厂类存在复杂的switch逻辑判断

  • 不使用静态工厂方法,可以形成基于继承的等级结构。

简单工厂模式的工厂类使用静态工厂方法


缺点

抽象工厂模式很难支持新种类产品的变化。
这是因为抽象工厂接口中已经确定了可以被创建的产品集合,如果需要添加新产品,此时就必须去修改抽象工厂的接口,这样就涉及到抽象工厂类的以及所有子类的改变,这样也就违背了开闭原则。

对于新的产品族符合开闭原则;对于新的产品种类不符合开-闭原则,这一特性称为开-闭原则的倾斜性。


抽象工厂模式和工厂模式的区别

  • 工厂方法模式利用继承,抽象工厂模式利用组合

  • 工厂方法模式产生一个对象,抽象工厂模式产生一族对象

  • 工厂方法模式利用子类创造对象,抽象工厂模式利用接口的实现创造对象

  • 抽象工程关键在于产品之间的抽象关系,所以至少要两个产品;工厂方法在于生成产品,不关注产品间的关系,所以可以只生成一个产品。

  • 抽象工厂中客户端把产品的抽象关系理清楚,在最终使用的时候,一般使用客户端(和其接口),产品之间的关系是被封装固定的;而工厂方法是在最终使用的时候,使用产品本身(和其接口)。


学习总结来源:

抽象工厂模式和工厂模式的区别
设计模式之工厂模式(factory pattern)
简单工厂模式(SimpleFactoryPattern
工厂方法模式(Factory Method
抽象工厂模式(Abstract Factory

12

评论区