工厂模式

最新推荐文章于 2024-07-29 10:56:36 发布
最新推荐文章于 2024-07-29 10:56:36 发布
阅读量314 收藏
点赞数
分类专栏： 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Linging_24/article/details/110367164
版权
1、简单工厂

简单工厂就是工厂提供一个统一的产品接口，根据传入的参数，由工厂决定要创建什么类型的产品对象，隐藏创建对象的内部细节。
好处就是解耦，使得代码不直接依赖于具体的实现类；
缺点就是违反开闭原则，每新增一个产品类，都需要修改我们的工厂。
在这里插入图片描述
抽象产品：

/**
 * 抽象产品--水果
 */
public interface Fruit {
    //获取产品名称--水果名称
    String name();
}

产品的具体实现：

/**
 * 产品具体实现---苹果
 */
public class Apple implements Fruit{

    @Override
    public String name() {
        return "苹果";
    }
}

/**
 * 具体的水果产品-- 香蕉
 */
public class Banana implements Fruit {
    @Override
    public String name() {
        return "香蕉";
    }
}

/**
 * 具体的水果产品--葡萄
 */
public class Grape implements Fruit{
    @Override
    public String name() {
        return "葡萄";
    }
}

生产产品的工厂:

/**
 * 生产水果的具体工厂
 */
public class FruitFactory {

    /**
     * 由工厂获取水果
     * @return
     */
    public Fruit getFruit(String name){
        if(name.equals("苹果")){
            return new Apple();
        }else if(name.equals("香蕉")){
            return new Banana();
        } else if(name.equals("葡萄")){   //新增产品类--葡萄，需要修改工厂类的源代码，违反开闭原则
            return new Grape();
        } else{
            return null;
        }
    }
}

测试：

public class Test {
    public static void main(String[] args) {
        //1.获取生产水果的工厂对象
        FruitFactory fruitFactory = new FruitFactory();
        //2.通过工厂生产水果
        Fruit apple = fruitFactory.getFruit("苹果");
        Fruit banana = fruitFactory.getFruit("香蕉");
        Fruit grape = fruitFactory.getFruit("葡萄");
        System.out.println("生产了:" + apple.name());
        System.out.println("生产了:" + banana.name());
        System.out.println("生产了:" + grape.name());
    }
}
2、工厂方法

工厂方法在简单工厂的基础上进行进一步抽象，将简单工厂中的具体工厂进行抽象为接口或抽象类，将实际创建工作推迟到子工厂中。
好处就是满足了开闭原则，用户只需要知道具体的工厂名称就可以得到所需的产品；
缺点就是每添加一个产品就要新创建一个具体产品类和一个具体的产品工厂，增加了系统复杂度。
在这里插入图片描述
抽象产品：

/**
 * 抽象产品--水果
 */
public interface Fruit {
    //获取产品名称--水果名称
    String name();
}

产品具体实现：

/**
 * 产品具体实现---苹果
 */
public class Apple implements Fruit{

    @Override
    public String name() {
        return "苹果";
    }
}

/**
 * 具体的水果产品-- 香蕉
 */
public class Banana implements Fruit {
    @Override
    public String name() {
        return "香蕉";
    }
}

/**
 * 具体的水果产品--葡萄
 */
public class Grape implements Fruit{
    @Override
    public String name() {
        return "葡萄";
    }
}

抽象工厂:

/**
 * 将简单工厂的具体工厂进行抽象为接口
 */
public interface FruitFactory {

    /**
     * 获取水果的抽象方法
     * @return
     */
    public Fruit getFruit();
}

抽象工厂的具体实现：

/**
 * 生产苹果的具体工厂
 */
public class AppleFactory implements FruitFactory{

    /**
     * 苹果工厂生产苹果产品
     * @return
     */
    @Override
    public Fruit getFruit() {
        return new Apple();
    }
}

/**
 * 生产香蕉的具体共产
 */
public class BananaFactory implements FruitFactory{
    /**
     * 生产香蕉
     * @return
     */
    @Override
    public Fruit getFruit() {
        return new Banana();
    }
}

/**
 * 葡萄工厂具体实现
 */
public class GrapeFactory implements FruitFactory{
    /**
     * 生产葡萄产品
     * @return
     */
    @Override
    public Fruit getFruit() {
        return new Grape();
    }
}

测试：

public class Test {
    public static void main(String[] args) {
        //1.我想要苹果，那么只需要知道苹果工厂即可
        AppleFactory appleFruitFactory = new AppleFactory();
        //2.生产苹果
        Fruit apple = appleFruitFactory.getFruit();
        //3.输出
        System.out.println("AppleFactory生产了:" + apple.name());

        System.out.println("=================================");

        //1.我想要香蕉，那么只需要知道香蕉工厂即可
        BananaFactory bananaFactory = new BananaFactory();
        //2.生产香蕉
        Fruit banana = bananaFactory.getFruit();
        //3.输出
        System.out.println("BananaFactory生产了:" + banana.name());

        System.out.println("=================================");
        //新增新的产品，只需新增具体产品的实现(Grape)和生产产品工厂的具体实现(GrapeFactory)即可

        //1.我想要葡萄，那么只需要知道葡萄工厂即可
        GrapeFactory grapeFactory = new GrapeFactory();
        //2.生产葡萄
        Fruit grape = grapeFactory.getFruit();
        //3.输出
        System.out.println("GrapeFactory生产了:" + grape.name());
    }
}
3、抽象工厂

工厂方法只能生产同一产品等级的产品，而抽象工厂将考虑多等级的产品生产，即抽象工厂中定义生产多个等级的产品的行为，由具体工厂来生产具体的产品。
好处是满足开闭原则，新增产品只需新增具体产品实现类和具体工厂实现，无需修改源代码，由具体的工厂来管理我们的产品族，无需引入其他类来管理；
缺点就是当产品族需要新增一个产品时，需要修改所有的工厂类。
在这里插入图片描述
抽象产品–水果：

/**
 * 抽象产品--水果
 */
public interface Fruit {
    //获取产品名称--水果名称
    String name();
}

/**
 * 抽象产品--水果汁
 */
public interface FruitJuice {

    //获取产品名称--水果汁名称
    public String name();
}

/**
 * 抽象产品--水果干
 */
public interface FruitDried {

    //获取产品名称--水果干名称
    public String name();

}

具体产品实现–苹果类:

/**
 * 产品具体实现---苹果
 */
public class Apple implements Fruit {

    @Override
    public String name() {
        return "苹果";
    }
}


/**
 * 具体的产品--苹果汁
 */
public class AppleJuice implements FruitJuice{
    /**
     * 获得苹果汁的名称
     * @return
     */
    @Override
    public String name() {
        return "苹果汁";
    }
}

/**
 * 具体的产品--苹果干
 */
public class AppleDried implements FruitDried{
    /**
     * 获取苹果干的名称
     * @return
     */
    @Override
    public String name() {
        return "苹果干";
    }
}

具体产品实现–香蕉类:

/**
 * 具体的水果产品-- 香蕉
 */
public class Banana implements Fruit {
    @Override
    public String name() {
        return "香蕉";
    }
}

/**
 * 具体的产品--香蕉汁
 */
public class BananaJuice implements FruitJuice{

    /**
     * 获取香蕉汁的名称
     * @return
     */
    @Override
    public String name() {
        return "香蕉汁";
    }
}

/**
 * 具体的产品--香蕉干
 */
public class BananaDried implements FruitDried{
    /**
     * 获取具体产品香蕉干的名称
     * @return
     */
    @Override
    public String name() {
        return "香蕉干";
    }
}

具体产品实现–葡萄类:

/**
 * 具体的水果产品--葡萄
 */
public class Grape implements Fruit {
    @Override
    public String name() {
        return "葡萄";
    }
}

/**
 * 具体的产品--葡萄汁
 */
public class GrapeJuice implements FruitJuice{
    /**
     * 获取葡萄汁的名称
     * @return
     */
    @Override
    public String name() {
        return "葡萄汁";
    }
}

/**
 * 具体的产品--葡萄干
 */
public class GrapeDried implements FruitDried {
    /**
     * 获取葡萄干的名称
     * @return
     */
    @Override
    public String name() {
        return "葡萄干";
    }
}

抽象工厂：

/**
 * 将工厂方法生产一个产品，升级为生产一个产品族
 */
public interface FruitFactory {

    /**
     * 生产水果
     * @return
     */
    public Fruit getFruit();


    /**
     * 生产水果汁
     * @return
     */
    public FruitJuice getFruitJuice();


    /**
     * 生产水果干
     * @return
     */
    public FruitDried getFruitDried();
}

具体工厂–苹果工厂：

/**
 * 具体工厂--苹果工厂
 */
public class AppleFactory implements FruitFactory {
    /**
     * 生产具体的产品--苹果
     * @return
     */
    @Override
    public Fruit getFruit() {
        return new Apple();
    }

    /**
     * 生产具体的产品--苹果汁
     * @return
     */
    @Override
    public FruitJuice getFruitJuice() {
        return new AppleJuice();
    }

    /**
     * 生产具体的产品--苹果干
     * @return
     */
    @Override
    public FruitDried getFruitDried() {
        return new AppleDried();
    }
}

具体工厂–香蕉工厂：

/**
 * 具体的工厂--香蕉工厂
 */
public class BananaFactory implements FruitFactory{
    /**
     * 生产具体的产品--香蕉
     * @return
     */
    @Override
    public Fruit getFruit() {
        return new Banana();
    }

    /**
     * 生产具体的产品--香蕉汁
     * @return
     */
    @Override
    public FruitJuice getFruitJuice() {
        return new BananaJuice();
    }

    /**
     * 生产具体的产品--香蕉干
     * @return
     */
    @Override
    public FruitDried getFruitDried() {
        return new BananaDried();
    }
}

具体工厂–葡萄工厂：

/**
 * 具体的工厂--葡萄工厂
 */
public class GrapeFactory implements FruitFactory{
    /**
     * 生产具体的产品--葡萄
     * @return
     */
    @Override
    public Fruit getFruit() {
        return new Grape();
    }

    /**
     * 生产具体的产品--葡萄汁
     * @return
     */
    @Override
    public FruitJuice getFruitJuice() {
        return new GrapeJuice();
    }

    /**
     * 生产具体的产品--葡萄干
     * @return
     */
    @Override
    public FruitDried getFruitDried() {
        return new GrapeDried();
    }
}

测试：

public class Test {
    public static void main(String[] args) {

        //1.我想获取苹果、苹果汁、苹果干产品，这些产品都有苹果工厂生产和管理
        AppleFactory appleFactory = new AppleFactory();
        //2.生产苹果、苹果汁、苹果干产品
        Fruit apple = appleFactory.getFruit();
        FruitJuice appleJuice = appleFactory.getFruitJuice();
        FruitDried appleDried = appleFactory.getFruitDried();
        //3.输出
        System.out.println("AppleFactory生产了:" + apple.name() + "、" + appleJuice.name() + "、" + appleDried.name());


        System.out.println("=====================================");

        //1.我想获取香蕉、香蕉汁、香蕉干产品，这些产品都有香蕉工厂生产和管理
        BananaFactory bananaFactory = new BananaFactory();
        //2.生产香蕉、香蕉汁、香蕉干产品
        Fruit banana = bananaFactory.getFruit();
        FruitJuice bananaJuice = bananaFactory.getFruitJuice();
        FruitDried bananaDried = bananaFactory.getFruitDried();
        //3.输出
        System.out.println("BananaFactory生产了:" + banana.name() + "、" + bananaJuice.name() + "、" + bananaDried.name());

        System.out.println("=====================================");

        //1.我想获取葡萄、葡萄汁、葡萄干产品，这些产品都有葡萄工厂生产和管理
        GrapeFactory grapeFactory = new GrapeFactory();
        //2.生产葡萄、葡萄汁、葡萄干产品
        Fruit grape = grapeFactory.getFruit();
        FruitJuice grapeJuice = grapeFactory.getFruitJuice();
        FruitDried GrapeDried = grapeFactory.getFruitDried();
        //3.输出
        System.out.println("GrapeFactory生产了:" + grape.name() + "、" + grapeJuice.name() + "、" + GrapeDried.name());
    }
}

面试–说说你对工厂设计模式的理解？

工厂模式分为三种：简单工厂、工厂方法、抽象工厂。

简单工厂就是工厂提供一个统一的产品接口，根据传入的参数，由工厂决定要创建什么类型的产品对象，隐藏创建对象的内部细节。
好处就是解耦，使得代码不直接依赖于具体的实现类；
缺点就是违反开闭原则，每新增一个产品类，都需要修改我们的工厂。

工厂方法在简单工厂的基础上进行进一步抽象，将简单工厂中的具体工厂进行抽象为接口或抽象类，将实际创建工作推迟到子工厂中。
好处就是满足了开闭原则，用户只需要知道具体的工厂名称就可以得到所需的产品；
缺点就是每添加一个产品就要新创建一个具体产品类和一个具体的产品工厂，增加了系统复杂度。

工厂方法只能生产同一产品等级的产品，而抽象工厂将考虑多等级的产品生产，即抽象工厂中定义生产多个等级的产品的行为，由具体工厂来生产具体的产品。
好处是满足开闭原则，新增产品只需新增具体产品实现类和具体工厂实现，无需修改源代码，由具体的工厂来管理我们的产品族，无需引入其他类来管理；
缺点就是当产品族需要新增一个产品时，需要修改所有的工厂类。

Linging_24
关注
专栏目录
GOF23种设计模式之抽象工厂模式
qq_44066201的博客
09-07 271
抽象工厂模式 用来生产不同产品族的全部产品。（对于增加新的产品，无能为力； 支持增加产品族） 抽象工厂模式是工厂方法模式的升级版本，在有多个业务品种、业务 分类时，通过抽象工厂模式产生需要的对象是一种非常好的解决方式。 示例代码： 高低端发动机： package com.xyj.factory.abstractFactory; /** * 发动机接口 */ public interface...
qt工厂模式例子qt简单工程模式源码
07-04
3. Qt工厂模式工程 4. Qt工厂模式例程 5. Qt工厂模式例子 6. 简单工厂模式 部分源码实例: // 奔驰工厂 class BenzFactory : public AFactory { public: ICar* CreateCar() { return new BenzCar(); } }; // ...
【设计模式】工厂模式详解
最新发布
k123456kah的博客
07-29 531
工厂模式是一种创建型设计模式，通过提供一个接口或抽象类来创建对象，而不是直接实例化对象。工厂模式的主要思想是将对象的创建与使用分离，使得创建对象的过程更加灵活和可扩展。抽象工厂（Abstract Factory）：定义了一个创建产品对象的接口，可以包含多个方法来创建不同类型的产品。具体工厂（Concrete Factory）：实现抽象工厂接口，负责实例化具体的产品对象。抽象产品（Abstract Product）：定义了产品的接口或抽象类，是工厂方法和抽象工厂模式中的基础。
AOC电视进入酒店模式和工厂模式的方法
06-15
测试机型：32m3095（其它机型未试，大同小异，自行测试） 测试时间：2022.06.15 进入酒店模式好处：可以设置...进入工厂模式好处：可以设置不正常的颜色，声音。恢复系统默认设置。好多功能，是英文的，我看不懂。
Java设计模式之工厂模式（Factory模式）介绍
09-03
**工厂模式**是一种常见的设计模式，它在Java中被广泛应用于创建对象实例。工厂模式的主要目的是将对象的创建过程封装起来，使得代码更加灵活且易于维护。通过使用工厂模式，我们可以将实例化对象的责任从客户端代码...
乐华板卡 进工程模式方法
04-11
根据提供的文档内容，本文将详细解释乐华板卡如何进入工程模式的方法，主要涉及Novatek和Realtek两种方案下的具体操作步骤。 ### 一、Novatek方案进特殊模式方法 #### 1. 板卡型号：PT系列 **1.1 工厂菜单** - *...
简单工厂模式、工厂模式、抽象工厂模式案例（C++实现）
04-10
在软件工程中，设计模式是解决常见问题的模板或最佳实践。工厂模式是其中最常用的一种，它提供了创建对象的最佳方式。在这个压缩包中，包含了三种工厂模式的C++实现：简单工厂模式、工厂方法模式以及抽象工厂模式。...
设计模式（五）.简单工厂模式
weixin_44310166的博客
09-23 198
简单工厂模式是属于创建型模式，又叫做静态工厂方法模式，但不属于23种GOF设计模式之一。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式，可以理解为是不同工厂模式的一个特殊实现。 下面是我画的一个简单的uml类图，不标准，但是大概意思能看懂，以水果为例子 在然后就是，我写的一个关于 ...
设计模式- 简单工厂模式---->工厂方法模式---->抽象工厂模式
bailizi的专栏
05-15 1213
一、引子            话说十年前，有一个暴发户，他家有三辆汽车——Benz奔驰、Bmw宝马、Audi奥迪，还雇了司机为他开车。不过，暴发户坐车时总是怪怪的：上Benz车后跟司机说“开奔驰车！”，坐上Bmw后他说“开宝马车！”，坐上Audi说“开奥迪车！”。你一定说：这人有病！直接说开车不就行了？！            而当把这个暴发户的行为放到我们程序设计中来时，会
设计模式解析：工厂模式详解
"这篇文章除了介绍设计模式中的工厂模式外，还涵盖了简单工厂模式、工厂方法模式和抽象工厂模式的基本概念，并给出了相应的代码示例。文章通过ICourse接口和其实现类JavaCourse来说明简单工厂模式的实现，接着讨论了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值