06【工厂设计模式】

已于 2022-08-16 16:03:26 修改
阅读量3.2k 收藏 5
点赞数 4
分类专栏： # 《设计模式系列》 文章标签： 设计模式 java 简单工厂模式 抽象工厂模式 工厂方法模式
于 2022-08-16 15:26:55 首次发布
緑水長流原创出品，未经许可禁止转载！
本文链接：https://blog.csdn.net/Bb15070047748/article/details/126367141
版权

文章目录

六、工厂设计模式

工厂设计模式，顾名思义，就是用来生产对象的，在Java中，万物皆对象，这些对象都需要创建，如果创建的时候直接new该对象，就会对该对象耦合严重，假如我们要更换对象，所有new对象的地方都需要修改一遍，这显然违背了软件设计的开闭原则（一个好的软件实体应该对扩展开放，对修改关闭）；另外，如果创建一个类的过程过于复杂，如需要传递过多的构造方法参数等，那么创建对象将会变得非常麻烦，并且会与其他业务类进行耦合。当这个类发生修改时，就需要在任何引用该类的源代码处进行修改；后期维护成本将会变得巨大；

如果我们使用工厂来生产对象，我们就只和工厂打交道就可以了，彻底和对象解耦，如果要更换对象，直接在工厂里更换该对象即可，达到了与对象解耦的目的；

工厂设计模式分为三种，分别为简单工厂设计模式、工厂方法设计模式、抽象工厂设计模式；

6.1 简单工厂设计模式

简单工厂模式（Simple Factory）：简单工厂模式又称为静态工厂方法模型，它属于类创建型模式。在简单工厂模式中，可以根据方法的参数不同返回不同类的实例。简单工厂专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。

Tips：简单工厂设计模式不在GoF23种设计模式之中；

6.1.1 设计需求

  • 设计一个计算类，具备基本的加减乘除方法：
package com.dfbz.demo01_简单工厂设计模式.demo01_需求;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Operation {

    /**
     * 计算方法
     * @param num1
     * @param num2
     * @param operate
     * @return
     */
    public static Double getResult(double num1, double num2, String operate) {

        Double result = 0.0D;
        switch (operate) {
            case "+":
                result = num1 + num2;
                break;
            case "-":
                result = num1 - num2;
                break;
            case "*":
                result = num1 * num2;
                break;
            case "/":
                result = num1 / num2;
                break;
        }
        return result;
    }
}
  • 测试类：
package com.dfbz.demo01_简单工厂设计模式.demo01_需求;

import java.util.Scanner;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo01_测试加减乘除计算类 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.println("请输入第一个数: ");
        double num1 = scanner.nextDouble();
        System.out.println("请输入第一个数: ");
        double num2 = scanner.nextDouble();

        System.out.println("请输入您要执行的运算符(+、-、*、/): ");
        String operate = scanner.next();

        Double result = Operation.getResult(num1, num2, operate);
        System.out.println("运算的结果: " + result);
    }
}

6.1.2 使用接口改进代码

在上述案例程序中，代码耦合性太高，假设程序需要改进加法算法，则必须把所有的代码全部提供；并且由于所有的算法都在一起，试想一下假设一个加法算法的代码在几千行，那么程序将变得难以维护，不利于各个部件的单独升级，我们要做的是将各个部件独立出来；这样方便以后的升级扩展，并且各个模块相对独立；

  • 设计计算类的顶层接口：
package com.dfbz.demo01_简单工厂设计模式.demo02_使用接口改进;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public interface Operation {
    /**
     * 负责计算两个两个数的运算结果集,到底做什么运算,交给子类
     * @param num1
     * @param num2
     * @return
     */
    public Double getResult(Double num1,Double num2);
}
  • 加法类：
package com.dfbz.demo01_简单工厂设计模式.demo02_使用接口改进;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class OperationAdd implements Operation{
    @Override
    public Double getResult(Double num1, Double num2) {
        return num1 + num2;
    }
}
  • 减法类：
package com.dfbz.demo01_简单工厂设计模式.demo02_使用接口改进;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class OperationSub implements Operation {
    @Override
    public Double getResult(Double num1, Double num2) {
        return num1 - num2;
    }
}
  • 测试代码：
package com.dfbz.demo01_简单工厂设计模式.demo02_使用接口改进;


import java.util.Scanner;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo01 {
    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);

        System.out.println("请输入第一个数: ");
        double num1 = scanner.nextDouble();
        System.out.println("请输入第一个数: ");
        double num2 = scanner.nextDouble();

        System.out.println("请输入您要执行的运算符(+、-、*、/): ");
        String operate = scanner.next();

        Operation operation = null;
        switch (operate) {
            case "+":
                operation = new OperationAdd();
                break;
            case "-":
                operation = new OperationSub();
        }

        Double result = operation.getResult(num1, num2);

        System.out.println("计算的结果集为: " + result);
    }
}

6.1.3 使用简单工厂再改进

使用接口改进后的代码各个部件相对独立，如果以后需要修改加法类的算法也不用提供其他算法类的具体实现；但是上述代码中还存在一个具体的问题，那就是如果以后新增了其他的算法，源代码则需要一直改变；这样违反了开闭原则，我们的程序应该是"对扩展开放，对修改关闭"；即类可以新增，但源代码尽量不要再修改；

  • 设计一个工厂类：
package com.dfbz.demo01_简单工厂设计模式.demo03_使用简单工厂再改进;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class OperationFactory {
    /**
     * 根据计算方式来选择创建对应的对象
     *
     * @param method
     * @return
     */
    public static Operation createOperation(String method) {

        Operation operation = null;
        if (method.equals("+")) {
            operation = new OperationAdd();
        } else if (method.equals("-")) {
            operation = new OperationSub();
        }
        return operation;
    }

}
  • 测试类：
package com.dfbz.demo01_简单工厂设计模式.demo03_使用简单工厂再改进;

import java.util.Scanner;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo01 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.println("请输入第一个数: ");
        double num1 = scanner.nextDouble();
        System.out.println("请输入第一个数: ");
        double num2 = scanner.nextDouble();

        System.out.println("请输入您要执行的运算符(+、-、*、/): ");
        String method = scanner.next();

        Operation operation = OperationFactory.createOperation(method);

        Double result = operation.getResult(num1, num2);
        System.out.println("计算的结果集为: " + result);
    }
}

就这样，一个简单工厂设计模式就完成了。在简单工厂模式下，任何的运算逻辑新增或者修改，都不会影响客户端的代码（Demo01），只需要添加Operation的实现类，并且修改工厂类添加逻辑即可；降低了程序的耦合性；

但是，简单工厂只做到了一半的"开闭原则"，因为在简单工厂中，新增了新的算法类，需要修改工厂类；如果我们需要频繁的新增一些算法则会导致频繁修改工厂类；简单工厂中，不仅对扩展开放了，对修改也开放了；

Tips：简单工厂只适合于产品对象较少，且产品固定的需求，对于产品变化无常的需求来说显然不合适；

6.1.4 简单工厂的优缺点

  • 优点：
    • 封装了创建对象的过程，可以通过参数直接获取对象。把对象的创建和业务逻辑层分开，这样以后就避免了修改客户代码，如果要实现新产品直接修改工厂类，而不需要在原代码中修改，这样就降低了客户代码修改的可能性，更加容易扩展。
  • 缺点：
    • 1）增加新产品时还是需要修改工厂类的代码，违背了“开闭原则”。
    • 2）简单工厂模式的工厂类单一，负责所有产品的创建，但产品基数增多时，工厂类将会变得非常臃肿，违背高内聚低耦合原则；

6.2 工厂方法设计模式

工厂设计模式（Factory Method）：指定一个创建对象的接口，由接口的实现类来决定实例化哪个类，工厂方法把类的实例化工作延迟到子类中进行；

在简单工厂中，随着产品链的丰富，则工厂的职责会变得越来越多，这样并不利于维护。工厂方法模式是对简单工厂模式的进一步抽象化，其好处是可以使系统在不修改原来代码的情况下引进新的产品，即满足开闭原则。

6.2.1 工厂方法的实现

工厂方法中，不仅把产品抽象出来，连工厂类也抽象出来，具体生成什么产品由子类来决定；

  • 改进后的类图如下：

在这里插入图片描述

在工厂方法中，如果要对算法进行扩展，那么就新增一个工厂并且再新增一个具体算法类即可，工厂方法完全符合了开闭原则的对扩展开发，对修改关闭的原则；

  • 工厂抽象接口：
package com.dfbz.demo02_工厂设计模式;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public interface IFactory {
    Operation createOperation();
}
  • 产品抽象接口：
package com.dfbz.demo02_工厂设计模式;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public interface Operation {
    /**
     * 负责计算两个两个数的运算结果集,到底做什么运算,交给子类
     * @param num1
     * @param num2
     * @return
     */
    public Double getResult(Double num1,Double num2);
}
  • 专门用于生成加法产品的工厂类：
package com.dfbz.demo02_工厂设计模式;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class OperationAddFactory implements IFactory{
    @Override
    public Operation createOperation() {
        return new OperationAdd();
    }
}
  • 专门用于生成减法产品的工厂类：
package com.dfbz.demo02_工厂设计模式;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class OperationSubFactory implements IFactory{
    @Override
    public Operation createOperation() {
        return new OperationSub();
    }
}
  • 加法产品：
package com.dfbz.demo02_工厂设计模式;


/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class OperationAdd implements Operation {
    @Override
    public Double getResult(Double num1, Double num2) {
        return num1 + num2;
    }
}
  • 减法产品：
package com.dfbz.demo02_工厂设计模式;


/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class OperationSub implements Operation {
    @Override
    public Double getResult(Double num1, Double num2) {
        return num1 - num2;
    }
}
  • 测试类：
package com.dfbz.demo02_工厂设计模式;


/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo01 {
    public static void main(String[] args) {
        // 创建工厂
        IFactory factory=new OperationAddFactory();

        // 创建运算类
        Operation operation = factory.createOperation();

        // 做运算
        Double result = operation.getResult(20.0D, 30.0D);
    }
}

工厂方法完完全全做到了开闭原则，以后我们要新增一些算法，或者第三方厂商想要新增一些算法，那么直接进行子类扩展就行；

6.2.2 工厂方法的优缺点

  • 优点：
    • 1）职责相对于简单工厂来说，更加明确。不仅将产品类独立，还将产品工厂独立，以后修改产品工厂内部逻辑变得清晰明了；
    • 2）在系统增加新的产品时只需要添加具体产品类和对应的具体工厂类，无须对原工厂进行任何修改，满足开闭原则；
    • 3）高层模块只需要知道产品的抽象类，无须关系其他实现类，符合迪米特法则，依赖倒转原则；
  • 缺点：
    • 1）每增加一个产品就要增加一个具体产品类和一个对应的具体工厂类，类的数量增多，这增加了系统的复杂度。
    • 2）每个工厂只能生产一种产品，该问题可以使用抽象工厂来解决。

6.3 抽象工厂设计模式

6.3.1 抽象工厂设计模式概述

在工厂方法设计模式中，工厂生产的是总是同一类的产品；例如产品1工厂只能生产产品1，产品2工厂只能生产产品2；这些工厂只生产同种类产品，而抽象工厂模式将考虑多种类产品的生产。在抽象工厂中，将同一种工厂生产出来的产品称为同族产品，而同一种工厂生产出来的不同产品称为同级产品；

例如电子设备工厂能够生产手机，笔记本；旗下有小米工厂，华为工厂；小米工厂能够生产小米手机，小米笔记本；华为工厂能够生产华为手机，华为笔记本；

程序类图如下：

在这里插入图片描述

在这里插入图片描述

  • 同族产品：
    • 小米手机，小米笔记本属于同族产品，都属于小米品牌（都属于小米工厂创建的产品）
    • 华为手机，华为笔记本属于同族产品，都属于华为品牌（都属于华为工厂创建的产品）
  • 同级产品：
    • 小米手机，华为手机属于同级产品，都属于手机产品
    • 小米笔记本，华为笔记本属于同级产品，都属于笔记本产品
1）同族和同级

同族：只要是同一个工厂生产的产品都属于同族产品；

在这里插入图片描述

  • 小米，小米手机，小米笔记本，小米智能机，小米老年机，小米游戏本，小米商务本等都属于小米工厂生产的产品，属于同族；

同级：工厂生产出来的产品的类别称为级别，所属同一个类别的产品，那么就是同级别产品；

在这里插入图片描述

  • 小米手机，华为手机都是属于手机，属于同级产品；
  • 小米笔记本，华为笔记本都是属于笔记本，属于同级产品；
2）同族的概念

同族是有相对概念的问题，主要看我们的程序是如何设计的

  • 关于同族：只要是同一个工厂生产的产品都属于同族产品；

  • 关于同级：工厂生产出来的产品的类别称为级别，所属同一个类别的产品，那么就是同级别产品；

例如，在下面类图中，同族与同级的关系发生了变化：

在这里插入图片描述

在这里插入图片描述

同族产品：

在这里插入图片描述

  • 小米智能机，华为智能机属于同族产品，都属于老年机厂商生产的产品
  • 小米老年机，华为老年机属于同族产品，都属于智能机厂商生产的产品

同级产品：

在这里插入图片描述

  • 小米智能机，小米老年机属于同级产品；都属于小米类别
  • 华为智能机，华为老年机属于同级产品；都属于华为类别

6.3.2 抽象工厂的实现

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

  1. 抽象工厂（Abstract Factory）：提供了创建产品的接口，它包含多个创建产品的方法 newProduct()，可以创建多个不同等级的产品。
  2. 具体工厂（Concrete Factory）：主要是实现抽象工厂中的多个抽象方法，完成具体产品的创建。
  3. 抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能，抽象工厂模式有多个抽象产品。
  4. 具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间是多对一的关系。

基于类图设计程序：

在这里插入图片描述

抽象工厂：

package com.dfbz.demo03_抽象工厂设计模式;

/**
 * @author lscl
 * @version 1.0
 * @intro: 电子设备工厂, 用于生产电子设备
 */
public abstract class AbstractFactory {

    // 生产手机
    public abstract Phone createPhone();

    // 生产笔记本
    public abstract Laptop createLaptop();
}
  • 具体工厂1-小米工厂：
package com.dfbz.demo03_抽象工厂设计模式;

/**
 * @author lscl
 * @version 1.0
 * @intro: 小米工厂,用于生产小米的设备
 */
public class XiaoMiFactory extends AbstractFactory{
    @Override
    public Phone createPhone() {
        return new XiaoMiPhone();
    }

    @Override
    public Laptop createLaptop() {
        return new XiaoMiLaptop();
    }
}
  • 具体工厂2-华为工厂：
package com.dfbz.demo03_抽象工厂设计模式;

/**
 * @author lscl
 * @version 1.0
 * @intro: 华为工厂,用于生产华为的设备
 */
public class HuaWeiFactory extends AbstractFactory {
    @Override
    public Phone createPhone() {
        return new HuaWeiPhone();
    }

    @Override
    public Laptop createLaptop() {
        return new HuaWeiLaptop();
    }
}
  • 抽象产品1-手机：
package com.dfbz.demo03_抽象工厂设计模式;

/**
 * @author lscl
 * @version 1.0
 * @intro: 抽象产品,抽象手机,每个手机的功能是不一样的,具体的实现交给子类
 */
public abstract class Phone {

    public abstract void sendMsg();
}
  • 抽象产品2-笔记本：
package com.dfbz.demo03_抽象工厂设计模式;

/**
 * @author lscl
 * @version 1.0
 * @intro: 抽象产品,抽象笔记本,每个笔记本的功能是不一样的,具体的实现交给子类
 */
public abstract class Laptop {
    public abstract void play();
}
  • 具体产品1-小米手机：
package com.dfbz.demo03_抽象工厂设计模式;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class XiaoMiPhone extends Phone {
    @Override
    public void sendMsg() {
        System.out.println("使用小米手机发送短信....");
    }
}
  • 具体产品2-小米笔记本：
package com.dfbz.demo03_抽象工厂设计模式;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class XiaoMiLaptop extends Laptop {
    @Override
    public void play() {
        System.out.println("使用小米笔记本打游戏...");
    }
}
  • 具体产品3-华为手机：
package com.dfbz.demo03_抽象工厂设计模式;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class HuaWeiPhone extends Phone {
    @Override
    public void sendMsg() {
        System.out.println("使用华为手机发送短信....");
    }
}
  • 具体产品4-华为笔记本：
package com.dfbz.demo03_抽象工厂设计模式;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class HuaWeiLaptop extends Laptop {
    @Override
    public void play() {
        System.out.println("使用华为笔记本打游戏...");
    }
}
  • 测试类：
package com.dfbz.demo03_抽象工厂设计模式;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo01 {
    public static void main(String[] args) {

        // 使用华为工厂来创建电子设备
        AbstractFactory factory=new HuaWeiFactory();
        Laptop laptop = factory.createLaptop();
        Phone phone = factory.createPhone();

        laptop.play();
        phone.sendMsg();

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

        // 使用小米工厂来创建电子设备
        AbstractFactory factory2=new XiaoMiFactory();
        Laptop laptop2 = factory.createLaptop();
        Phone phone2 = factory.createPhone();

        laptop2.play();
        phone2.sendMsg();
    }
}

6.3.3 抽象工厂的优缺点

  • 优点：

    • 1）类的继承体系结构清晰明确，对类的管理方便
    • 2）有了抽象工厂，当新增一个产品族时，不需要修改源代码，例如还要新增一个联想产品族，只需要自己编写联想工厂，联想手机，联想笔记本等即可，程序的扩展性强，符合开闭原则；
    • 3）当一个产品线中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品线中的对象。

  • 缺点：

    • 当产品族中需要增加一个新的产品时，所有的工厂类都需要进行修改。例如抽象工厂不仅要生产手机和笔记本要生产电视机，那么所有的工厂包括小米工厂，华为工厂等都行呀新增对生产电视机这种产品的实现；
緑水長流*z
关注
专栏目录
Java设计模式之工厂模式
微笑听雨
07-31 2549
工厂模式（Factory Pattern）是创建型设计模式之一，旨在提供一个创建对象的接口，而不是直接通过 `new` 关键字来实例化对象。工厂模式在提高代码的可维护性、可扩展性和灵活性方面具有显著优势。
Java设计模式——工厂设计模式
12-22
工厂模式： – 实现了创建者和调用者的分离。 – 详细分类： 简单工厂模式 工厂方法模式 抽象工厂模式 面向对象设计的基本原则： OCP（开闭原则，Open-Closed Principle）：一个软件的实体应当对扩展开放，对修改...
抽象工厂模式：一个工厂的故事续集
zherop的博客
07-31 171
抽象工厂模式定义提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。涉及的两个概念（1）产品等级结构产品的继承结构。比如故事中的TV、HuaweiTV、HonorSmartTV、XiaomiTV就是一个产品等级结构，总共有3个产品等级结构（2）产品族由同一个工厂生产的，位于不同产品等级结构中的一组产品。比如故事中的HuaweiFactory生产的HuaweiTV、HuaweiPC、HuaweiSmartPhone就是一个产品族，总共有3个产品族。......
设计模式04——创建型模式
如不來的博客
01-08 332
一、概述  创建型模式的主要关注点是“怎样创建对象？”，它的主要特点是“将对象的创建与使用分离”。这样可以降低系统的耦合度，使用者不需要关注对象的创建细节，对象的创建由相关的工厂来完成。就像我们去商场购买商品时，不需要知道商品是怎么生产出来一样，因为它们由专门的厂商生产。  创建型模式分为以下几种：   单例（Singleton）模式：某个类只能生成一个实例，该类提供了一个全局访问点供外部获取该实例，其拓展是有限多例模式。   原型（Prototype）模式：将一个对象作为原型，通过对其进行复制而克隆出多个
设计模式——工厂模式
vincewm的博客
04-29 1906
工厂模式介绍、静态简单工厂模式、工厂方法模式、抽象工厂模式、JDK 源码分析
工厂设计模式
elapse008的专栏
04-30 5573
1、概念 工厂模式分三种：简单工厂模式、工厂方法模式、抽象工厂模式 简单工厂模式(Simple Factory Pattern)：属于类的创新型模式，又叫静态工厂方法模式(Static FactoryMethod Pattern),是通过专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。简单工厂模式严重违背了“开闭原则”，难以拓展。 工厂方法模式(Factory Method)：定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类当中。核心工厂类不再负责产品的创建，这样核心类成为
设计模式23模式介绍
热门推荐
学Java，找哪吒
01-18 13万+
设计模式精品专栏。
设计模式创建型——工厂模式
tszc95的博客
04-04 4423
工程模式是通过工厂获取一个一个的新对象。定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。
Java 设计模式——工厂方法模式
代码星辰的博客
07-16 2126
本文介绍了工厂方法模式的相关知识。
设计模式——工厂方法模式
y小川的专栏
06-16 8125
工厂方法是一种创建设计模式，它在父类中提供了创建对象的接口，但允许子类更改将要创建的对象类型。
设计模式创建型——抽象工厂模式
tszc95的博客
04-06 8511
抽象工厂模式（Abstract Factory Pattern）隶属于设计模式中的创建型模式，用于产品族的构建。抽象工厂是所有形态的工厂模式中最为抽象和最具一般性的一种形态。抽象工厂是指当有多个抽象角色时使用的一种工厂模式。抽象工厂模式可以向客户端提供一个接口，使客户端在不必指定产品的具体情况下，创建多个产品族中的产品对象。
Java设计模式——工厂设计模式详解
08-28
Java设计模式——工厂设计模式详解 在软件设计中，工厂设计模式是一种常用的设计模式，主要用于实例化有共同接口的类。Java设计模式——工厂设计模式是Java中的一种常用的设计模式，主要用于实例化有共同接口的类。...
Java设计模式之工厂模式（Factory模式）介绍
09-03
**工厂模式**是一种常见的设计模式，它在Java中被广泛应用于创建对象实例。工厂模式的主要目的是将对象的创建过程封装起来，使得代码更加灵活且易于维护。通过使用工厂模式，我们可以将实例化对象的责任从客户端代码...
设计模式：单例设计模式（全部实现方式）工厂设计模式，抽象工厂模式
10-18
单例设计模式、工厂设计模式和抽象工厂模式是常见的软件开发设计模式。这些设计模式提供了一些有用的思想和实现方式，可以帮助开发人员在设计和实现复杂的软件系统时，更加灵活和高效地进行编程。 单例设计模式是一...
c++设计模式-工厂方法模式
06-04
工厂方法模式是面向对象设计模式中的一个创建型模式，它提供了一种封装对象创建过程的方式，使得具体的对象创建过程可以延迟到子类中进行。在C++编程中，工厂方法模式广泛应用于各种软件设计中，因为它能有效地解耦...
MVC设计模式与delegate,tablview，Appdelegate,SceneDelegate
M3151549808的博客
09-08 835
tableView.dataSource=self 设置了UITableView的数据源为当前视图控制器对象 tableView.delegate=self 表格视图的代理对象为当前的视图控制器 那么代理有什么用呢？ 代理可以让两个视图关联起来，例如 现有两个视图控制器AVC与BVC,你要通过B视图控制器同时修改A，B两个view的背景颜色
设计模式-行为型模式-状态模式
LB_bei的博客
09-06 945
允许一个对象在其内部状态改变时改变他的行为，用于解决系统中复杂对象的状态转换以及不同状态下行为的封装问题，状态模式将一个对象的状态从该对象中分离出来，封装到专门的状态类中，使得对象的状态可以灵活变化；
24下半年学习计划
2301_80336512的博客
09-08 1831
上课的时候认真听，不要以为提前了解一些知识就认为不重要，不听也要坚持看书，不要被外界吸引。我以后大概率走后端方向，对于后端的一些技术栈目前只是跟着网上的教程学，网上的教程大部分。只适合入门，对其原理背后的实行的机制还是需要看一些经典书籍，因此在这一学期除了完成实验。《设计模式之美》，提高自己编写代码的规范性，了解设计原理，养成良好的写代码习惯。，数据库对于后端开发者来说十分重要，这一部分知识要熟悉掌握。早睡早起，少熬夜，最好是每天早晨记10个单词，晚上睡前复习。
【c++23种设计模式概述】
最新发布
m0_45463480的博客
09-09 746
c++23种设计模式概述。
设计模式解析：工厂模式详解
"这篇文章除了介绍设计模式中的工厂模式外，还涵盖了简单工厂模式、工厂方法模式和抽象工厂模式的基本概念，并给出了相应的代码示例。文章通过ICourse接口和其实现类JavaCourse来说明简单工厂模式的实现，接着讨论了...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

緑水長流*z

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值