【浅谈设计模式】:(3) 工厂模式–将实例的生成交给子类

这是我参与更文挑战的第5天,活动详情查看: 更文挑战

一、初识工厂模式

1.1 概述

今天,开始学习设计模式中创建者模式的第二种–工厂模式(Factory Method)。

老规矩,先上百度百科定义:

工厂模式是我们最常用的实例化对象模式了,是用工厂方法代替new操作的一种模式。著名的Jive论坛 ,就大量使用了工厂模式,工厂模式在Java程序系统可以说是随处可见。因为工厂模式就相当于创建实例对象的new,我们经常要根据类Class生成实例对象,如A a=new A() 工厂模式也是用来创建实例对象的,所以以后new时就要多个心眼,是否可以考虑使用工厂模式,虽然这样做,可能多做一些工作,但会给你系统带来更大的可扩展性和尽量少的修改量。

通过百度百科,我们知道平常使用最多的new操作来创建实例的时候,可能并不是最好的生成实例的策略,每次 new 一个对象的时候,它会有一些列复杂的初始化过程,例如进行在内存开辟空间、对变量进行初始化、还有检查配置文件等等校验操作,重复的new对象就相当于我们做月饼,如果每次都手工去做,那么就要把这个面团里面放馅,然后将它捏成圆形,在雕刻上字样,过程非常复杂,而使用工厂模式,就只需要将放完馅后的面团经过模具直接复印出来即可,在工厂模式种判断,如果是要刻上“花好月圆”就使用花好月圆的模具来打造,如果是要刻上“中秋佳节”就使用中秋佳节的模具来打造。

月饼.jpg

那么对应到工厂模式,就是我们不妨定义一个类(月饼模具)来 专门负责对象的创建,这样的类称为工厂类。在任何需要生成复杂对象的地方,都可以使用工厂模式来打造。这样,就把模具的实例和月饼分离开,一个是负责创建实例,一个是使用实例。

1.2 使用场景

  • 对象的创建过程准备工作很复杂,需要初始化很多参数、查询数据库等。
  • 类本身有很多子类,这些类的创建过程在业务种容易发生改变,或者对类的调用容易发生改变。

分类:

  • 1、简单工厂模式
  • 2、工厂方法模式
  • 3、抽象工厂模式

二、简单工厂模式

工厂模式最大的优点就是解耦,实现了面向接口编程思想。定义一个创建对象的接口,让其子类自己决定实例化哪一个工厂类。

2.1 结构

简单工厂模式不是一种设计模式,反而像是一种编程习惯。

简单工厂包含如下角色:

  • 抽象产品:定义了产品的规范,描述了产品的主要特性和功能
  • 具体产品:实现或者继承抽象产品的子类
  • 具体工厂:提供了创建产品的方法,调用者通过该方法来获取产品。

2.2 使用

创建不同字样的月饼。

image.png

1、创建抽象接口

/**
 * 定义一个月饼模具接口
 */
public interface MoonCakeMould {
    //使用模具
    void use();
}
复制代码

2、创建子类实例

public class GoodMoon implements MoonCakeMould {
    @Override
    public void use() {
        System.out.println("采用花好月圆模具");
    }
    public GoodMoon(){
        this.use();
    }
}

public class NotBadMoon implements MoonCakeMould {
    @Override
    public void use() {
        System.out.println("使用中秋快乐模具!");
    }
    public NotBadMoon(){
        this.use();
    }
}

复制代码

3、创建工厂类:

public class MoonCakeFactory {
    public MoonCakeMould makeMoon(String text){
        if(text.equals("花好月圆")){
            return new GoodMoon();
        }else if (text.equals("中秋快乐")){
            return new NotBadMoon();
        }
        return null;
    }

    public static void main(String[] args) {
        MoonCakeFactory factory = new MoonCakeFactory();
        MoonCakeMould moon = factory.makeMoon("花好月圆");
        MoonCakeMould moon1 = factory.makeMoon("中秋快乐");
        System.out.println("模具花好月圆:"+moon+";模具中秋快乐:"+moon1);
    }
}
复制代码

4、输出结果:

采用花好月圆模具
使用中秋快乐模具!
模具花好月圆:patten.facotry.GoodMoon@33a10788;模具中秋快乐:patten.facotry.NotBadMoon@7006c658
复制代码

2.3 优缺点

优点:简单工厂模式封装了创建对象的过程,可以通过参数直接获取对象。把对象的创建和业务逻辑层分开,这样以后就避免了修改客户端代码,如果需要新增新产品,直接修改工厂类,而不需要在原代码中修改,这样就降低了客户代码修改的可能性,更加容易扩展。

缺点:增加新产品需要修改工厂类的代码,违背了“开闭原则”,也就是多加几个if-else,所以简单工厂模式适合业务简单,工厂类不会经常变更的情况。

三、工厂方法模式

为了解决简单工厂模式的修改问题,既然要修改工厂类,那我们可以多建几个工厂这样就可以不用修改了,这些工厂统一继承一个抽象工厂,这样就完全遵循开闭原则。

3.1 结构

工厂方法模式的主要角色:

  • 抽象工厂(Abstract Factory):声明工厂方法接口,调用者通过它访问具体工厂的工厂方法来创建产品。
  • 具体工厂(ConcreteFactory):实现抽象工厂中的抽象方法,完成具体产品的创建。
  • 抽象产品(product):定义了产品的规范,描述了产品的主要特性和功能。
  • 具体产品(concreteProduct):实现了抽象产品角色所定义的接口,由具体工厂来创建,它由具体工厂之间一一对应。

image.png

3.2 实现

1、抽象工厂

public interface MoonCakeFactory {
     MoonCakeMould makeMoon();
}
复制代码

2、具体工厂

public class GoodMoonCakeFactory implements MoonCakeFactory {
    @Override
    public MoonCakeMould makeMoon() {
        return new GoodMoon();
    }
}

public class NotBadMoonCakeFactory implements MoonCakeFactory {
    @Override
    public MoonCakeMould makeMoon() {
        return new NotBadMoon();
    }
}
复制代码

3、抽象产品

public interface MoonCakeMould {
    //使用模具
    void use();
}
复制代码

4、具体产品

public class NotBadMoon implements MoonCakeMould {
    @Override
    public void use() {
        System.out.println("使用中秋快乐模具!");
    }
    public NotBadMoon(){
        this.use();
    }
}

public class GoodMoon implements MoonCakeMould {
    @Override
    public void use() {
        System.out.println("采用花好月圆模具");
    }
    public GoodMoon(){
        this.use();
    }
}
复制代码

3.3 优缺点分析

优点:

  • 解决了开闭原则,无需修改工厂类
  • 用户只需要知道具体工厂的名称就可以得到所要的产品,无须知道产品的具体创建过程。

缺点:

  • 每增加一个产品就要增加一个具体类和一个对应的具体工厂类,这增加了系统的复杂度。

四、抽象工厂模式

抽象工厂的出现是为了解决工厂模式的问题,尽可能缩减工厂实现子类的数量,不必给每一个产品分配一个工程类,能够将产品进行分组,然后在每组中由同一个工厂类的不同方法来创建。例如真正的工厂可能又造手机,又搞电视,最近还要搞车!

image.png

那么面对这种综合型能搞的公司,能够生产出多种类的产品,就可以采用抽象工厂模式考虑多个组。

抽象工厂模式将考虑多等级产品的生产和多品牌的产品。

image.png

如上所示,上面简单的按小米和红米来分,事实上一个一个产品可能有更多的类,那么如果每一个类都创建一个实例工厂,例如图中的小米汽车工厂类、红米汽车工厂类……等,那就需要六个工厂类。

4.1 结构

抽象工厂模式的主要角色如下:

  • 抽象工厂(Abstract Factory):提供了创建产品的接口,它包含多个创建产品的方法,可以创建多个不同等级的产品。例如:有小米手机、红米手机、黑鲨游戏机等等产品…..
  • 具体工厂(Concrete Factory):实现抽象工厂的多个抽象方法,完成具体产品的创建。
  • 抽象产品(product):定义了产品的规范,描述了产品的主要特性和功能,抽象工厂模式有多个抽象产品。
  • 具体产品(product):实现了抽象产品角色定义的接口,由具体工厂创建。与具体工厂是多对一关系。

4.2 实现

image.png
1、抽象工厂

/**
 * 抽象工厂
 */
public interface TopFactory {
    //创建小米产品
    Xiaomi createXiaomiProduct();
    //创建红米产品
    RedMei createRedmiProduct();
}
复制代码

2、具体工厂(对应产品族)

/**
 * 手机工厂类
 */
public class PhoneFactory implements TopFactory{
    @Override
    public Xiaomi createXiaomiProduct() {
        return new XiaomiPhone();
    }

    @Override
    public RedMei createRedmiProduct() {
        return new RedmiPhone();
    }
}

/**
 * 电视工厂类
 */
public class TvFactory implements TopFactory {
    @Override
    public Xiaomi createXiaomiProduct() {
        return new XiaomiTv();
    }

    @Override
    public RedMei createRedmiProduct() {
        return new RedMiTv();
    }
}
复制代码

3、抽象产品(对应横轴)

/**
 * 产品抽象类:小米
 */
public interface Xiaomi {
    void print();
}

/**
 * 产品抽象类:红米
 */
public interface RedMei {
    void print();
}
复制代码

4、具体类

public class RedMiTv implements RedMei {
    public RedMiTv(){
        this.print();
    }
    @Override
    public void print() {
        System.out.println("生产一个红米手机");
    }
}

public class RedmiPhone implements RedMei {
    public RedmiPhone(){
        this.print();
    }
    @Override
    public void print() {
        System.out.println("生产一台红米手机");
    }
}

public class XiaomiTv implements Xiaomi {
    public XiaomiTv(){
        this.print();
    }
    @Override
    public void print() {
        System.out.println("生产一个小米电视");
    }
}

public class XiaomiPhone implements Xiaomi {
    public XiaomiPhone(){
        this.print();
    }
    @Override
    public void print() {
        System.out.println("生产一台小米手机");
    }
}
复制代码

5、测试

public class test {
    public static void main(String[] args) {
        PhoneFactory phoneFactory = new PhoneFactory();
        phoneFactory.createRedmiProduct(); //生产一台红米手机
        TvFactory tvFactory = new TvFactory();
        tvFactory.createXiaomiProduct();//生产一个小米电视
    }
}
复制代码

4.3 优缺点

优点:当一个产品族中的多个对象被设计程一起工作时,它能保证客户端始终只使用同一个产品族中的对象。

缺点:当产品中需要增加一个新的产品时,所有的工厂类都需要进行修改。例如新增个黑鲨产品,那么父工厂就要新增一个创建黑鲨产品的方法,其他子工厂都要继承修改。

五、小结

  • 简单工厂:唯一工厂类,一个产品抽象类,工程类的创建方法依据入参判断。

  • 工厂方法:多个工厂类,一个产品抽象类,利用多态创建不同的产品对象,避免大量的if-else判断。

  • 抽象工厂:多个工厂类,多个产品抽象类,产品子类分组,同一个工厂实现类创建同组的不同产品,减少了工厂子类的数量。

工厂模式使用场景:

1、对象的创建过程、实例化准备工作很复杂,需要初始化很多参数,查询数据库等。

2、类本身有很多子类,这些类的创建过程在业务中容易发生改变,或者对类的调用容易发生改变。

3、DateForamt类中的getInstance()方法使用的是工厂模式;

4、Calendar类中的getInstance()方法使用的是工厂模式;

总之,工厂模式的意义就是 :其一为了方便将实例化过程和业务逻辑真正的解耦,其二是屏蔽复杂对象创建逻辑。工厂模式一般用来创建复杂对象,如果只需用new就可以创建成功的简单对象,就无需使用工厂模式,否则会增加系统的复杂度。

这是浅谈设计模式系列的第三篇文章,学习设计模式的目的就是尽快能看懂各种大神优雅的代码设计,并学着使用它,路漫漫其修远兮,求索之心不可断。

© 版权声明
THE END
喜欢就支持一下吧
点赞0 分享