RoastDuck

主题

创建型模式 ​

单例模式 ​

单例模式用来创建全局唯一的对象。一个类只允许创建一个对象（或者叫实例），那这个类就是一个单例类，这种设计模式就叫作单例模式。单例有几种经典的实现方式，它们分别是：饿汉式、懒汉式、双重检测、静态内部类、枚举。

java
// 饿汉式单例模式
// 饿汉式单例模式在类加载时就创建实例，确保实例在第一次使用前就已经创建。
public class Singleton {
    private static Singleton singleton = new Singleton();
    private Singleton(){}
    public static Singleton getInstance(){
        return singleton;
    }
}
// 双重检查锁定的懒汉式单例模式
// 懒汉式单例模式在第一次使用时才创建实例，常见的实现方式有线程不安全的懒汉式和线程安全的双重检查锁定懒汉式。
public class SynchronizedSingleton {
    //一个静态的实例
    private static SynchronizedSingleton synchronizedSingleton;
    //私有化构造函数
    private SynchronizedSingleton(){}
    //给出一个公共的静态方法返回一个单一实例
    public static SynchronizedSingleton getInstance(){
        if (synchronizedSingleton == null) {
            synchronized (SynchronizedSingleton.class) {
                if (synchronizedSingleton == null) {
                    synchronizedSingleton = new SynchronizedSingleton();
                }
            }
        }
        return synchronizedSingleton;
    }
}

工厂模式 ​

工厂模式包括简单工厂、工厂方法、抽象工厂这 3 种细分模式。其中，简单工厂和工厂方法比较常用，抽象工厂的应用场景比较特殊，所以很少用到，不是我们学习的重点。

简单工厂模式 ​

简单工厂模式通过一个工厂类来决定创建哪一种产品类的实例。它通常包含一个静态方法，根据传入的参数不同返回不同的对象实例。

特点：

  • 简单易懂，使用方便。
  • 扩展性差，新增产品需要修改工厂类代码，违反开闭原则。

示例代码：

java
public class SimpleFactory {
    public static Product createProduct(String type) {
        if (type.equals("A")) {
            return new ProductA();
        } else if (type.equals("B")) {
            return new ProductB();
        }
        return null;
    }
}

public interface Product {
    void use();
}

public class ProductA implements Product {
    public void use() {
        System.out.println("Using Product A");
    }
}

public class ProductB implements Product {
    public void use() {
        System.out.println("Using Product B");
    }
}

工厂方法模式 ​

工厂方法模式定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方法使一个类的实例化延迟到其子类。

特点：

  • 符合开闭原则，新增产品时无需修改现有代码。
  • 更符合单一职责原则，每个工厂类负责创建一种产品。
  • 增加了系统的复杂性，需要为每个产品创建一个工厂类。

示例代码：

java
public interface Factory {
    Product createProduct();
}

public class FactoryA implements Factory {
    public Product createProduct() {
        return new ProductA();
    }
}

public class FactoryB implements Factory {
    public Product createProduct() {
        return new ProductB();
    }
}

public interface Product {
    void use();
}

public class ProductA implements Product {
    public void use() {
        System.out.println("Using Product A");
    }
}

public class ProductB implements Product {
    public void use() {
        System.out.println("Using Product B");
    }
}

抽象工厂模式 ​

抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。它通常用于创建一组相关的产品。

特点：

  • 可以创建一系列相关的产品对象，保证产品的一致性。
  • 扩展产品族时非常困难，需要修改抽象工厂接口及其所有子类。
java
public interface AbstractFactory {
    ProductA createProductA();
    ProductB createProductB();
}

public class ConcreteFactory1 implements AbstractFactory {
    public ProductA createProductA() {
        return new ProductA1();
    }
    public ProductB createProductB() {
        return new ProductB1();
    }
}

public class ConcreteFactory2 implements AbstractFactory {
    public ProductA createProductA() {
        return new ProductA2();
    }
    public ProductB createProductB() {
        return new ProductB2();
    }
}

public interface ProductA {
    void use();
}

public interface ProductB {
    void use();
}

public class ProductA1 implements ProductA {
    public void use() {
        System.out.println("Using Product A1");
    }
}

public class ProductB1 implements ProductB {
    public void use() {
        System.out.println("Using Product B1");
    }
}

public class ProductA2 implements ProductA {
    public void use() {
        System.out.println("Using Product A2");
    }
}

public class ProductB2 implements ProductB {
    public void use() {
        System.out.println("Using Product B2");
    }
}

原型模式 ​

原型模式是一种创建型设计模式，它允许你通过复制现有对象来创建新对象，而不是通过实例化类。原型模式使用原型实例指定创建对象的种类，并通过拷贝这些原型创建新的对象。

  • 主要角色
  1. Prototype：定义一个接口，用于克隆自身。
  2. ConcretePrototype：实现Prototype接口，克隆自身。
  3. Client：通过调用原型对象的克隆方法来创建新的对象。
java
// 原型接口
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 prototype = new ConcretePrototype("Prototype Field");
        ConcretePrototype clone = (ConcretePrototype) prototype.clone();
        System.out.println(clone);
    }
}

建造者模式 ​

建造者模式是一种创建型设计模式，它允许你一步一步地构建复杂对象。与其他创建型模式不同，建造者模式关注于通过一个构建过程来创建对象，而不是通过继承或工厂方法。

  • 主要角色
  1. Builder：定义构建产品的抽象接口。
  2. ConcreteBuilder：实现Builder接口，构建和装配各个部件。
  3. Director：构建一个使用Builder接口的对象。
  4. Product：表示被构建的复杂对象。
  • 示例代码
java
// 产品类
public class Product {
    private String partA;
    private String partB;
    private String partC;

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

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

    public void setPartC(String partC) {
        this.partC = partC;
    }

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

// 抽象建造者
public abstract class Builder {
    protected Product product = new Product();

    public abstract void buildPartA();
    public abstract void buildPartB();
    public abstract void buildPartC();

    public Product getResult() {
        return product;
    }
}

// 具体建造者
public class ConcreteBuilder extends Builder {
    public void buildPartA() {
        product.setPartA("Part A");
    }

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

    public void buildPartC() {
        product.setPartC("Part C");
    }
}

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

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

    public Product construct() {
        builder.buildPartA();
        builder.buildPartB();
        builder.buildPartC();
        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);
    }
}

如有转载或 CV 的请标注本站原文地址

Copyright © 2024-present RoastDuck