创造型设计模式详解与总结

于 2024-10-12 09:00:00 发布
阅读量685 收藏 21
点赞数 9
文章标签： 设计模式 java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fudaihb/article/details/142844751
版权

引言

设计模式是软件开发中的一个重要概念，旨在提供通用的解决方案来应对常见的设计问题。设计模式可以分为三大类：创造型模式、结构型模式和行为型模式。在这些模式中，创造型设计模式（Creational Design Patterns）专注于对象的创建，确保系统在面对复杂对象构建时具有更好的灵活性和可维护性。

创造型设计模式的核心思想是将对象的创建逻辑与业务逻辑分离，使系统能够在不影响业务代码的情况下，灵活地修改或扩展对象的创建方式。本文将详细介绍几种常见的创造型设计模式，包括工厂模式、抽象工厂模式、单例模式、建造者模式和原型模式。

一、工厂方法模式（Factory Method Pattern）

1.1 模式简介

工厂方法模式是一种常用的创建型设计模式，它通过定义一个创建对象的接口或抽象类，让子类决定实例化哪一个类。工厂方法模式的关键思想是将对象的实例化操作延迟到子类，从而使得客户端不必依赖于具体类的实现。

1.2 模式结构

工厂方法模式的主要参与者包括：

  • 抽象工厂（Creator）：声明一个创建对象的抽象方法，通常是 createProduct() 方法。
  • 具体工厂（Concrete Creator）：实现抽象工厂中的创建方法，负责实例化具体的产品对象。
  • 产品（Product）：定义产品的接口或抽象类。
  • 具体产品（Concrete Product）：具体实现产品接口的类。

1.3 代码示例

// 产品接口
public interface Product {
    void use();
}

// 具体产品A
public class ConcreteProductA implements Product {
    @Override
    public void use() {
        System.out.println("使用产品A");
    }
}

// 具体产品B
public class ConcreteProductB implements Product {
    @Override
    public void use() {
        System.out.println("使用产品B");
    }
}

// 工厂接口
public abstract class Creator {
    public abstract Product createProduct();
}

// 具体工厂A
public class ConcreteCreatorA extends Creator {
    @Override
    public Product createProduct() {
        return new ConcreteProductA();
    }
}

// 具体工厂B
public class ConcreteCreatorB extends Creator {
    @Override
    public Product createProduct() {
        return new ConcreteProductB();
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Creator creatorA = new ConcreteCreatorA();
        Product productA = creatorA.createProduct();
        productA.use();

        Creator creatorB = new ConcreteCreatorB();
        Product productB = creatorB.createProduct();
        productB.use();
    }
}

1.4 优缺点

  • 优点：

    • 遵循开闭原则，方便扩展产品种类。
    • 将具体类的创建延迟到子类，避免了客户端与具体类的耦合。

  • 缺点：

    • 每增加一种产品类型，都需要增加对应的具体工厂类，可能导致类的数量增加。

1.5 适用场景

  • 客户端不需要知道所创建对象的具体类。
  • 需要创建一系列相关的产品类，而不希望客户端关心具体的实现细节。

二、抽象工厂模式（Abstract Factory Pattern）

2.1 模式简介

抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们的具体类。抽象工厂模式的核心思想是为产品族提供一个统一的创建接口，使得系统能够使用一系列的产品，而不必关心具体的产品类。

2.2 模式结构

抽象工厂模式主要包括：

  • 抽象工厂（Abstract Factory）：声明创建一系列产品的方法。
  • 具体工厂（Concrete Factory）：实现抽象工厂中的创建方法，负责具体产品的实例化。
  • 抽象产品（Abstract Product）：定义产品的接口或抽象类。
  • 具体产品（Concrete Product）：实现具体产品的类。

2.3 代码示例

// 抽象产品A
public interface ProductA {
    void doSomething();
}

// 抽象产品B
public interface ProductB {
    void doSomething();
}

// 具体产品A1
public class ConcreteProductA1 implements ProductA {
    @Override
    public void doSomething() {
        System.out.println("产品A1");
    }
}

// 具体产品B1
public class ConcreteProductB1 implements ProductB {
    @Override
    public void doSomething() {
        System.out.println("产品B1");
    }
}

// 抽象工厂
public interface AbstractFactory {
    ProductA createProductA();
    ProductB createProductB();
}

// 具体工厂1
public class ConcreteFactory1 implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ConcreteProductA1();
    }

    @Override
    public ProductB createProductB() {
        return new ConcreteProductB1();
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        AbstractFactory factory1 = new ConcreteFactory1();
        ProductA productA = factory1.createProductA();
        ProductB productB = factory1.createProductB();
        productA.doSomething();
        productB.doSomething();
    }
}

2.4 优缺点

  • 优点：

    • 分离了具体类的实现，客户端不需要了解产品的具体类。
    • 可以方便地扩展和更改产品族，符合开闭原则。

  • 缺点：

    • 如果需要增加新的产品族，所有的工厂类都需要修改，系统复杂度增加。

2.5 适用场景

  • 需要创建一系列相关或相互依赖的对象。
  • 系统不应该依赖产品的具体实现。

三、单例模式（Singleton Pattern）

3.1 模式简介

单例模式确保一个类只有一个实例，并提供全局访问点。它通过私有化构造函数，确保外部无法创建新实例，进而在类内部控制实例化过程。

3.2 模式结构

单例模式的主要参与者是：

  • 单例类（Singleton）：提供静态方法用于获取唯一的实例，并确保构造函数为私有。

3.3 代码示例

public class Singleton {
    private static Singleton instance;

    private Singleton() {}

    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

3.4 优缺点

  • 优点：

    • 只会生成一个实例，节省了资源。
    • 提供全局访问点，易于控制。

  • 缺点：

    • 多线程环境下需要加锁处理，可能影响性能。

3.5 适用场景

  • 需要确保某个类只有一个实例，如线程池、数据库连接池等。

四、建造者模式（Builder Pattern）

4.1 模式简介

建造者模式通过将对象的构建过程拆分为多个步骤，使得复杂对象的构建可以更加灵活。客户端通过指定每个步骤的实现来构建不同类型的对象。

4.2 模式结构

建造者模式的参与者包括：

  • 建造者（Builder）：定义构建产品的各个部分。
  • 具体建造者（Concrete Builder）：实现具体的构建步骤。
  • 指挥者（Director）：负责控制建造过程。
  • 产品（Product）：表示复杂对象。

4.3 代码示例

// 产品
public class Product {
    private String partA;
    private String partB;

    public void setPartA(String partA) {
        this.partA = partA;
    }

    public void setPartB(String partB) {
        this.partB = partB;
    }

    @Override
    public String toString() {
        return "Product [partA=" + partA + ", partB=" + partB + "]";
    }
}

// 抽象建造者
public interface Builder {
    void buildPartA();
    void buildPartB();
    Product getResult();
}

// 具体建造者
public class ConcreteBuilder implements Builder {
    private Product product = new Product();

    @Override
    public void buildPartA() {
        product.setPartA("构建 PartA");
    }

    @Override
    public void buildPartB() {
        product.setPartB("构建 PartB");
    }

    @Override
    public Product getResult() {
        return product;
    }
}

// 指挥者
public class Director {
    private Builder builder;

    public Director(Builder builder) {
        this.builder = builder;
    }

    public Product construct() {
        builder.buildPartA();
        builder.build
        builder.buildPartB();
        return builder.getResult();
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Builder builder = new ConcreteBuilder();
        Director director = new Director(builder);
        Product product = director.construct();
        System.out.println(product);
    }
}

4.4 优缺点

  • 优点：

    • 建造者模式将产品的构建过程与其表示相分离，使得相同的构建过程可以创建不同的表示。
    • 增加新的具体建造者不需要修改已有代码，符合开闭原则。

  • 缺点：

    • 可能导致系统变得复杂，特别是当产品具有很多细节的构建步骤时。

4.5 适用场景

  • 需要构建复杂对象，而该对象由多个部分组成，各部分的构建过程可能需要不同的实现。
  • 希望通过同一个构建过程生成不同的产品表示。

五、原型模式（Prototype Pattern）

5.1 模式简介

原型模式通过复制现有的对象来创建新对象，而不是通过实例化类来创建对象。它的核心思想是通过克隆方法实现对象的快速复制，尤其适用于创建代价较大的对象。

5.2 模式结构

原型模式的主要参与者包括：

  • 原型（Prototype）：定义一个接口，声明 clone() 方法，用于复制对象。
  • 具体原型（Concrete Prototype）：实现 clone() 方法，负责具体对象的复制。
  • 客户端（Client）：通过调用原型对象的 clone() 方法来创建新的对象。

5.3 代码示例

// 原型接口
public interface Prototype {
    Prototype clone();
}

// 具体原型
public class ConcretePrototype implements Prototype {
    private String field;

    public ConcretePrototype(String field) {
        this.field = field;
    }

    @Override
    public Prototype clone() {
        return new ConcretePrototype(this.field);
    }

    @Override
    public String toString() {
        return "ConcretePrototype{" +
                "field='" + field + '\'' +
                '}';
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        ConcretePrototype prototype1 = new ConcretePrototype("原型对象1");
        Prototype clonedPrototype = prototype1.clone();
        System.out.println(clonedPrototype);
    }
}

5.4 优缺点

  • 优点：

    • 克隆对象比直接创建对象更高效，特别是对于创建代价较高的对象。
    • 可以在运行时动态选择并创建符合要求的对象。

  • 缺点：

    • 如果对象中的属性含有复杂的嵌套对象，深度克隆的实现会变得复杂。
    • 需要对每个类都实现克隆方法，增加了系统复杂性。

5.5 适用场景

  • 创建对象的代价较高，或者需要通过复杂过程初始化对象。
  • 需要避免使用 new 关键字来直接创建对象。

六、总结

创造型设计模式通过提供一系列优雅的解决方案来简化对象的创建过程，帮助开发者从不同的角度解决复杂对象的构建问题。这些模式不仅减少了代码的重复和耦合，还使得系统在扩展时更加灵活。

模式名称主要作用适用场景
工厂方法模式定义一个用于创建对象的接口，让子类决定实例化哪一个类当需要将对象的创建与业务逻辑分离时使用
抽象工厂模式提供一个创建相关或相互依赖对象的接口当需要创建一系列相关对象或产品族时使用
单例模式确保一个类只有一个实例，并提供全局访问点当系统中某个类的实例必须唯一时使用，如线程池、数据库连接池
建造者模式将复杂对象的构建过程分步进行，使构建过程更加灵活当需要构建复杂对象，且构建过程可能有多种方式时使用
原型模式通过复制现有对象来创建新对象当创建对象的代价较高，或希望通过克隆快速创建对象时使用

通过合理使用创造型设计模式，开发者可以有效降低系统的耦合性，提高系统的可扩展性和维护性。在实际开发中，根据具体场景选择合适的模式是关键。

希望本文能帮助大家更好地理解和运用创造型设计模式，提高代码的设计能力和软件的质量。

一休哥助手
关注
23种设计模式详解
蜡笔小心的博客
03-16 780
设计模式是代码开发人员总结归纳出的代码设计经验，使用合理的设计模式能够提高代码的可拓展性和可维护性。 本文主要介绍了设计模式开山鼻祖经典书籍《Design Patterns》描写的23种设计模式，不过正如GoF所说“We don’t consider this collection of design patterns complete and static; it’s more a recording of our current thoughts on design.(我们并不认为这些设计模式是完整并.
【java总结】设计模式详解
Mankind的博客
04-03 2600
Java设计模式，是一套由前人总结的，被反复使用的代码设计经验。它为我们解决一些实际问题提供了一些很好的设计模板，了解设计模式，有利于提高我们的代码设计能力，架构能力，更有可能自己能够设计出适合业务的一套设计模式。接下来就让我们了解一下这些神秘的设计模式。 总的来说，设计模式可以分为以下几大类。 创建型模式：属于创建型模式的设计模式有单例模式，简单工厂模式，工厂方法模式，抽象工厂模式，原型模式
java23种设计模式详解
跟派大星学编程
04-17 446
一、设计模式分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。其实还有两类：并发型模式和线程池...
Java开发中的23种设计模式详解(转)
唐者荣耀的博客
09-05 277
设计模式（Design Patterns） ——可复用面向对象软件的基础 设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 毫无疑问，设计模式于己于他人于系统都是多赢的，设计模式使代码编制真正工程化...
Java经典设计模式之五大创建型模式（附实例和详解）
qq_66587374的博客
04-19 8022
一、概况总体来说设计模式分为三大类： （1）创建型模式，共五种： 一、Singleton，单例模式 ： 保证一个类只有一个实例，并提供一个访问它的全局访问点 二、Abstract Factory，抽象工厂：提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们的具体类 三、Factory Method，工厂方法：定义一个用于创建对象的接口，让子类决定实例化哪一个类，Factory Method使一个类的实例化延迟到了子类 四、Builder，建造模式：将一个...
Java设计模式学习总结
bcbobo21cn的专栏
03-10 1722
什么是设计模式？ 1。设计模式是对读者经常遇到的设计问题的可再现的解决方案(The Smalltalk Companion);  2。设计模式简历了一系列描述如何完成软件开发领域中特定任务的规则(Pree 1995);  3。设计模式更关注于复用可重复出现的结构设计方案，而框架注重于具体设计和实现(Coplien and Schmidt 1995);  4。模式提出了一个发生在特定
23种设计模式模式详解 Java UML类图小知识（一）
rickey17的博客
04-16 8035
23种设计模式模式详解 Java UML类图小知识（一）设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。 使用设计模式的好处：代码的可重用性、可扩展性，可阅读性，保证代码的可靠。（代码要优雅）关于相关源码可以在GitHub上下载： https://github.com/rickey17/design 设计模式的6大原则 设计模式分类 创
设计模式笔记
sunhaijingxiaohai的专栏
07-09 192
参考网上资料，站在巨人肩膀上总结提炼如下内容。 抽象类 抽象方法是一种特殊的方法：它只有声明，而没有具体的实现，抽象方法必须用abstract关键字进行修饰。如果一个类含有抽象方法，则称这个类为抽象类，抽象类必须在类前用abstract关键字修饰。因为抽象类中含有无具体实现的方法，所以不能用抽象类创建对象。同时抽象类中可以不含抽象方法。简言之：含抽象方法的类一定是抽象类，抽象类不一定含有抽象方法。 抽象类特点：1、abstrac 声明的类，不能被实例化。 2、抽象方法必须为public或者protec
详细整理全23种设计模式-创建型模式篇（java源码，优缺点解析，适用场景）
Koikoi12的博客
02-10 729
设计模式首先分成三类，这一篇主要讲创建型模式中的5种，创建型模式的作用就是为了产生实例对象，基于面向对象设计，将对象的创建与使用分离，降低系统的耦合度 单例模式 特点： 单例类只有一个实例对象，减少内存开销 该单例对象必须由单例类自行创建 单例类对外提供一个访问该单例的全局访问点 饿汉 public class HungrySingleton { // 创建私有静态实例，意味着这个类第一次使用的时候就会进行创建 private static final HungrySingleton ins
本人亲自整理的极客时间设计模式之美下部的硬核笔记（残缺版）最近加班太多，搞不了太多，只能尽量了xd们
菼执的博客
03-30 1352
设计模式之美（下） 这位猿，三连，再走吧！ 以下内容是为了让搜索引擎，检测到这篇文章。要阅读体验，请点击上面的连接“点击我”，去我的语雀看。对了，我看到语雀那里有投诉的功能，请读者不要去点。程序员不要为难程序员。你去点了，就再也无法看到我的笔记了。 创造型设计模式 创建型模式主要解决对象的创建问题，封装复杂的创建过程，解耦对象的创建代码和使用代码。 其中，单例模式用来创建全局唯一的对象。工厂模式用来创建不同但是相关类型的对象（继承同一父类或者接口的一组子类），由给定的参数来决定创建哪种类型的对象。
计算机设计大赛信息可视化设计的获奖经验剖析解读—基于本专栏文章助力4C大赛【全网最全万字攻略-获奖必读】
一键难忘的博客
12-14 3161
计算机设计大赛信息可视化设计的获奖经验剖析解读—基于本专栏文章助力4C大赛【全网最全万字攻略-获奖必读】 信息可视化设计包括以下小类：（1）信息图形设计。（2）动态信息影像（MG动画）。（3）交互信息设计。（4）数据可视化。
中兴面试总结，华为。技术，市场
peng10101010的专栏
10-11 6202
1，软件测试，如何把这个测试做的更好。 2，
人工智能与大数据时代-2019
热门推荐
anchker的博客
02-01 3万+
文章不断更新中..... 20191013 白皮书丨大数据产业发展呈现八大趋势 《2019中国大数据产业发展白皮书》深度解读之一 《2019中国大数据产业发展白皮书》深度解读之二 《2019中国大数据产业发展白皮书》深度解读之三 《2019中国大数据产业发展白皮书》深度解读之四 《2019中国大数据产业发展白皮书》深度解读之五 德勤&第四范式联合发布企业智能化转型白皮书 ...
LabVIEW提高开发效率技巧----调度器设计模式
bjcyck的博客
10-04 1321
在LabVIEW开发中，针对多任务并行的需求，使用调度器设计模式（Scheduler Pattern）可以有效地管理多个任务，确保它们根据优先级或时间间隔合理执行。这种模式在需要多任务并发执行时特别有用，尤其是在实时系统、数据采集、硬件控制等场景中。
设计模式、系统设计 record part04
最新发布
m0_47505062的博客
10-08 843
结构型。
设计模式-解释器模式
ZSS1753936255的博客
10-04 567
解释器模式描述了如何构成一个简单的语言解释器，主要应用在使用面向对象语言开发的编译器中。它描述了如何为简单的语言定义一个文法，如何在该语言中表示一个句子，以及如何解释这些句子。解释器模式（Interpreter）:给定一种语言，定义它的文法表示，并定义一个解释器，该解释器用来根据文法表示来解释语言中的句子。总结：了解即可，难度太大了。
设计模式-访问者模式
ZSS1753936255的博客
10-04 473
访问者模式（Visitor）:表示一个作用于某对象结构中的各元素的操作，使得在不改变个元素的类的前提下定义作用于这些元素的新操作。
设计模式——观察者模式
m0_66825548的博客
10-08 1261
定义对象间一种一对多的依赖关系，使得每当一个对象改变状态，则所有依赖于它的对象都会得到通知并被自动更新。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

一休哥助手

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

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

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

打赏作者

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

抵扣说明：

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

余额充值