• 23种设计模式之创建型模式篇

    一、创建型模式

    这类模式主要关注对象的创建过程。它们试图在创建对象的同时，将对象的创建和使用分离，以达到更高的灵活性和可扩展性.

    包括:
    • 工厂方法模式（Factory Method）
    • 抽象工厂模式（Abstract Factory）
    • 单例模式（Singleton）
    • 建造者模式（Builder）
    • 原型模式（Prototype）
    1、工厂方法模式(Factory Method)
    1.1.代码实现
    //操作步骤一:定义一个动物类接口
public interface Animal {
    void speak();
}

//操作步骤二:Cat实现动物类接口
public class Cat implements Animal {
    @Override
    public void speak() {
        System.out.println("我是cat类,喵喵喵");
    }
}

//操作步骤二:Dog实现动物类接口
public class Dog implements Animal {
    @Override
    public void speak() {
        System.out.println("我是dog类,汪汪汪");
    }
}


//操作步骤三:工厂类
public class AnimalFactory {

    /**
     * 创建一个动物,根据类型创建
     * */
    public static Animal createAnimal(String type){
        if (type.equalsIgnoreCase("dog")) {
            return new Dog();
        } else if (type.equalsIgnoreCase("cat")) {
            return new Cat();
        } else {
            throw new IllegalArgumentException("Invalid animal type");
        }
    }

}

//代码测试
public class FactoryTest {
    /**
     * 1.定义了一个Animal接口和两个实现该接口的类Dog和Cat。
     * 2.创建了一个工厂类AnimalFactory，它有一个静态方法createAnimal，该方法根据传入的类型参数来创建相应的					动物对象。
     * 3.在客户端代码中，我们使用工厂类来创建不同的动物对象并调用它们的speak方法。
     *
     * 这个例子展示了工厂模式的基本用法，通过工厂类来创建对象，而不是直接使用构造函数。
     * 这样做的好处是可以将对象的创建逻辑与使用逻辑分离，使得代码更加灵活和可维护。
     * */
    public static void main(String[] args) {
        Animal cat = AnimalFactory.createAnimal("cat");
        cat.speak();        //创建一个cat类


        Animal dog = AnimalFactory.createAnimal("dog");
        dog.speak();
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    1.2.概念总结
    1.2.1.工厂模式主要有以下几种类型:

    1.简单工厂模式2.工厂方法模式 3.抽象工厂模式

    1.2.2.使用场景：

    1. 创建复杂对象：如果一个对象的创建过程非常复杂，需要很多步骤，工厂模式可以将这些步骤封装在工厂类中，简化客户端代码。

    2. 对象类型动态决定：如果需要在运行时根据不同的情况创建不同的对象，可以使用工厂模式。例如，根据用户输入的信息创建不同类型的图形对象。

    3. 依赖注入：在依赖注入的应用中，工厂模式可以用来创建所需的依赖对象，并将其注入到目标对象中。

    4. 多数据库支持：如果应用需要支持多种数据库，可以使用工厂模式来创建对应的数据库连接对象。

    5. 工具类创建：如果一个类无法轻易通过new直接创建（例如，由于某些原因需要隐藏其构造函数），可以提供一个静态工厂方法来创建该类的实例。

    6. 遵循开闭原则：工厂模式允许系统在不修改现有代码的情况下引入新的产品类，这有助于保持系统的灵活性和可扩展性。

    7. 配置文件加载：在读取配置文件并根据配置信息创建相应对象时，工厂模式非常有用。

    8. 多平台或多环境支持：针对不同的平台或环境可能需要创建不同的对象，工厂模式可以根据环境变量或平台特性来决定实例化哪个类。

    9. 游戏开发中的实体生成：在游戏开发中，不同的游戏实体（如角色、道具、敌人等）可以通过工厂模式来创建，便于管理和扩展。

    10.框架和库的开发：在设计框架或库时，为了提供灵活的扩展点，通常会使用工厂模式来创建关键组件。

    总体来说，工厂模式适用于那些对象创建过程复杂、需要隔离创建和使用、或者需要对创建过程进行集中管理的场景。
    通过使用工厂模式，可以提高代码的模块化和可维护性，同时减少出错的可能性。

    2、单例模式(Singleton)
    2.1.代码实现
    /**
 * @author ：jerry
 * @date ：Created in 2024/4/19 13:50
 * @description：枚举实现单利模式
 * @version: V1.1
 */
public enum SingletonEnum {
    INSTANCE;

    // 在枚举中定义实例变量和方法
    private String name;

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    //代码测试
    public static void main(String[] args) {
        // 获取单例对象并设置名称
        SingletonEnum singleton = SingletonEnum.INSTANCE;
        singleton.setName("Singleton");

        // 输出单例对象的名称
        System.out.println(singleton.getName());
    }
}

/**
 * @author ：jerry
 * @date ：Created in 2024/4/19 13:59
 * @description：饿汉式（线程安全）：
 * @version: V1.1
 */
public class EagerSingleton {
  	//类加载时就创建实例
    private static final EagerSingleton instance = new EagerSingleton();

    private EagerSingleton() {}

    public static EagerSingleton getInstance() {
        return instance;
    }

    public static void main(String[] args) {
        // 获取单例对象
        EagerSingleton instanceObj = EagerSingleton.getInstance();
        System.out.println("其他操作");
    }
}


/**
 * @author ：jerry
 * @date ：Created in 2024/4/19 13:59
 * @description：懒汉式（线程不安全）：
 * @version: V1.1
 */
public class LazySingleton {
    private static LazySingleton instance;

    private LazySingleton() {}

    public static LazySingleton getInstance() {
      //第一次使用时创建实例，实现了延迟加载
        if (instance == null) {
            instance = new LazySingleton();
        }
        return instance;
    }

    public static void main(String[] args) {
        LazySingleton instanceObj = LazySingleton.getInstance();
        System.out.println("其他操作");
    }
}


/**
 * @author ：jerry
 * @date ：Created in 2024/4/19 14:16
 * @description：双重检查锁定
 * @version: V1.1
 */
public class SingletonDouble {

    private static volatile SingletonDouble instance;

    private SingletonDouble() {
    }

    public static SingletonDouble getInstance() {
        if (instance == null) {
            synchronized (SingletonDouble.class) {
                if (instance == null) {
                    instance = new SingletonDouble();
                }
            }
        }
        return instance;
    }
  
    public static void main(String[] args) {
        SingletonDouble instance = SingletonDouble.getInstance();
        System.out.println("其他业务代码");
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    2.2.概念总结

    单例模式是一种常用的软件设计模式，它确保一个类只有一个实例，并提供该实例的全局访问点。

    2.2.1.概念

    单例模式的核心思想是控制对象的创建，确保一个类在任何情况下都只有一个实例存在。这个唯一的实例可以通过特定的方法在整个应用程序中被访问。

    2.2.2.优点

    单例模式可以节省系统资源，对于频繁使用的对象，避免多次创建和销毁；同时，它还提供了一个对资源的受控访问点，比如配置文件、线程池或数据库连接等。

    2.2.3.实现方式：
    • 饿汉式：在类加载时就创建实例，可能导致资源浪费，但简单且能保证线程安全。
    • 懒汉式：在第一次使用时创建实例，实现了延迟加载，但需要考虑线程安全问题。
    • 双重检查锁定：结合了懒汉式的延迟加载和线程安全的优点，通过同步锁和两次检查来确保只创建一个实例。
    • 静态内部类：利用类加载机制保证初始化实例时的线程安全和懒加载。
    • 枚举：通过枚举类型实现单例，自动支持序列化机制，绝对防止多次实例化。
    • C++11 std::call_once：提供了一次性调用的功能，确保某个函数只被执行一次，适用于C++中的单例实现。
    2.2.4.问题和注意事项：
    • 线程安全：在多线程环境下，需要确保单例的创建不会发生并发问题。
    • 延迟加载：在某些实现中，单例的实例是在第一次使用时才创建的，这可以减少程序启动时的资源消耗。
    • 反序列化：在Java中，单例对象在序列化和反序列化过程中可能会被破坏，需要注意避免这种情况的发生。

    总的来说，单例模式适用于那些需要频繁使用且不需要多个实例的场景，如配置管理、日志记录、驱动程序对象等。它可以减少系统开销，但同时也需要注意其可能带来的问题，如内存泄漏和过度使用导致的代码耦合。在实际使用中，应根据具体情况选择合适的实现方法，并注意单例的生命周期管理和访问控制。

    3、抽象工厂模式（Abstract Factory）
    3.1.代码实现
    //操作步骤一:抽象工厂
public interface AbstractFactory {
    ProductA createProductA();
    ProductB createProductB();
}

//操作步骤二:抽象产品A
public interface ProductA {
    void operationA();
}

//操作步骤三:抽象产品B
public interface ProductB {
    void operationB();
}

//操作步骤四:具体产品A1
public class ConcreteProductA1 implements ProductA {

    @Override
    public void operationA() {
        System.out.println("ConcreteProductA1 operationA");
    }
}
//操作步骤四:具体产品A2
public class ConcreteProductA2 implements ProductA {
    @Override
    public void operationA() {
        System.out.println("ConcreteProductA2 operationA");
    }
}
//操作步骤四:具体产品B1
public class ConcreteProductB1 implements ProductB {
    @Override
    public void operationB() {
        System.out.println("ConcreteProductB1 operationB");
    }
}
//操作步骤四:具体产品B2
public class ConcreteProductB2 implements ProductB {
    @Override
    public void operationB() {
        System.out.println("ConcreteProductB2 operationB");
    }
}
//操作步骤五:具体工厂1
public class ConcreteFactory1 implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ConcreteProductA1();
    }

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

//操作步骤五:具体工厂2
public class ConcreteFactory2 implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ConcreteProductA2();
    }

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

public class AbstractFactoryTest {
    /**
     *1.ProductA和ProductB是抽象产品接口，分别定义了各自的操作方法。
     * ConcreteProductA1、ConcreteProductA2、ConcreteProductB1和
     		ConcreteProductB2是具体的产品类，实现了相应的抽象产品接口。
     * 2.AbstractFactory是抽象工厂接口，定义了创建产品的方法。ConcreteFactory1和
     		ConcreteFactory2是具体的工厂类，实现了抽象工厂接口，并返回相应的具体产品对象。
     		
     * 在客户端代码中，通过调用不同的工厂对象的创建方法来获取不同类型的产品对象，并执行相应的操作
     * */
    public static void main(String[] args) {
        AbstractFactory factory1 = new ConcreteFactory1();
        ProductA productA1 = factory1.createProductA();
        ProductB productB1 = factory1.createProductB();
        productA1.operationA(); // 输出：ConcreteProductA1 operationA
        productB1.operationB(); // 输出：ConcreteProductB1 operationB

        AbstractFactory factory2 = new ConcreteFactory2();
        ProductA productA2 = factory2.createProductA();
        ProductB productB2 = factory2.createProductB();
        productA2.operationA(); // 输出：ConcreteProductA2 operationA
        productB2.operationB(); // 输出：ConcreteProductB2 operationB
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    3.2.概念总结

    抽象工厂模式是一种创建型设计模式，用于创建一系列相关或相互依赖的对象，而无需指定它们具体的类。

    3.2.1.这种模式通常用于以下几种情况：
    • 产品族和产品等级结构：当需要创建多个产品族的产品时，每个产品族都有其自身的等级结构。
    • 跨产品族的共享约束：如果不同产品族之间存在一些共同的约束或配置，可以使用抽象工厂来简化这些约束的管理。
    • 产品的复杂创建过程：如果产品的创建过程涉及到多个步骤或者需要多个组件，抽象工厂可以帮助将这个过程封装起来，使得客户端代码不需要知道具体的创建细节。

    在实际应用中，抽象工厂模式可以帮助我们实现高度模块化和可扩展的设计，例如在开发家具商店模拟器时，可以通过抽象工厂模式来创建不同类型的家具产品，如椅子、桌子等，而无需在客户端代码中指定具体的产品类型。

    4、建造者模式（Builder）
    4.1.代码实现
    //操作步骤一:抽象建造者角色
public interface Builder {
    void buildPartA();

    void buildPartB();
}

//操作步骤二:产品角色
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;
    }

    public void show() {
        System.out.println("PartA: " + partA + ", PartB: " + partB);
    }
}

//操作步骤三:指挥者角色
public class Director {
    private Builder builder;

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

    public void construct() {
        builder.buildPartA();
        builder.buildPartB();
    }

    public Product getResult() {
        return ((ConcreteBuilder) builder).getResult();
    }
}

//操作步骤四:具体建造者角色
public class ConcreteBuilder implements Builder {
    private Product product = new Product();

    public void buildPartA() {
        product.setPartA("Part A");
    }

    public void buildPartB() {
        product.setPartB("Part B");
    }

    public Product getResult() {
        return product;
    }
}

//测试代码
public class BuilderTest {
    /**
     *Product类代表了要创建的复杂对象，Builder接口定义了构建产品各个部分的抽象接口，
     * ConcreteBuilder类实现了Builder接口并完成了产品的各个部分的构建
     * ，而Director类则负责指挥ConcreteBuilder进行产品的构建。
     *
     *
     * 客户端代码通过创建ConcreteBuilder和Director对象，并调用指挥者的construct方法来构建最终的产品。
     * */
    public static void main(String[] args) {
        Builder builder = new ConcreteBuilder();
        Director director = new Director(builder);
        director.construct();
        Product product = director.getResult();
        product.show();
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    4.2.概念总结

    建造者模式（Builder）是一种对象创建型设计模式，旨在将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

    4.2.1.建造者模式的关键角色和组件包括：
    • 产品（Product）：表示要创建的复杂对象。
    • 抽象建造者（Builder）：定义创建产品各个部分的抽象接口。
    • 具体建造者（ConcreteBuilder）：实现抽象建造者接口，完成产品的各个部分的构建。
    • 指挥者（Director）：负责构建产品的对象，指挥具体建造者进行产品的构建。
    5、原型模式（Prototype）
    5.1.代码实现
    //操作步骤一:定义一个抽象原型类
public class Prototype implements Cloneable {

    private String value;

    public Prototype(String value) {
        this.value = value;
    }

    // 覆盖clone方法
    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }
}
 
//测试代码
public class PrototypeTest {
    /**
     * Prototype类实现了Cloneable接口并覆盖了clone()方法。
     *
     * 在main方法中，我们创建了一个原始对象，并通过调用clone()方法得到了一个复制的对象。这样我们就实现了原型模式。
     * */
    public static void main(String[] args) throws CloneNotSupportedException {
        Prototype prototype1 = new Prototype("Tom");
        Prototype prototype2 = (Prototype) prototype1.clone();

        System.out.println("prototype1: " + prototype1.getValue());
        System.out.println("prototype2: " + prototype2.getValue());
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    5.2.概念总结

    原型模式是一种创建型设计模式，用于通过复制现有的实例来创建新的对象，而不是通过调用构造函数来新建对象。

    原型模式的关键在于利用已有的实例作为模板来创建新的实例，这样可以在不知晓具体类的情况下生成新对象。这种模式适用于那些创建成本高或者需要重复使用相似对象的场合。以下是原型模式的一些关键点：

    • 结构与实现：原型模式通常涉及到一个原型接口，该接口定义了克隆自身的方法。具体的原型类实现这个接口，并提供深克隆和浅克隆两种实现方式。
    • 深克隆与浅克隆：深克隆会复制对象以及所有嵌套引用的对象，而浅克隆只复制对象本身和它的引用，不复制引用的对象。两者的选择取决于具体的应用场景。
    • 优缺点：原型模式的优点在于可以在运行时动态地创建对象，不需要知道具体的类名。同时，它还能保持原有对象的状态，使得复制更为便捷。然而，其主要缺点是每个子类都需要实现克隆方法，这可能导致代码的复杂性增加。
    • 使用场景：当直接创建对象的成本比复制一个已有对象更高时，或者当希望获得对一个复杂对象的独立副本时，原型模式是一个很好的选择。例如，在使用像Photoshop这样的图形编辑软件时，用户可以通过复制图层来重用和修改图像部分，而不需要从头开始创建新图层。

    综上所述，原型模式提供了一种灵活且高效的方式来创建对象，尤其适合那些对象创建成本较高或者需要避免与原始对象共享状态的场景。在实际应用中，根据具体需求选择合适的克隆方法（深克隆或浅克隆）是实现原型模式的关键。

  • 相关阅读:
    【C语言】位操作符详解
    C++ 火车调度
    Qt QTableView排序
    SVN服务数据迁移（windows）
    wires hark抓包内容解析
    php警车管理系统设计与实现
    VPX 插座（VITA46）介绍及应用 (简单介绍)
    如何报考产品总监认证（UCPD）？
    (ubuntu) 安装JDK
    HFSS端口介绍2---波端口
  • 原文地址：https://blog.csdn.net/qq_40068304/article/details/137982178