设计模式之工厂模式

最新推荐文章于 2024-08-22 10:30:40 发布
最新推荐文章于 2024-08-22 10:30:40 发布
阅读量164 收藏
点赞数
分类专栏： 设计模式
随意转载。
本文链接：https://blog.csdn.net/dengjili/article/details/79450261
版权

为什么需要工厂

我们来看看，当没有工厂时引发的问题

业务情景，当前有许多卖手机的店，里面卖着各种型号的手机，当前卖了苹果，三星，oppo，三款手机

当前设计

这里写图片描述
对应代码

IPhone 

package headfirst.hd.factory.phone;

public class IPhone {
    public double price = 6000;
}

Samsung

package headfirst.hd.factory.phone;

public class Samsung{
    public double price = 5000;
}

Oppo

package headfirst.hd.factory.phone;

public class Oppo{
    public double price = 2888;
}

PhoneStore ，当前需要卖一个IPhone手机

package headfirst.hd.factory.phone;

public class PhoneStore {
    public void salePhone() {
        IPhone iPhone = new IPhone();
        System.out.println(iPhone.price);
    }
}

测试类
Client 

package headfirst.hd.factory.phone;

public class Client {

    public static void main(String[] args) {
        PhoneStore phoneStore = new PhoneStore();
        phoneStore.salePhone();
    }

}
问题来了

当我们需要卖其他手机的时候，我们需要修改PhoneStore类，如下当我们需要卖Oppo手机时

package headfirst.hd.factory.phone;

public class PhoneStore {
    public void salePhone() {
        Oppo oppo= new Oppo();
        System.out.println(oppo.price);
    }
}

引入简单工厂

为了解决以上问题，我们引入简单工厂，通过接收的参数的不同来返回不同的对象实例。

简单工厂模型

这里写图片描述

重写设计模型

我们将手机抽象成接口，使用工厂类有一个共同的产品类型

设计为

这里写图片描述

重要代码为，以下修改

package headfirst.hd.factory.phone;

public interface Phone {
    void salePrice();
}

package headfirst.hd.factory.phone;

public class IPhone implements Phone {
    public double price = 6000;

    @Override
    public void salePrice() {
        System.out.println(price);
    }

}

package headfirst.hd.factory.phone;

public class Oppo implements Phone {
    public double price = 2888;

    @Override
    public void salePrice() {
        System.out.println(price);
    }
}

package headfirst.hd.factory.phone;

public class Samsung  implements Phone {
    public double price = 5000;

    @Override
    public void salePrice() {
        System.out.println(price);
    }
}

package headfirst.hd.factory.phone;

public class SimpleFactory {

    enum PhoneType {
        IPHONE,OPPO,SAMSUNG
    }

    public Phone createProduct(PhoneType type) {

        Phone phone = null;
        if (PhoneType.IPHONE == type) {
            phone = new IPhone();
        } else if (PhoneType.OPPO == type) {
            phone = new Oppo();
        } else if (PhoneType.SAMSUNG == type) {
            phone = new Samsung();
        }

        return phone;
    }


}

package headfirst.hd.factory.phone;

import headfirst.hd.factory.phone.SimpleFactory.PhoneType;

public class PhoneStore {

    SimpleFactory simpleFactory;

    public PhoneStore(SimpleFactory simpleFactory) {
        this.simpleFactory = simpleFactory;
    }

    public void salePhone(PhoneType type) {

        if (simpleFactory == null) {
            throw new NullPointerException("simpleFactory未初始化！！！");
        }

        Phone phone = simpleFactory.createProduct(type);
        phone.salePrice();
    }
}

package headfirst.hd.factory.phone;

import headfirst.hd.factory.phone.SimpleFactory.PhoneType;

public class Client {

    public static void main(String[] args) {

        SimpleFactory factory = new SimpleFactory();
        PhoneStore phoneStore = new PhoneStore(factory);
        phoneStore.salePhone(PhoneType.IPHONE);
    }

}

可以看到，简单工厂将创建实例统一管理起来，这是他的优点

缺点是当我们需要新增一种类型，必须打开createProduct方法，如下，我们添加XiaoMi手机类型

新增手机类型，小米XiaoMi 


package headfirst.hd.factory.phone;
public class XiaoMi implements Phone {
    public double price = 1999;

    @Override
    public void salePrice() {
        System.out.println(price);
    }
}

修改SimpleFactory 

package headfirst.hd.factory.phone;

public class SimpleFactory {

    enum PhoneType {
        IPHONE,OPPO,SAMSUNG,XIAOMI
    }

    public Phone createProduct(PhoneType type) {

        Phone phone = null;
        if (PhoneType.IPHONE == type) {
            phone = new IPhone();
        } else if (PhoneType.OPPO == type) {
            phone = new Oppo();
        } else if (PhoneType.SAMSUNG == type) {
            phone = new Samsung();
        } else if (PhoneType.XIAOMI == type) {
            phone = new XiaoMi();
        }

        return phone;
    }


}

PS:简单工厂不是设计模式

引入工厂方法模式

为了解决以上问题，我们引入工厂方法模式，通过逻辑拆分，将创建实例封装在不同的工厂中，例如，IPhone有很多款手机，XiaoMi也有很多款手机，当IPhone发布新手机的时候，我们需要改变IPhone对应的工厂

工厂方法模式模型

这里写图片描述

重写设计新模型

这里写图片描述

这里只贴与factory相关的代码，重点说明一下工厂方法模式
PhoneFactory

package headfirst.hd.factory.phone;

public abstract class PhoneFactory {
    //父类定义抽象接口，不管子类具体是哪一种类型
    public void salePhone(String type) {
        Phone phone = createProduct(type);
        phone.salePrice();
    }

    //子类只实现这个方法，其他的什么都不做
    protected abstract Phone createProduct(String type);
}

XiaoMiPhoneFactory

package headfirst.hd.factory.phone;

public class XiaoMiPhoneFactory extends PhoneFactory {

    @Override
    protected Phone createProduct(String type) {

        Phone phone = null;

        if ("XiaoMi2".equals(type)) {
            phone = new XiaoMi2();
        } else if ("XiaoMi3".equals(type)) {
            phone = new XiaoMi3();
        }

        return phone;
    }

}

IPhonePhoneFactory

package headfirst.hd.factory.phone;

public class IPhonePhoneFactory extends PhoneFactory {

    @Override
    protected Phone createProduct(String type) {

        Phone phone = null;

        if ("IPhone4".equals(type)) {
            phone = new IPhone4();
        } else if ("IPhone5".equals(type)) {
            phone = new IPhone5();
        }

        return phone;
    }

}

测试Client

package headfirst.hd.factory.phone;

public class Client {

    public static void main(String[] args) {
        //卖小米4
        PhoneFactory factory = new XiaoMiPhoneFactory();
        factory.salePhone("XiaoMi2");

    }
}
重要说明


  2. 工厂方法模式，其中方法指的子类里只实现父类的抽象方法，而父亲提供产品的行为，工厂方法模式将两者解耦，使类责任单一化
  3. 与简单工厂的相似性，如果单单看其中某一个工厂，和所对应的产品，工厂方法模式和简单工厂很类似，如下图所示
    这里写图片描述
  4. 站在PhoneFactory角度看，我们将原来简单工厂的逻辑，按照业务拆分成多个方法
    这里写图片描述
  5. 当我们新增具体的产品时候
    • 当前新增手机IPhone6，简单工厂会修改SimpleFactory中的代码，工厂方法模式修改IPhonePhoneFactory中的代码，不会影响XiaoMiPhoneFactory中的代码，将影响降低
    • 当前新增手机XiaoMi4，简单工厂会修改SimpleFactory中的代码，工厂方法模式修改XiaoMiPhoneFactory中的代码，不会影响IPhonePhoneFactory中的代码，将影响降低
    • 当我们新增新类型手机，例如VIVO，单工厂会修改SimpleFactory中的代码，工厂方法模式新增VivoPhoneFactory类，不会影响到已有类，最理想的状态

简单工厂对需求已知时候，毕竟适应，产品需求经常变话时，工厂方法模式更加适应

抽象工厂模式

以上问题都是单一产品。抽象工厂是应对产品族概念的。比如说，每一款手机由屏幕，处理器，内存等组成。其中屏幕，电量，内存都对应的一类产品。那么每一个工厂创建手机的组成时候，需要创建对应组成部分。

这里的产品对应的是屏幕（很多种），电量（很多种），内存（很多种）

抽象工厂模式模型

这里写图片描述

iPhone X的手机的一些配置
这里写图片描述

当前设计
这里写图片描述

对应代码

产品家族Battery 

package headfirst.hd.factory.abs;

public interface Battery {
    //这里简化，不做任何操作
}

package headfirst.hd.factory.abs;

public class Battery1 implements Battery {

}

package headfirst.hd.factory.abs;

public class Battery2 implements Battery {

}

产品家族Memory 

package headfirst.hd.factory.abs;

public interface Memory {
    //这里简化，不做任何操作
}

package headfirst.hd.factory.abs;

public class Memory1 implements Memory {

}

package headfirst.hd.factory.abs;

public class Memory2 implements Memory {

}

产品家族Screen 

package headfirst.hd.factory.abs;

public interface Screen {
    //这里简化，不做任何操作
}

package headfirst.hd.factory.abs;

public class Screen1 implements Screen {

}

package headfirst.hd.factory.abs;

public class Screen2 implements Screen {

}

抽象工厂

package headfirst.hd.factory.abs;

public interface IPhoneXFactory {
    Screen createScreen();
    Battery createBattery();
    Memory createMemory();
}

package headfirst.hd.factory.abs;

//普通版本，8333
public class NormalFactory implements IPhoneXFactory {

    @Override
    public Screen createScreen() {
        return new Screen1();
    }

    @Override
    public Battery createBattery() {
        return new Battery1();
    }

    @Override
    public Memory createMemory() {
        return new Memory1();
    }

}

package headfirst.hd.factory.abs;

//plus版本，10000
public class PlusFactory implements IPhoneXFactory {

    @Override
    public Screen createScreen() {
        return new Screen2();
    }

    @Override
    public Battery createBattery() {
        return new Battery2();
    }

    @Override
    public Memory createMemory() {
        return new Memory2();
    }

}

定义手机

package headfirst.hd.factory.abs;

public class IPhone {

    IPhoneXFactory factory;

    public IPhone(IPhoneXFactory factory) {
        this.factory = factory;
    }

    //手机的一些操作
    public void doOperate() {
        //屏幕

        //内存

        //电池
    }

}

测试

package headfirst.hd.factory.abs;

public class Client {

    public static void main(String[] args) {
        //整一个plus版本
        IPhoneXFactory factory = new PlusFactory();
        IPhone iPhone = new IPhone(factory);
        iPhone.doOperate();
    }

}

缺点，如果现在新增处理器产品，则必须修改抽象工厂接口，如下
产品

package headfirst.hd.factory.abs;

public interface Cpu {
    //这里简化，不做任何操作
}

抽象接口

package headfirst.hd.factory.abs;

public interface IPhoneXFactory {
    Screen createScreen();
    Battery createBattery();
    Memory createMemory();

    Cpu createCpu();
}

影响已有代码

总结

整理优点缺点
简单工厂用来生产同一等级结构中的任意产品，且设计简单对于增加新的产品，必须修改原有代码
工厂方法模式用来生产同一等级结构中任意产品，是对简单工厂的增强将影响降到最低
抽象工厂模式用来生产不同产品族的产品如何新增产品，必须修改抽象工厂接口

可根据实际需求，选择对应的方法

dengjili
关注
专栏目录
Java设计模式之工厂模式
微笑听雨
07-31 2994
工厂模式（Factory Pattern）是创建型设计模式之一，旨在提供一个创建对象的接口，而不是直接通过 `new` 关键字来实例化对象。工厂模式在提高代码的可维护性、可扩展性和灵活性方面具有显著优势。
设计模式之工厂模式总结
12-21
编辑Java笔记");}}增加Python笔记public ...设计模式是软件开发中的宝贵经验总结，工厂模式作为其中的一员，可以帮助我们编写更加灵活、可维护的代码。理解并熟练运用工厂模式，能够提升软件设计的质量和可扩展性。
设计模式之工厂模式(C++)
热门推荐
翟天保的博客
02-15 2万+
介绍设计模式之工厂模式
JAVA设计模式之工厂模式（三种工厂模式）
m0_65260253的博客
11-17 2万+
JAVA设计模式之工厂模式（三种工厂模式）
javascript设计模式之工厂模式
object not found的博客
08-12 1万+
函数creatPerson（）接受了三个参数，根据这几个参数创建了一个包含person信息的对象，可以用不同的参数去多次调用这个对象，而它就回每次都返回3个属性和一个方法的对象，虽然这种工厂模式可以解决创建多个相似对象的问题，但是他没有解决对象标识的问题，到这里可能有小伙伴不知道对象标识是什么，解释一下对象标识就是我们创建的对象是什么类型。工厂模式是一种众所周知的设计模式，广泛应用于软件工程领域，用于抽象创建特定对象的过程。.........
C#设计模式之工厂模式
BraveRunTo的博客
07-10 1813
C#设计模式之工厂模式 文章目录C#设计模式之工厂模式简单工厂模式模式分类模式产生的原因模式灵感的来源模式类图经典代码实现简单工厂模式的总结（优点和缺点最好在使用中自行体会）简单工厂模式的优点简单工厂模式的缺点工厂方法模式模式分类模式产生的原因模式灵感的来源模式类图经典代码实现工厂方法模式总结工厂方法模式的优点工厂方法模式的缺点抽象工厂模式模式分类模式产生的原因模式灵感的来源模式类图经典代码实现抽象工厂模式总结抽象工厂模式的优点：抽象工厂模式的缺点： 本篇博客将介绍简单工厂，工厂方法和抽象工厂，之所以放在一
Android常用设计模式之工厂模式理解
qq_36639105的博客
10-10 2516
设计模式之工厂模式
JS设计模式之工厂模式
weixin_44051815的博客
11-19 2379
JS设计模式之工厂模式 工厂模式大体分为三类： 简单工厂模式、 工厂方法模式、抽象工厂模式。三者之间的关系，也是渐进式的，抽象化的范围也是越来越高。 1. 简单工厂模式： 对同一类对象创建过程的抽象，在形式上它仅仅只是简单的通过 switch 等判断语句，根据不同条件去生成不同对象，且只能创建现有的数据，如果要添加，必须手动添加。 interface IPhone { name: string; price: number; } enum Phones { hw, mi } /
设计模式 之 工厂模式
大佛拈花的博客
08-28 1万+
工厂模式可以屏蔽接口的具体实现，调用的时候只关注接口的具体名称而无需关注实现。这是他的优点。如果增加其他的功能，只需要实现接口即可。同样的，当需要大量的额功能是，这时候就需要创建多个类，增加了类的数目，也为系统带来了复杂性。下面的代码是演示工厂设计模式。 场景：当我们调用接口的时候我们根据传递进来的进口通信...
游戏开发设计模式之工厂模式
最新发布
Ctrl+CV九段手
08-22 1830
抽象工厂模式提供了一个接口，用于创建一系列相关或相互依赖的对象，而无需指定它们具体的类。抽象工厂模式使得客户端不需要知道如何创建这些对象的具体类。在游戏开发中，工厂模式可以有效地解决对象创建的问题，降低耦合度，提高系统的可扩展性和灵活性。具体选择哪种工厂模式应根据实际情况和需求进行权衡。例如，在Unity3D游戏开发中，工厂模式被广泛应用于各种设计模式中，帮助开发者写出低耦合高内聚的项目。如果项目较小且不需要处理复杂的产品系列，简单工厂模式可能是一个不错的选择。
PHP设计模式之工厂模式定义与用法详解
12-20
【工厂模式】是一种常见的设计模式，它属于创建型模式，主要目标是提供一个创建对象的接口，隔离了实例化过程，使得系统对扩展开放而对修改封闭。在PHP中，工厂模式的应用能帮助我们更好地管理和控制对象的创建。 ...
Java设计模式之工厂模式实现方法详解
08-28
Java设计模式之工厂模式实现方法详解 工厂模式是 Java 设计模式中的一种重要模式，它提供了一种创建对象的接口，以便将创建对象的具体过程屏蔽隔离起来，达到提高灵活性的目的。工厂模式主要有三种：简单工厂模式、...
Java设计模式之工厂模式（Factory模式）介绍
09-03
工厂模式之所以被广泛采用，原因在于它能够带来以下好处： 1. **封装变化**：当需要创建的对象发生变化时，如新增或修改类，只需要修改工厂类，而无需改动使用这些对象的客户端代码。 2. **提高灵活性**：通过工厂...
访问者模式
dengjili的专栏
10-30 7203
想要为一个对象增强新的行为，且不封装具体的实现，那么就用访问者模式 一般我们都是使用访问者模式增添遍历行为，这是一个误区。 模型 Element 表示要增强的行为，即accept方法 elementA 代表原有对象 visitor表示抽象接口 visitorA表示具体的行为实现 改进之前的例子 组合模式中的列子：https://blog.csdn.net/dengjili/article/d...
依赖倒置原则定义，及倒置的两种理解
dengjili的专栏
03-06 4278
依赖倒置原则定义 如下（可先不管） - 高层模块不应该依赖低层模块，两者都应该依赖抽象 - 抽象不应该依赖细节 - 细节应该依赖抽象 情景描述 当前有一家饮料店，里面卖着很多饮料 设计如下 问题描述 这里箭头符号表示BeverageStore依赖Juice，及高层依赖于低层 在BeverageStore中，对应的是具体的饮料实现，具体代码如下 pa...
模板方法-高级应用 hook（钩子）
dengjili的专栏
03-22 3231
模板方法模式入门：https://blog.csdn.net/dengjili/article/details/79631472 修改设计 加入hook，其中这个hook方法是可选的 给出例子，再给出解释 package headfirst.hd.template.eg; public abstract class AbstractClass { //不让子类覆盖掉...
命令模式 undo，redo
dengjili的专栏
03-12 2177
命令模式入门例子：http://blog.csdn.net/dengjili/article/details/79495454 为什么需要undo 很多时候，我们再操作完，命令之后，我们发现，这个功能不是我们想要的，比如我们在文本编辑中，误删除了文本，我们希望通过回退操作，达到之前的状态。像之前的列子，我们打开了灯，但是之后发现，我们不需要开灯，我们也可以通过undo能撤销刚才的命令 ...
设计模式解析：工厂模式详解
"这篇文章除了介绍设计模式中的工厂模式外，还涵盖了简单工厂模式、工厂方法模式和抽象工厂模式的基本概念，并给出了相应的代码示例。文章通过ICourse接口和其实现类JavaCourse来说明简单工厂模式的实现，接着讨论了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值