Scott's world.

设计模式-工厂模式

Word count: 7.7kReading time: 27 min
2019/08/23 Share

设计模式-工厂模式

模式分类

1.简单工厂模式(又称静态工厂模式)
2.工厂方法模式
3.抽象工厂模式

1.简单工厂模式(静态工厂模式)

模式定义
简单工厂模式(Simple Factory Pattern):又称为静态工厂方法(Static Factory Method)模式,它属于类创建型模式。在简单工厂模式中,可以根据参数的不同返回不同类的实例。简单工厂模式专门定义一个类来负责创建其他类的实例,被创建的实例通常都具有共同的父类。
例如:
考虑一个简单的软件应用场景,一个软件系统可以提供多个外观不同的按钮(如圆形按钮、矩形按钮、菱形按钮等), 这些按钮都源自同一个基类,不过在继承基类后不同的子类修改了部分属性从而使得它们可以呈现不同的外观,如果我们希望在使用这些按钮时,不需要知道这些具体按钮类的名字,只需要知道表示该按钮类的一个参数,并提供一个调用方便的方法,把该参数传入方法即可返回一个相应的按钮对象,此时,就可以使用简单工厂模式。
模式结构
在这里插入图片描述

  • Factory:工厂角色
    工厂角色负责实现创建所有实例的内部逻辑
  • Product:抽象产品角色
    抽象产品角色是所创建的所有对象的父类,负责描述所有实例所共有的公共接口
  • ConcreteProduct:具体产品角色
    具体产品角色是创建目标,所有创建的对象都充当这个角色的某个具体类的实例。

模式例子
每次我们吃火锅都会选择什么锅底对吧,那我们开始吧
首先,我们先将锅底父类写出来

  • GuoDi.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
    27
    28
    29
    30
    31
    32
    33
    34
    package factory.first;

    /**
    * TODO
    *
    * @author tudou
    * @version 1.0
    * @date 2019/5/28 0:12
    **/
    public class Guodi {

    private String name;

    /**
    * 准备工作
    */
    public void prepare(){
    System.out.println("放入火锅底料");
    }

    /**
    * 加入热水与作料
    */
    public void put(){
    System.out.println("放入热水与作料");
    }

    /**
    * 加热开涮
    */
    public void start(){
    System.out.println("加热开涮");
    }
    }

然后加入锅底的各种种类

  • HongTang.java / YuanYang.java / QingTang.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
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    package factory.first;

    /**
    * TODO
    *
    * @author tudou
    * @version 1.0
    * @date 2019/5/28 0:18
    **/
    public class QingTang extends Guodi {

    public QingTang(){
    this.name="清汤";
    }
    }

    package factory.first;

    /**
    * TODO
    *
    * @author tudou
    * @version 1.0
    * @date 2019/5/28 0:16
    **/
    public class HongTang extends Guodi {
    public HongTang(){
    this.name="红汤";
    }
    }

    package factory.first;

    /**
    * TODO
    *
    * @author tudou
    * @version 1.0
    * @date 2019/5/28 0:17
    **/
    public class YuanYang extends Guodi {
    public YuanYang(){
    this.name="鸳鸯";
    }
    }

然后我们再创建一个工厂来生产底料

  • 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
    package factory.first;

    /**
    * TODO
    *
    * @author tudou
    * @version 1.0
    * @date 2019/5/28 0:20
    **/
    public class Factory {

    public Guodi createGuoDi(String choice){
    Guodi guodi=null;
    if(choice.equals("清汤")){
    guodi=new QingTang();
    }
    else if(choice.equals("红汤")){
    guodi=new HongTang();
    }
    else if(choice.equals("鸳鸯")){
    guodi = new YuanYang();
    }
    return guodi;
    }
    }

有了生产底料的工厂之后,把生产的底料分给一个店来销售

  • HuoGuoStore.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
    27
    package factory.first;

    /**
    * TODO
    *
    * @author tudou
    * @version 1.0
    * @date 2019/5/28 0:23
    **/
    public class HuoGuoStore {
    private Factory factory;

    public HuoGuoStore(Factory factory){
    this.factory=factory;
    }

    /**
    * 根据选择来进行销售
    */
    public GuoDi chooseGuodi(String choice){
    GuoDi guoDi=factory.createGuoDi(choice);
    guoDi.prepare();
    guoDi.put();
    guoDi.start();
    return guoDi;
    }
    }

最后一个简单工厂模式就完成啦,如果以后出现了新的锅底种类,则只需要在GuoDi的父类中添加相应子类,最后加入工厂进行生产.

模式分析

  • 将对象的创建和对象本身业务处理分离可以降低系统的耦合度,使得两者修改起来都相对容易。
  • 在调用工厂类的工厂方法时,由于工厂方法是静态方法,使用起来很方便,可通过类名直接调用,而且只需要传入一个简单的参数即可,在实际开发中,还可以在调用时将所传入的参数保存在XML等格式的配置文件中,修改参数时无须修改任何源代码。
  • 简单工厂模式最大的问题在于工厂类的职责相对过重,增加新的产品需要修改工厂类的判断逻辑,这一点与开闭原则是相违背的。
  • 简单工厂模式的要点在于:当你需要什么,只需要传入一个正确的参数,就可以获取你所需要的对象,而无须知道其创建细节。

模式优缺点
优点:

  • 工厂类含有必要的判断逻辑,可以决定在什么时候创建哪一个产品类的实例,客户端可以免除直接创建产品对象的责任,而仅仅“消费”产品;简单工厂模式通过这种做法实现了对责任的分割,它提供了专门的工厂类用于创建对象。
  • 客户端无须知道所创建的具体产品类的类名,只需要知道具体产品类所对应的参数即可,对于一些复杂的类名,通过简单工厂模式可以减少使用者的记忆量。
  • 通过引入配置文件,可以在不修改任何客户端代码的情况下更换和增加新的具体产品类,在一定程度上提高了系统的灵活性。

缺点:

  • 由于工厂类集中了所有产品创建逻辑,一旦不能正常工作,整个系统都要受到影响。
  • 使用简单工厂模式将会增加系统中类的个数,在一定程序上增加了系统的复杂度和理解难度。
  • 系统扩展困难,一旦添加新产品就不得不修改工厂逻辑,在产品类型较多时,有可能造成工厂逻辑过于复杂,不利于系统的扩展和维护。
  • 简单工厂模式由于使用了静态工厂方法,造成工厂角色无法形成基于继承的等级结构。

模式应用
1.JDK类库中广泛使用了简单工厂模式,如工具类java.text.DateFormat,它
用于格式化一个本地日期或者时间。

1
2
3
4
public final static DateFormat getDateInstance();
public final static DateFormat getDateInstance(int style);
public final static DateFormat getDateInstance(int style,Locale
locale);

2.Java加密技术
获取不同加密算法的密钥生成器:

KeyGenerator keyGen=KeyGenerator.getInstance(“DESede”);

创建密码器:

Cipher cp=Cipher.getInstance(“DESede”);

总结

  • 创建型模式对类的实例化过程进行了抽象,能够将对象的创建与对象的使用过程分离。
  • 简单工厂模式又称为静态工厂方法模式,它属于类创建型模式。在简单工厂模式中,可以根据参数的不同返回不同类的实例。简单工厂模式专门定义一个类来负责创建其他类的实例,被创建的实例通常都具有共同的父类。
  • 简单工厂模式包含三个角色:工厂角色负责实现创建所有实例的内部逻辑;抽象产品角色是所创建的所有对象的父类,负责描述所有实例所共有的公共接口;具体产品角色是创建目标,所有创建的对象都充当这个角色的某个具体类的实例。
  • 简单工厂模式的要点在于:当你需要什么,只需要传入一个正确的参数,就可以获取你所需要的对象,而无须知道其创建细节。
  • 简单工厂模式最大的优点在于实现对象的创建和对象的使用分离,将对象的创建交给专门的工厂类负责,但是其最大的缺点在于工厂类不够灵活,增加新的具体产品需要修改工厂类的判断逻辑代码,而且产品较多时,工厂方法代码将会非常复杂。
  • 简单工厂模式适用情况包括:工厂类负责创建的对象比较少;客户端只知道传入工厂类的参数,对于如何创建对象不关心。

2.工厂方法模式

模式定义
工厂方法模式(Factory Method Pattern)又称为工厂模式,也叫虚拟构造器(Virtual Constructor)模式或者多态工厂(Polymorphic Factory)模式,它属于类创建型模式。在工厂方法模式中,工厂父类负责定义创建产品对象的公共接口,而工厂子类则负责生成具体的产品对象,这样做的目的是将产品类的实例化操作延迟到工厂子类中完成,即通过工厂子类来确定究竟应该实例化哪一个具体产品类。
例如:
现在对该系统进行修改,不再设计一个按钮工厂类来统一负责所有产品的创建,而是将具体按钮的创建过程交给专门的工厂子类去完成,我们先定义一个抽象的按钮工厂类,再定义具体的工厂类来生成圆形按钮、矩形按钮、菱形按钮等,它们实现在抽象按钮工厂类中定义的方法。这种抽象化的结果使这种结构可以在不修改具体工厂类的情况下引进新的产品,如果出现新的按钮类型,只需要为这种新类型的按钮创建一个具体的工厂类就可以获得该新按钮的实例,这一特点无疑使得工厂方法模式具有超越简单工厂模式的优越性,更加符合“开闭原则”。

模式结构
工厂方法模式包含如下角色:

  • Product:抽象产品
  • ConcreteProduct:具体产品
  • Factory:抽象工厂
  • ConcreteFactory:具体工厂
    在这里插入图片描述
    在这里插入图片描述
    模式例子
    根据上面的火锅店,由于每个城市或者每家店的火锅店可能对锅底的选择种类会不一样,比如重庆的火锅店的红汤还依据辣度来分等级划分
    我们可以分成几个分店来销售
    所以我们的火锅总店则变成了抽象类:
  • HuoGuoStore.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
    package factory.second;

    import factory.first.GuoDi;

    /**
    * TODO
    *
    * @author tudou
    * @version 1.0
    * @date 2019/5/28 0:41
    **/
    public abstract class HuoGuoStore {

    public abstract GuoDi createGuoDi(String type);

    /**
    * 根据具体选择来销售
    */
    public GuoDi sellGuoDi(String type){
    GuoDi guoDi=createGuoDi(type);
    guoDi.prepare();
    guoDi.put();
    guoDi.start();
    return guoDi;
    }
    }

然后来开划分在南方和北方的分店

  • SouthStore.java / NorthStore.java
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    package factory.second;

    import factory.first.GuoDi;
    /**
    * TODO
    *
    * @author tudou
    * @version 1.0
    * @date 2019/5/28 0:51
    **/
    public class NorthStore extends HuoGuoStore {
    @Override
    public GuoDi createGuoDi(String type) {
    GuoDi guoDi=null;
    if(type.equals("清汤")){
    guoDi=new NorthQingTang();
    }
    else if(type.equals("红汤")){
    guoDi=new NorthHongTang();
    }
    return guoDi;
    }
    }

由子类决定实例化的类,可以看到我们的火锅底料是子类生成的

模式分析
工厂方法模式是简单工厂模式的进一步抽象和推广。由于使用了面向对象的多态性,工厂方法模式保持了简单工厂模式的优点,而且克服了它的缺点。在工厂方法模式中,核心的工厂类不再负责所有产品的创建,而是将具体创建工作交给子类去做。这个核心类仅仅负责给出具体工厂必须实现的接口,而不负责哪一个产品类被实例化这种细节,这使得工厂方法模式可以允许系统在不修改工厂角色的情况下引进新产品。

实例

  • 日志记录器

某系统日志记录器要求支持多种日志记录方式,如文件记录、数据库记录等,且用户可以根据要求动态选择日志记录方式, 现使用工厂方法模式设计该系统。
结构图:
在这里插入图片描述
时序图:
在这里插入图片描述

模式优缺点
优点:

  • 在工厂方法模式中,工厂方法用来创建客户所需要的产品,同时还向客户隐藏了哪种具体产品类将被实例化这一细节,用户只需要关心所需产品对应的工厂,无须关心创建细节,甚至无须知道具体产品类的类名。
  • 基于工厂角色和产品角色的多态性设计是工厂方法模式的关键。它能够使工厂可以自主确定创建何种产品对象,而如何创建这个对象的细节则完全封装在具体工厂内部。工厂方法模式之所以又被称为多态工厂模式,是因为所有的具体工厂类都具有同一抽象父类。
  • 使用工厂方法模式的另一个优点是在系统中加入新产品时,无须修改抽象工厂和抽象产品提供的接口,无须修改客户端,也无须修改其他的具体工厂和具体产品,而只要添加一个具体工厂和具体产品就可以了。这样,系统的可扩展性也就变得非常好,完全符合“开闭原则”。

缺点:

  • 在添加新产品时,需要编写新的具体产品类,而且还要提供与之对应的具体工厂类,系统中类的个数将成对增加,在一定程度上增加了系统的复杂度,有更多的类需要编译和运行,会给系统带来一些额外的开销。
  • 由于考虑到系统的可扩展性,需要引入抽象层,在客户端代码中均使用抽象层进行定义,增加了系统的抽象性和理解难度,且在实现时可能需要用到DOM、反射等技术,增加了系统的实现难度。

模式适用环境
在以下情况下可以使用工厂方法模式:

  • 一个类不知道它所需要的对象的类:在工厂方法模式中,客户端不需要知道具体产品类的类名,只需要知道所对应的工厂即可,具体的产品对象由具体工厂类创建;客户端需要知道创建具体产品的工厂类。
  • 一个类通过其子类来指定创建哪个对象:在工厂方法模式中,对于抽象工厂类只需要提供一个创建产品的接口,而由其子类来确定具体要创建的对象,利用面向对象的多态性和里氏代换原则,在程序运行时,子类对象将覆盖父类对象,从而使得系统更容易扩展。
  • 将创建对象的任务委托给多个工厂子类中的某一个,客户端在使用时可以无须关心是哪一个工厂子类创建产品子类,需要时再动态指定,可将具体工厂类的类名存储在配置文件或数据库中。

模式应用
java中专门针对数据库的jdbc

1
2
3
4
Connection conn=DriverManager.getConnection("jdbc:microsoft:sqlserver://loc
alhost:1433; DatabaseName=DB;user=sa;password=");
Statement statement=conn.createStatement();
ResultSet rs=statement.executeQuery("select * from UserInfo");

模式扩展

  • 使用多个工厂方法:在抽象工厂角色中可以定义多个工厂方法,从而使具体工厂角色实现这些不同的工厂方法,这些方法可以包含不同的业务逻辑,以满足对不同的产品对象的需求。
  • 产品对象的重复使用:工厂对象将已经创建过的产品保存到一个集合(如数组、List等)中,然后根据客户对产品的请求,对集合进行查询。如果有满足要求的产品对象,就直接将该产品返回客户端;如果集合中没有这样的产品对象,那么就创建一个新的满足要求的产品对象,然后将这个对象在增加到集合中,再返回给客户端。
  • 多态性的丧失和模式的退化:如果工厂仅仅返回一个具体产品对象,便违背了工厂方法的用意,发生退化,此时就不再是工厂方法模式了。一般来说,工厂对象应当有一个抽象的父类型,如果工厂等级结构中只有一个具体工厂类的话,抽象工厂就可以省略,也将发生了退化。当只有一个具体工厂,在具体工厂中可以创建所有的产品对象,并且工厂方法设计为静态方法时,工厂方法模式就退化成简单工厂模式。

模式总结

  • 工厂方法模式又称为工厂模式,它属于类创建型模式。在工厂方法模式中,工厂父类负责定义创建产品对象的公共接口,而工厂子类则负责生成具体的产品对象,这样做的目的是将产品类的实例化操作延迟到工厂子类中完成,即通过工厂子类来确定究竟应该实例化哪一个具体产品类。
  • 工厂方法模式包含四个角色:抽象产品是定义产品的接口,是工厂方法模式所创建对象的超类型,即产品对象的共同父类或接口;具体产品实现了抽象产品接口,某种类型的具体产品由专门的具体工厂创建,它们之间往往一一对应;抽象工厂中声明了工厂方法,用于返回一个产品,它是工厂方法模式的核心,任何在模式中创建对象的工厂类都必须实现该接口;具体工厂是抽象工厂类的子类,实现了抽象工厂中定义的工厂方法,并可由客户调用,返回一个具体产品类的实例。
  • 工厂方法模式是简单工厂模式的进一步抽象和推广。由于使用了面向对象的多态性,工厂方法模式保持了简单工厂模式的优点,而且克服了它的缺点。在工厂方法模式中,核心的工厂类不再负责所有产品的创建,而是将具体创建工作交给子类去做。这个核心类仅仅负责给出具体工厂必须实现的接口,而不负责产品类被实例化这种细节,这使得工厂方法模式可以允许系统在不修改工厂角色的情况下引进新产品。
  • 工厂方法模式的主要优点是增加新的产品类时无须修改现有系统,并封装了产品对象的创建细节,系统具有良好的灵活性和可扩展性;其缺点在于增加新产品的同时需要增加新的工厂,导致系统类的个数成对增加,在一定程度上增加了系统的复杂性。
  • 工厂方法模式适用情况包括:一个类不知道它所需要的对象的类;一个类通过其子类来指定创建哪个对象;将创建对象的任务委托给多个工厂子类中的某一个,客户端在使用时可以无须关心是哪一个工厂子类创建产品子类,需要时再动态指定。

3.抽象工厂模式

模式定义
抽象工厂模式(Abstract Factory Pattern):提供一个创建一系列相关或相互依赖对象的接口,而无须指定它们具体的类。抽象工厂模式又称为Kit模式,属于对象创建型模式。
模式动机

  • 在工厂方法模式中具体工厂负责生产具体的产品,每一个具体工厂对应一种具体产品,工厂方法也具有唯一性,一般情况下,一个具体工厂中只有一个工厂方法或者一组重载的工厂方法。但是有时候我们需要一个工厂可以提供多个产品对象,而不是单一的产品对象。

    为了更清晰地理解工厂方法模式,需要先引入两个概念:

    • 产品等级结构 :产品等级结构即产品的继承结构,如一个抽象类是电视机,其子类有海尔电视机、海信电视机、TCL电视机,则抽象电视机与具体品牌的电视机之间构成了一个产品等级结构,抽象电视机是父类,而具体品牌的电视机是其子类。
    • 产品族 :在抽象工厂模式中,产品族是指由同一个工厂生产的,位于不同产品等级结构中的一组产品,如海尔电器工厂生产的海尔电视机、海尔电冰箱,海尔电视机位于电视机产品等级结构中,海尔电冰箱位于电冰箱产品等级结构中。
  • 当系统所提供的工厂所需生产的具体产品并不是一个简单的对象,而是多个位于不同产品等级结构中属于不同类型的具体产品时需要使用抽象工厂模式。

  • 抽象工厂模式是所有形式的工厂模式中最为抽象和最具一般性的一种形态。

  • 抽象工厂模式与工厂方法模式最大的区别在于,工厂方法模式针对的是一个产品等级结构,而抽象工厂模式则需要面对多个产品等级结构,一个工厂等级结构可以负责多个不同产品等级结构中的产品对象的创建 。当一个工厂等级结构可以创建出分属于不同产品等级结构的一个产品族中的所有对象时,抽象工厂模式比工厂方法模式更为简单、有效率。

模式结构
抽象工厂模式包含如下角色:

  • AbstractFactory:抽象工厂
  • ConcreteFactory:具体工厂
  • AbstractProduct:抽象产品
  • Product:具体产品

在这里插入图片描述
在这里插入图片描述

模式例子
继续我们开火锅店的例子,你看我们火锅在南北方都开了分店,但是南北方的底料生产方式和原料成分都有所差别也就使南北方的口味不一样,这样就导致了我们生产原料的工厂都要根据南北方的原料的不同分别开设相应的生产原料和生产锅底的工厂

首先我们创建一个提供原料和生产锅底的工厂

  • Factory.java
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    package factory.third;

    /**
    * TODO
    *
    * @author tudou
    * @version 1.0
    * @date 2019/5/28 14:11
    **/
    public interface Factory {

    public YuanLiao createYuanLiao();

    public GuoDi createGuoDi(String type);

    }

然后分别在南北方设立分工厂

  • NorthFactory.java \ SouthFactory.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
    27
    28
    29
    package factory.third;

    /**
    * TODO
    *
    * @author tudou
    * @version 1.0
    * @date 2019/5/28 14:16
    **/
    public class NorthFactory implements Factory {


    @Override
    public YuanLiao createYuanLiao() {
    return new NorthYuanLiao();
    }

    @Override
    public GuoDi createGuoDi(String type) {
    GuoDi guoDi=new GuoDi();
    if(type.equals("红汤")){
    guoDi=new HongTang();
    }else if(type.equals("清汤")){
    guoDi=new QingTang();
    }
    return guoDi;
    }

    }

其中我们的锅底的原料需要进行说明使用的是北方还是南方的原料

  • GuoDi.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
    27
    28
    29
    package factory.third;

    /**
    * TODO
    *
    * @author tudou
    * @version 1.0
    * @date 2019/5/28 14:07
    **/
    public class GuoDi {

    protected String name;

    /**
    * 预备工作
    */
    public void prepare(Factory factory){
    YuanLiao yuanLiao=factory.createYuanLiao();
    System.out.println("使用的原料是:"+yuanLiao.name+",使用的锅底是:"+this.name);
    }

    /**
    * 开始烫火锅
    */
    public void start(){
    System.out.println("开始烫火锅");
    }

    }

当我们建立南北方分店的时候先建立一个店的抽象类,以便我们选择锅底

  • HuoGuoStore.java
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    package factory.third;

    /**
    * TODO
    *
    * @author tudou
    * @version 1.0
    * @date 2019/5/28 14:19
    **/
    public abstract class HuoGuoStore {
    public abstract GuoDi chooseGuoDi(String type);
    }

然后再南北分店分别进行销售

  • NorthStore.java \ SouthStore.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
    package factory.third;

    /**
    * TODO
    *
    * @author tudou
    * @version 1.0
    * @date 2019/5/28 14:22
    **/
    public class NorthStore extends HuoGuoStore {

    private NorthFactory factory;

    public NorthStore(NorthFactory factory){
    this.factory=factory;
    }

    @Override
    public GuoDi chooseGuoDi(String type) {
    GuoDi guoDi=factory.createGuoDi(type);
    guoDi.prepare(factory);
    guoDi.start();
    return guoDi;
    }
    }

最后我们来进行测试

  • test.java
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    package factory;

    import factory.third.NorthFactory;
    import factory.third.NorthStore;

    /**
    * TODO
    *
    * @author tudou
    * @version 1.0
    * @date 2019/5/28 0:09
    **/
    public class test {

    public static void main(String[] args) {
    NorthFactory northFactory=new NorthFactory();
    NorthStore northStore=new NorthStore(northFactory);
    northStore.chooseGuoDi("红汤");
    }
    }

其结果是
在这里插入图片描述

模式优缺点
优点:

  • 抽象工厂模式隔离了具体类的生成,使得客户并不需要知道什么被创建。由于这种隔离,更换一个具体工厂就变得相对容易。所有的具体工厂都实现了抽象工厂中定义的那些公共接口,因此只需改变具体工厂的实例,就可以在某种程度上改变整个软件系统的行为。另外,应用抽象工厂模式可以实现高内聚低耦合的设计目的,因此抽象工厂模式得到了广泛的应用。
  • 当一个产品族中的多个对象被设计成一起工作时,它能够保证客户端始终只使用同一个产品族中的对象。这对一些需要根据当前环境来决定其行为的软件系统来说,是一种非常实用的设计模式。
  • 增加新的具体工厂和产品族很方便,无须修改已有系统,符合“开闭原则”。

缺点:

  • 在添加新的产品对象时,难以扩展抽象工厂来生产新种类的产品,这是因为在抽象工厂角色中规定了所有可能被创建的产品集合,要支持新种类的产品就意味着要对该接口进行扩展,而这将涉及到对抽象工厂角色及其所有子类的修改,显然会带来较大的不便。
  • 开闭原则的倾斜性(增加新的工厂和产品族容易,增加新的产品等级结构麻烦)

模式适用环境
在以下情况下可以使用抽象工厂模式:

  • 一个系统不应当依赖于产品类实例如何被创建、组合和表达的细节,这对于所有类型的工厂模式都是重要的。
  • 系统中有多于一个的产品族,而每次只使用其中某一产品族。
  • 属于同一个产品族的产品将在一起使用,这一约束必须在系统的设计中体现出来。
  • 系统提供一个产品类的库,所有的产品以同样的接口出现,从而使客户端不依赖于具体实现。

模式应用
在很多软件系统中需要更换界面主题,要求界面中的按钮、文本框、背景色等一起发生改变时,可以使用抽象工厂模式进行设计。

模式扩展
1.“开闭原则”的倾斜性

  • “开闭原则”要求系统对扩展开放,对修改封闭,通过扩展达到增强其功能的目的。对于涉及到多个产品族与多个产品等级结构的系统,其功能增强包括两方面:
    • 增加产品族:对于增加新的产品族,工厂方法模式很好的支持了“开闭原则”,对于新增加的产品族,只需要对应增加一个新的具体工厂即可,对已有代码无须做任何修改。
    • 增加新的产品等级结构:对于增加新的产品等级结构,需要修改所有的工厂角色,包括抽象工厂类,在所有的工厂类中都需要增加生产新产品的方法,不能很好地支持“开闭原则”。
  • 抽象工厂模式的这种性质称为“开闭原则”的倾斜性,抽象工厂模式以一种倾斜的方式支持增加新的产品,它为新产品族的增加提供方便,但不能为新的产品等级结构的增加提供这样的方便。

2.工厂模式的退化

  • 当抽象工厂模式中每一个具体工厂类只创建一个产品对象,也就是只存在一个产品等级结构时,抽象工厂模式退化成工厂方法模式;当工厂方法模式中抽象工厂与具体工厂合并,提供一个统一的工厂来创建产品对象,并将创建对象的工厂方法设计为静态方法时,工厂方法模式退化成简单工厂模式。

总结

  • 抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口,而无须指定它们具体的类。抽象工厂模式又称为Kit模式,属于对象创建型模式。
  • 抽象工厂模式包含四个角色:抽象工厂用于声明生成抽象产品的方法;具体工厂实现了抽象工厂声明的生成抽象产品的方法,生成一组具体产品,这些产品构成了一个产品族,每一个产品都位于某个产品等级结构中;抽象产品为每种产品声明接口,在抽象产品中定义了产品的抽象业务方法;具体产品定义具体工厂生产的具体产品对象,实现抽象产品接口中定义的业务方法。
    抽象工厂模式是所有形式的工厂模式中最为抽象和最具一般性的一种形态。抽象工厂模式与工厂方法模式最大的区别在于,工厂方法模式针对的是一个产品等级结构,而抽象工厂模式则需要面对多个产品等级结构。
  • 抽象工厂模式的主要优点是隔离了具体类的生成,使得客户并不需要知道什么被创建,而且每次可以通过具体工厂类创建一个产品族中的多个对象,增加或者替换产品族比较方便,增加新的具体工厂和产品族很方便;主要缺点在于增加新的产品等级结构很复杂,需要修改抽象工厂和所有的具体工厂类,对“开闭原则”的支持呈现倾斜性。
  • 抽象工厂模式适用情况包括:一个系统不应当依赖于产品类实例如何被创建、组合和表达的细节;系统中有多于一个的产品族,而每次只使用其中某一产品族;属于同一个产品族的产品将在一起使用;系统提供一个产品类的库,所有的产品以同样的接口出现,从而使客户端不依赖于具体实现。

参考:
https://blog.csdn.net/lmj623565791/article/details/24460585
https://design-patterns.readthedocs.io/zh_CN/latest/creational_patterns/abstract_factory.html

CATALOG
  1. 1. 设计模式-工厂模式
    1. 1.1. 模式分类
      1. 1.1.1. 1.简单工厂模式(静态工厂模式)
        1. 1.1.1.1. 总结
      2. 1.1.2. 2.工厂方法模式
        1. 1.1.2.1. 模式总结
      3. 1.1.3. 3.抽象工厂模式
        1. 1.1.3.1. 总结