设计模式之工厂模式，但是宝可梦

🕗 发布于 2024-11-16 11:52 设计模式工厂模式 java

前言

工作一年了，业务代码写太多，还是得自驱提升点技术。希望工作一年后写出来的能有更多自己的思考。

正文

工厂模式是一种创建型设计模式，主要的目的还是在创建一个对象时提供更灵活、更易扩展的机制。

简单工厂模式

情景模拟

小智到商店去买精灵球，精灵球的种类繁多。商店店员会在库房中根据小智的要求拿对应的精灵球。在这个过程中，作为买家，小智不需要关注精灵球放在库房的哪一个位置。

/**
* 精灵球可以查看成功率，实现类有普通球和超级球
**/
public interface Ball {
    void showDetails();
}

class NormalBall implements Ball{

    @Override
    public void showDetails() {
        System.out.println("This is a normal ball. 15% to catch");
    }
}

class SuperBall implements Ball{

    @Override
    public void showDetails() {
        System.out.println("This is a super ball. 25% to catch");
    }
}

/**
 * 精灵球商店
 */
public class BallShop {
    public static Ball getBall(int ballCode){
        if (ballCode == 0){
        // 去放普通球的地方...
            return new NormalBall();
        }
        if (ballCode == 1){
        // 去放超级球的地方...
            return new SuperBall();
        }
        return null;
    }
}

对比一下直接new创建类和用工厂模式创建类：

Ball ball1 = new NormalBall();
    Ball ball2 = new SuperBall();

Ball normalBall = BallShop.getBall(0);
    Ball superBall = BallShop.getBall(1);

有一个很直观的区别：我根本不需要关心new的是什么实现类，我只需要传入对应的参数，告诉工厂我需要什么实现类。更规范一点，可以把0,1等数替换为枚举类，这样作为调用方，我无需关注怎么new的，new的什么类，我只需要相信工厂类会返回给我想要的类。

举例

DateFormat是简单工厂模式的经典运用，获取实例对象时，我只需要在getTimeInstance()方法传入类提供的枚举类，我无需关注内部实现细节，传入不同参数，后续的具体实现也就不同。

DateFormat timeInstance = DateFormat.getTimeInstance(DateFormat.FULL);
        String format1 = timeInstance.format(new Date());
        DateFormat timeInstance2 = DateFormat.getTimeInstance(DateFormat.DATE_FIELD);
        String format2 = timeInstance2.format(new Date());
        System.out.println(format1);  // 中国标准时间 上午12:37:33
        System.out.println(format2);  // 上午12:37

不足

简单工厂模式对于简单场景是很友好的，实现很简单，如果能确保业务不再扩展，简单工厂模式是很好的选择。然而如果业务有扩展，简单工厂模式的弊端就体现出来了。

如果现在我新增了一个新的球种类——大师球。现在商店里的店员都需要知道大师球放在哪个位置，加重了商店店员的逻辑（工厂内创建逻辑）

class MasterBall implements Ball{

    @Override
    public void showDetails() {
        System.out.println("MasterBall!!. 100% to catch");
    }
}

对应的工厂类就要做相应的适配：

public class BallShop {
    public static Ball getBall(int ballCode){
        if (ballCode == 0){
            // 去放普通球的地方...
            return new NormalBall();
        }
        if (ballCode == 1){
            // 去放超级球的地方...
            return new SuperBall();
        }
        if (ballCode == 2){
        // 去放大师球的地方...
            return new MasterBall();
        }
        return null;
    }
}

新增一个if分支的同时打破了开闭原则（对扩展开放，对修改封闭），其次，工厂类涵盖了所有的创建逻辑，高内聚。
为了解决业务会有新增的情况，根据面向对象编程的原则，抽象！引入工厂方法模式。

工厂方法模式

场景模拟

由于精灵球的种类不断增多，店员没办法记住每种球的位置（内聚太多逻辑），所以精灵球商店把店面分成了几个区域，每个区域售卖一种球，一个店员负责一个区域，这个店员只需要关注这个区域售卖的球在哪里。作为买家小智，他只需要知道他想买哪种球，然后去对应的分区，他仍然不需要关心球在哪里存放。

于是工厂类修改为：

public interface BallShopNew {
    Ball findBall();
}

class NormalBallFactory implements BallShopNew{
    @Override
    public Ball findBall() {
        return new NormalBall();
    }
}

class SuperBallFactory implements BallShopNew{
    @Override
    public Ball findBall() {
        return new SuperBall();
    }
}

class MasterBallFactory implements BallShopNew{
    @Override
    public Ball findBall() {
        return new MasterBall();
    }
}

使用方式：

public class FactoryDemo {
    public static void main(String[] args) {
        Ball masterBall = new MasterBallFactory().findBall();
        Ball normalBall = new NormalBallFactory().findBall();
        masterBall.showDetails();
        normalBall.showDetails();
    }
}

现在如果新推出了一种新的球，只需要开辟新的分区，聘请一个新店员（创建新的实现类），遵循了开闭原则。

不足

如果这个时候，产品维度发生了扩展，商店不止卖球了，还要卖贴纸。当产品变成复数，每个工厂就要进行相应的修改来支持新的产品，或者新增对应数量的新的工厂和实现类。系统中的类会变得极其多。抽象工厂模式用于解决复数产品的场景。

抽象工厂模式

抽象工厂模式首先将产品抽象：

public interface Label {
    void showColor();
}

class NormalLabel implements Label{
    @Override
    public void showColor() {
        System.out.println("红白配色");
    }
}

class MasterLabel implements Label{
    @Override
    public void showColor() {
        System.out.println("紫色配色");
    }
}

再在抽象工厂中引入抽象产品。

public interface BallLabelShop {
    Ball findBall();
    Label findLabel();
}

class NormalBallLabelShop implements BallLabelShop{
    @Override
    public Ball findBall() {
        return new NormalBall();
    }
    @Override
    public Label findLabel() {
        return new NormalLabel();
    }
}

class MasterBallLabelShop implements BallLabelShop{
    @Override
    public Ball findBall() {
        return new MasterBall();
    }
    @Override
    public Label findLabel() {
        return new MasterLabel();
    }
}

使用：

public class FactoryDemo {
    public static void main(String[] args) {
        MasterBallLabelShop masterBallLabelShop = new MasterBallLabelShop();
        Ball ball = masterBallLabelShop.findBall();
        Label label = masterBallLabelShop.findLabel();
        ball.showDetails();
        label.showColor();
        
NormalBallLabelShop normalBallLabelShop = new NormalBallLabelShop();
        Ball ball2 = normalBallLabelShop.findBall();
        Label label2 = normalBallLabelShop.findLabel();
        ball2.showDetails();
        label2.showColor();
    }
}

/**
MasterBall!!. 100% to catch
紫色配色
This is a normal ball. 15% to catch
红白配色
**/

这里可能就有读者会问，这不是和工厂方法模式差不多吗？其实我的理解是抽象方法模式中，工厂的实现类是将以产品组合为单位的。
上面的例子，两个工厂分别是组合了Normal和Master两种类型，让同一工厂生产的是能配套的产品组合。回到工厂模式的维度，使用者只需要知道什么工厂会给他想要的产品组合。

总结

作为一个细分了三个种类的设计模式，到底该如何取舍？比起直接new一个对象，使用对应模式的好处到底在哪？

简单工厂模式：
1. 根据传入的参数决定产出的对象，可以隐藏一些创建的细节
2. 适用于需要根据条件创建不同对象的场景。
工厂方法模式：
1. 将简单工厂转化为抽象工厂的子类，每个子类负责相应对象的创建，将创建逻辑从简单工厂中解耦到各自实现类。
2. 适用于要创建的对象会出现扩展的场景；或者是希望将创建逻辑分别封装在具体工厂类的场景。
抽象工厂模式：
1. 抽象工厂提供接口，用于创建一系列相关或者相互依赖的对象。
2. 适用于要创建复数种类的对象；或者是希望将创建逻辑封装在具体工厂类的场景。

原文地址：https://blog.csdn.net/weixin_44569973/article/details/143783758

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：k8s 中传递参数给docker容器
下一篇：【深度学习】wsl-ubuntu深度学习基本配置

【网络安全】Cookie SameSite属性
严格限制可能会影响用户体验，例如，当用户点击 GitHub 链接时，无法保持登录状态，因为此时会丢失 GitHub 的 Cookie。当浏览器加载该图片时，它会向 A.com 发送带有 Cookie
阅读更多2024-11-16
【C语言】实现二维数组按行排序
【C语言】实现二维数组按行排序
阅读更多2024-11-16
NLP开发常见问题
NLP开发常见问题
阅读更多2024-11-16
在spring boot工程中使用Filter时，@WebFilter 注解不生效的问题分析和解决方案
如果要使用@WebFilter进行过滤路径的配置，则需要在启动类中添加@ServletComponentScan注解启用Servlet容器扫描@WebFilter注解，并删除Filter类中的@Com
阅读更多2024-11-16
天天学编程Day16
在 C++ 中，常量表达式（Constant Expression）是指在编译期就能计算出结果的表达式。其结果在程序运行过程中是不可改变的，并且这个结果必须是编译时常量，例如整数常量、枚举常量、用常量
阅读更多2024-11-16
消失的数字（c语言实现）
方法一我们使用异或操作符实现。介绍一下^操作符性质就是首先0^a=a；a^a=0;然后异或操作符还满足交换律。比如a ^ b ^ c ^a= a ^ a ^b ^c;我们可以通过这样的性质实现这个代
阅读更多2024-11-16
机器学习——期末复习重点题归纳
机器学习期末复习
阅读更多2024-11-16
opencv kdtree & pcl kdtree 效率对比
由于项目中以一个环节需要使用kdtree ,对性能要求比较严苛，所以看看那个kdtree效率高一些。对比了opencv和pcl。
阅读更多2024-11-16
Qt 5.6.3 手动配置 mingw 环境
手动设置 qt mingw 编译环境
阅读更多2024-11-16
IntelliJ IDEA 2024.3（Ultimate Edition）免费化教学
一款由 JetBrains 公司开发的集成开发环境 (Integrated Development Environment, IDE)，主要用于 Java 语言的软件开发，但它也支持其他多种编程语言和
阅读更多2024-11-16

设计模式之工厂模式，但是宝可梦

前言

正文

简单工厂模式

工厂方法模式

抽象工厂模式

总结

相关文章