Java23种设计模式--工厂模式

最新推荐文章于 2024-09-08 21:56:57 发布
最新推荐文章于 2024-09-08 21:56:57 发布
阅读量106 收藏 1
点赞数
分类专栏： Java23种设计模式 文章标签： 设计模式 java uml
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_64332518/article/details/130290418
版权
本文通过代码示例介绍了工厂模式（包括简单工厂、工厂方法和抽象工厂）在创建对象时的不同策略，强调了它们在解耦合和提高代码可维护性方面的作用。文章探讨了如何根据需求选择适当的设计模式，并指出设计模式选择应考虑软件的扩展性和架构。
摘要由CSDN通过智能技术生成

在23种设计模式有工厂模式和抽象工厂模式。其实我觉得没必要分开，可能是为了凑数。我在这篇博客就一起写了。工厂模式属于创建型模式不知道23种设计模式是如何分类的，去看我的单例模式讲解，那里面讲解了

  • 工厂模式其中有分类如下：
    1. 简单工厂
    2. 工厂方法
    3. 抽象工厂
  • 工厂模式：一个工厂对应一类产品，解决重复创建对象问题，直白点就是不用new，全靠这个工厂给我们对象。目的：维护对象方便，解耦合
  • 熟悉设计模式7大原则就知道工厂模式就是的最最核心就是依赖倒置原则：高层模块不应该依赖低层模块，它们都应该依赖抽象接口。抽象接口不应该依赖具体实现，具体实现应该依赖抽象接口。

1：需求

  • 为了贴近现实，就拿造车这个例子：我有一个詹姆斯车行，可以卖各种车

  • 以代码方式展现，传统写法：

    /**
 * 普通实现，所有的类都都写在内部类中最外面的相当于容器，方便观看
 * @author xxl
 * @date 2023/4/21
 */
public  class Original {
    public static void main(String[] args) {
        JamesCarStone jamesCarStone = new JamesCarStone();
        System.out.println(jamesCarStone.sellingCar("汽车"));
        System.out.println(jamesCarStone.sellingCar("跑车"));
        System.out.println(jamesCarStone.sellingCar("新能源车"));

    }
    /**
     * 核心类
     */
    public abstract static class CarStone{
        abstract  String type();
    }
    public static class NewEnergyVehicles extends CarStone{
        @Override
        String type() {
            return "新能源车";
        }
    }
    public static class Automobile extends CarStone{
        @Override
        String type() {
            return "汽车";
        }
    }
    public static class JamesCarStone{
        public static final String NEW_ENERGY_VEHICLES = "新能源车";
        public static final String AUTOMOBILE = "汽车";

        public String sellingCar(String  carName){
            CarStone carStone = null;
            switch (carName) {
                case NEW_ENERGY_VEHICLES -> carStone = new NewEnergyVehicles();
                case AUTOMOBILE -> carStone = new Automobile();
                default -> carStone = null;
            }
            return carStone == null ? carName + "暂时不在售" : "正在出售" + carStone.type();
        }
    }
}

    UML类图

在这里插入图片描述

2：简单工厂

  • 也叫静态工厂，就是通过静态方法返回一个工厂对象

  • 核心思想：**创建对象 **

    /**
 * 简单工厂
 * @author xxl
 * @date 2023/4/21
 */
public class SimpleFactoryPattern {
    public static void main(String[] args) {
        JamesCarStone jamesCarStone = new JamesCarStone(new CarStone());
        TomCarStone tomCarStone = new TomCarStone(new CarStone());

        System.out.println(jamesCarStone.sellingCar("跑车"));
        System.out.println(jamesCarStone.sellingCar("卡车"));

        System.out.println(tomCarStone.sellingCar("新能源车"));
        System.out.println(tomCarStone.sellingCar("汽车"));

    }
    
    public abstract static class Car{
        abstract  String type();
    }
    public static class NewEnergyVehicles extends Car {
        @Override
        String type() {
            return "新能源车";
        }
    }
    public static class Automobile extends Car {
        @Override
        String type() {
            return "汽车";
        }
    }
    public static class SportsCar extends Car {
        @Override
        String type() {
            return "跑车";
        }
    }
    /**
     * 核心类
     */
    public static class CarStone  {
        public static final String SPORTS_CAR = "跑车";
        public static final String AUTOMOBILE = "汽车";
        public static final String NEW_ENERGY_VEHICLES = "新能源车";
        public String queryCar(String  carName){
            Car carStone = null;
            switch (carName) {
                case NEW_ENERGY_VEHICLES -> carStone = new NewEnergyVehicles();
                case AUTOMOBILE -> carStone = new Automobile();
                case SPORTS_CAR -> carStone = new SportsCar();
                default -> carStone = null;
            }
            return carStone == null ? carName + "暂时不在售" : "正在出售" + carStone.type();
        }
    }

    public static class JamesCarStone{
        CarStone carStone = null;

        public JamesCarStone(CarStone carStone) {
            this.carStone = carStone;
        }

        public String sellingCar(String carName){
            return carStone.queryCar(carName);
        }
    }
    public static class TomCarStone{
        CarStone carStone = null;

        public TomCarStone(CarStone carStone) {
            this.carStone = carStone;
        }

        public String sellingCar(String carName){
            return carStone.queryCar(carName);
        }
    }
}

UML类图

在这里插入图片描述

3：工厂方法

  • 核心思想是：对象的实例化在子类中

    /**
 * 工厂方法类
 * @author xxl
 * @date 2023/4/21
 */
public class FactoryMethod {
    public static void main(String[] args) {
        JamesCarStone jamesCarStone = new JamesCarStone(new NewEnergyVehiclesCarFactory());
        TomCarStone tomCarStone = new TomCarStone(new AutomobileCarFactory());

        System.out.println(jamesCarStone.sellingCar("特斯拉"));
        System.out.println(jamesCarStone.sellingCar("卡车"));

        System.out.println(tomCarStone.sellingCar("宝马"));
        System.out.println(tomCarStone.sellingCar("汽车"));

    }
    public interface  Car {
        String type();
    }

    public static class BYD implements Car{
        @Override
        public String type() {
            return "比亚迪";
        }
    }
    public static class Tesia implements Car{
        @Override
        public String type() {
            return "特斯拉";
        }
    }
    public static class BWM implements Car{
        @Override
        public String type() {
            return "宝马";
        }
    }
    public static class Lamborghini implements Car{
        @Override
        public String type() {
            return "兰博基尼";
        }
    }

    public static  class NewEnergyVehiclesCarFactory extends CarStone{

        @Override
        public String queryCar(String carName) {
            Car car = null;
            if ("特斯拉".equals(carName)) {
                car = new Tesia();
            }else if ("比亚迪".equals(carName)){
                car = new BYD();
            }
            return car == null ? carName+"当前品牌不在出售":"正在出售："+car.type();
        }
    }
    public static  class AutomobileCarFactory extends CarStone{
        @Override
        public String queryCar(String carName) {
            Car car = null;
            if ("宝马".equals(carName)) {
                car = new BWM();
            }
            return car == null ? carName+"当前品牌不在出售":"正在出售："+car.type();
        }
    }
    public static  class SportsCarFactory extends CarStone{
        @Override
        public String queryCar(String carName) {
            Car car = null;
            if ("兰博基尼".equals(carName)) {
                car = new Lamborghini();
            }
            return car == null ? carName+"当前品牌不在出售":"正在出售："+car.type();
        }
    }

    public static abstract class CarStone{
        public abstract String queryCar(String carName);
    }

    public static class JamesCarStone{
        CarStone carStone = null;

        public JamesCarStone(CarStone carStone) {
            this.carStone = carStone;
        }

        public String sellingCar(String carName){
            return carStone.queryCar(carName);
        }
    }
    public static class TomCarStone{
        CarStone carStone = null;

        public TomCarStone(CarStone carStone) {
            this.carStone = carStone;
        }

        public String sellingCar(String carName){
            return carStone.queryCar(carName);
        }
    }
}

    UML图

在这里插入图片描述

4：抽象工厂

  • **核心思想：**通过定义一个接口(抽象工厂)，所有的小工厂去实现这个接口。通过这个接口就可以返回各种小工厂

  • 抽象工厂模式有两层：

    1. 抽象工厂
    2. 工厂子类
    package src.java_23_design_modes.creationmode.FactoryPattern;

/**
 * 抽象工厂
 * @author xxl
 * @date 2023/4/21
 */
public class AbstractFactory {
    public static void main(String[] args) {
        JamesCarStone jamesCarStone = new JamesCarStone(new CarStone());
        TomCarStone tomCarStone = new TomCarStone(new CarStone());

        System.out.println(jamesCarStone.sellingCar("特斯拉"));
        System.out.println(jamesCarStone.sellingCar("卡车"));

        System.out.println(tomCarStone.sellingCar("宝马"));
        System.out.println(tomCarStone.sellingCar("汽车"));
    }
    public interface Car{String type();}
    public interface CarFactory{
        Car createCar(String carName);

        String get();
    }
    public static class BYD implements Car {
        @Override
        public String type() {
            return "比亚迪";
        }
    }
    public static class Tesia implements Car {
        @Override
        public String type() {
            return "特斯拉";
        }
    }
    public static class BWM implements Car {
        @Override
        public String type() {
            return "宝马";
        }
    }
    public static class Lamborghini implements Car {
        @Override
        public String type() {
            return "兰博基尼";
        }
    }
    public static  class NewEnergyVehiclesCarFactory implements CarFactory {
        String batteryVariety;

        public void setBatteryVariety(String batteryVariety) {
            this.batteryVariety = batteryVariety;
        }

        @Override
        public Car createCar(String carName) {
            Car car = null;
            if ("特斯拉".equals(carName)) {
                car = new Tesia();
                setBatteryVariety("电池型号：18650 型钴酸锂离子电池");
            } else if ("比亚迪".equals(carName)) {
                car = new BYD();
                setBatteryVariety("电池型号：LFP（磷酸铁锂）电池");
            }

            return car;
        }
        @Override
        public String get() {
            return batteryVariety;
        }
    }
    public static  class AutomobileCarFactory implements CarFactory {
        String gasolineModel;

        public void setGasolineModel(String gasolineModel) {
            this.gasolineModel = gasolineModel;
        }

        @Override
        public Car createCar(String carName) {
            Car car = null;
            if ("宝马".equals(carName)) {
                car = new BWM();
                setGasolineModel("汽油种类：92");
            }
            return car;
        }
        @Override
        public String get() {
            return gasolineModel;
        }
    }
    public static  class SportsCarFactory implements CarFactory {
        String engineModel;

        public void setEngineModel(String engineModel) {
            this.engineModel = engineModel;
        }

        @Override
        public Car createCar(String carName) {
            Car car = null;
            if ("兰博基尼".equals(carName)) {
                car = new Lamborghini();
                setEngineModel("V12发动机");
            }
            return car;
        }
        @Override
        public String get() {
            return engineModel;
        }
    }
    public static  class CarStone{

        public  String queryCar(String carName){
            CarFactory automobileCarFactory = getAutomobileCarFactory();
            CarFactory newEnergyVehiclesCarFactory = getNewEnergyVehiclesCarFactory();
            CarFactory sportsCarFactory = getSportsCarFactory();

            Car car1 = automobileCarFactory.createCar(carName);
            Car car2 = newEnergyVehiclesCarFactory.createCar(carName);
            Car car3 = sportsCarFactory.createCar(carName);

            if (car1 != null) {
                return "正在出售"+car1.type()+automobileCarFactory.get();
            }
            if (car2 != null) {
                return "正在出售"+car2.type()+newEnergyVehiclesCarFactory.get();
            }
            if (car3 != null) {
                return "正在出售"+car3.type()+sportsCarFactory.get();
            }
            return carName+"此车不在出售";
        }

        private CarFactory getAutomobileCarFactory() {
            return new AutomobileCarFactory();
        }
        private CarFactory getNewEnergyVehiclesCarFactory() {
            return new NewEnergyVehiclesCarFactory();
        }
        private CarFactory getSportsCarFactory() {
            return new SportsCarFactory();
        }
    }

    public static class JamesCarStone{
        CarStone carStone = null;

        public JamesCarStone(CarStone carStone) {
            this.carStone = carStone;
        }

        public String sellingCar(String carName){
            return carStone.queryCar(carName);
        }
    }
    public static class TomCarStone{
        CarStone carStone = null;

        public TomCarStone(CarStone carStone) {
            this.carStone = carStone;
        }

        public String sellingCar(String carName){
            return carStone.queryCar(carName);
        }
    }

}

    UML类图

在这里插入图片描述

5：总结

  • 简单工厂 --> 工厂方法 --> 抽象工厂，从以上案例还不难看出越到后面类与类之间越来越复杂，用的模式也越来越难懂。就是说设计一个软件，初期就需要考虑它的架构和扩展性，不是说一上来就用最难的技术。而是根据情况选择，往往一个好的软件扩展性肯定不差
JamesAks
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java创建型设计模式-工厂模式
欢迎拜读我的作品，喜欢的领域请给我留言
08-10 1043
工厂设计模式中的超类可以是接口抽象类或普通 Java 类。对于我们的工厂设计模式示例，我们有一个抽象超类，其中重写了 toString()方法以用于测试目的。@Override假设我们的计算机Computer有两个子类PC和Server。PC类的实现@Override@Override@OverrideServer类的实现@Override@Override@Override关于工厂设计模式方法的一些要点是；我们可以保留工厂类。
2020版23种Java设计模式-图解-附代码.pdf
09-04
本教程详细介绍了23种经典的Java设计模式，包括创建型、结构型和行为型模式。下面将对这三大类模式进行深入解析。 1. **创建型模式**： - **工厂方法模式**：定义一个用于创建对象的接口，让子类决定实例化哪一个...
Java23种设计模式之第三弹-工厂模式
weixin_44735933的博客
11-26 1918
简单工厂也称为静态工厂。是一种创建型模式。在简单工厂中，可以根据传入参数的不同返回不同类的对象实例。简单工厂是一个专门的工厂类，用来创建不同其他类的实例对象。这些实例对象通常他们的父类是同一个抽象类或者接口。相当于加了一层。在一个工厂类中生产各种产品，对单一产品的修改又或者增加产品都可能会影响到之前创建其他产品的逻辑。所以我们要加一层将创建产品的过程移至子类生产，每个工厂子类对应一个产品的生产。产品的增加和删除不会影响到其他产品的产出单个产品逻辑修改只需要在对应的工厂类修改即可，不需要动其他的工厂。
设计模式之工厂模式
weixin_44061521的博客
05-03 370
介绍   工厂模式也称 简单工厂模式，是创建型设计模式的一种。工厂模式提供了按需创建对象的最佳方式，并且不会对外暴露创建细节，通过一个统一的接口创建所需对象。   使用工厂模式，你不需要知道对象是怎么创建出来的，不需要你去 new，调用者想要创建一个对象，知道对象的名称即可。 意图   定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。 场景   假设现在有一个造车厂，可以生产奥迪、奔驰、福特三种类型的汽车。那么此时用户要买车，只需要告诉造车厂我需要什么车，不需
【设计模式 三】实战工厂汽车代工之工厂模式-简单模式
hikktn的博客
08-21 505
工厂模式 工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。 在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。 简易UML图 #mermaid-svg-JUL5v2PZf3AZBr82 .label{font-family:'trebuchet ms', verdana, arial;font-family:var(--mermaid-font-family
【超详细】JAVA设计模式总结之23种设计模式详解（附示例代码）
qq_44082755的博客
05-11 3133
单例模式是一种创建型设计模式，确保一个类只有一个实例，并提供全局访问点来访问该实例。这意味着无论何时请求该类的实例，都将返回相同的实例。单一实例： 一个类只能有一个实例。全局访问点： 提供一个全局的访问点，使得其他对象可以轻松地访问到这个实例。延迟实例化： 实例化过程被延迟到第一次请求该实例时。节省资源： 由于只有一个实例，节省了内存和系统资源。易于控制： 由于单例模式限制了实例化过程，因此易于对实例化过程进行控制。易于扩展： 对单例类的访问点是全局的，因此易于对其功能进行扩展和修改。
java常用设计模式-抽象工厂模式
08-26
java常用设计模式-抽象工厂模式 抽象工厂模式（Abstract Factory Pattern）是一种创建型设计模式，它通过定义一个创建对象的接口来创建对象，但将具体实现的决定留给子类来决定。在抽象工厂模式中，接口是负责创建...
java常用设计模式-工厂模式
08-26
工厂模式（Factory Pattern）是一种常用的设计模式，它通过一个工厂类来实现对象的创建，而无需直接暴露对象的创建逻辑给客户端。这种模式可以使客户端代码与具体的产品类解耦，提高代码的灵活性和可维护性。 工厂...
JAVA-设计模式-创建型模式-工厂模式
08-10
JAVA-设计模式-创建型模式-工厂模式
Java常用设计模式—工厂模式
[爪洼ing]的博客
01-23 366
工厂模式 它提供了⼀种创建对象的最佳⽅式，我们在创建对象时 不会对客户端暴露创建逻辑，并且是通过使⽤⼀个共同 的接⼝来指向新创建的对象。 工厂模式有 3 种不同的实现⽅式： **简单工厂模式（**静态工厂）：通过传⼊相关的类型来返回相应的类，这种方式比较单一，可扩展性相对较差。 工厂方法模式：通过实现类实现相应的⽅法来决定相应的返回结果，这种方式的可扩展性比较强。 抽象工厂模式：基于上述两种模式的拓展，且⽀持细化产品。 应⽤场景： 解耦：分离职责，把复杂对象的创建和使⽤的过程分开。 复⽤代码 降低
23种设计模式之工厂模式
致力于不留技术债务cuizb.top
06-21 582
现实生活中，原始社会自给自足（没有工厂），农耕社会小作坊（简单工厂，民间酒坊），工业革命流水线（工厂方法，自产自销），现代产业链代工厂（抽象工厂，富士康）。项目代码同样是由简到繁一步一步迭代而来的，但对于调用者来说，却越来越简单。在日常开发中，凡是需要生成复杂对象的地方，都可以尝试考虑使用工厂模式来代替。定义一个创建产品对象的工厂接口，将产品对象的实际创建工作推迟到具体子工厂类当中。这满足创建型模式中所要求的“创建与使用相分离”的特点。按实际业务场景划分，工厂模式有 3 种不同的实现方式，分别是简单工厂模式
详解JAVA面向对象的设计模式 （三）、工厂模式
07-12 229
工厂模式 Factory 介绍 工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。 在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。 前言 工厂模式主要分为三种形式 简单工厂模式（不属于GoF的23种设计模式中） 工厂方法模式 抽象工厂模式 简单来说，本质上工厂模式是对创建对象过程的一种封装。通过封装，让客户端无需在意对象创建的过程和逻辑。看看.
走穿java23种设计模式-3抽象工厂模式详解
wenzhi的博客
10-03 7814
走穿java23种设计模式-3工厂方法模式详解工厂模式可以分为：简单工厂模式，工厂方法模式，抽象工厂模式。简单工厂模式就没什么好说的了，无非是所有的东西都写在一个类里面，要什么就调用什么，如果要添加新的方法也是到这类里面添加，代码很多，看起来也是很乱，就像一个大工厂，什么都在里面。扩展性很低。而工厂方法模式，把说明的理论和生产的东西就分开一点。抽象工厂模式是工厂方法模式的升级。
Java之23种设计模式-工厂方法模式
刘信坚的博客
07-29 755
一  简单工厂模式 在说工厂方法模式之前，先看看简单工厂模式。简单工厂模式分为三种。 1）普通 就是建立一个工厂类，对实现了同一接口的一些类进行实例的创建。首先看下关系图：   下面举一个发短信和邮箱的例子： Sender.java package com.lxj.simplefactory; public interface Sender { public void se...
设计模式-行为型模式-状态模式
LB_bei的博客
09-06 886
允许一个对象在其内部状态改变时改变他的行为，用于解决系统中复杂对象的状态转换以及不同状态下行为的封装问题，状态模式将一个对象的状态从该对象中分离出来，封装到专门的状态类中，使得对象的状态可以灵活变化；
漫谈设计模式 [11]：代理模式
刘炫320的博客
09-07 1274
老鸟：想象一下，你有一个朋友非常忙，你需要通过他的秘书与他联系。这个秘书就是你的代理，他可以帮你处理一些简单的事情，比如预约时间、传递信息等。这样，你的朋友就可以专注于他的重要工作。这就是代理模式的基本思想：通过代理对象来控制对实际对象的访问。菜鸟：哦，我明白了。代理对象就像是中间人，帮我们处理一些额外的事务。老鸟：没错。代理模式的核心思想就是在不改变原有对象的情况下，通过代理对象来添加额外的功能。老鸟：今天我们讨论了代理模式的核心思想、实现方法、优势以及适用场景。希望你能在实际项目中灵活应用。
24下半年学习计划
最新发布
2301_80336512的博客
09-08 1301
上课的时候认真听，不要以为提前了解一些知识就认为不重要，不听也要坚持看书，不要被外界吸引。我以后大概率走后端方向，对于后端的一些技术栈目前只是跟着网上的教程学，网上的教程大部分。只适合入门，对其原理背后的实行的机制还是需要看一些经典书籍，因此在这一学期除了完成实验。《设计模式之美》，提高自己编写代码的规范性，了解设计原理，养成良好的写代码习惯。，数据库对于后端开发者来说十分重要，这一部分知识要熟悉掌握。早睡早起，少熬夜，最好是每天早晨记10个单词，晚上睡前复习。
MVC设计模式与delegate,tablview，Appdelegate,SceneDelegate
M3151549808的博客
09-08 662
tableView.dataSource=self 设置了UITableView的数据源为当前视图控制器对象 tableView.delegate=self 表格视图的代理对象为当前的视图控制器 那么代理有什么用呢？ 代理可以让两个视图关联起来，例如 现有两个视图控制器AVC与BVC,你要通过B视图控制器同时修改A，B两个view的背景颜色
Java 23种设计模式详解
"《Java23种设计模式(总结)》是2014年11月27日发布的一份详细介绍了Java设计模式的文档，涵盖了23种经典的设计模式，旨在帮助开发者理解和应用这些模式。作者通过简洁的例子和理论部分，引导读者逐步深入设计模式的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值