正文

五大模型设计模式解析与应用攻略

/0 浏览量
0413

在软件设计中，设计模式是解决常见问题的可重用解决方案。它们可以帮助开发者构建更可维护、可扩展和可重用的代码。以下是对五大经典模型设计模式的解析及其应用攻略。

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

1.1 模型概述

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

1.2 应用技巧

  • 定义接口：创建一个创建对象的接口。
  • 实现子类：具体工厂类实现这个接口，并返回其创建的对象实例。
  • 客户端调用：客户端通过工厂接口请求对象，而不需要知道具体实现类。

1.3 代码示例

// 创建产品接口
interface Product {
    void operation();
}

// 具体产品A
class ConcreteProductA implements Product {
    public void operation() {
        System.out.println("操作A");
    }
}

// 具体产品B
class ConcreteProductB implements Product {
    public void operation() {
        System.out.println("操作B");
    }
}

// 工厂接口
interface Factory {
    Product createProduct();
}

// 具体工厂A
class ConcreteFactoryA implements Factory {
    public Product createProduct() {
        return new ConcreteProductA();
    }
}

// 具体工厂B
class ConcreteFactoryB implements Factory {
    public Product createProduct() {
        return new ConcreteProductB();
    }
}

// 客户端
public class Client {
    public static void main(String[] args) {
        Factory factoryA = new ConcreteFactoryA();
        Product productA = factoryA.createProduct();
        productA.operation();

        Factory factoryB = new ConcreteFactoryB();
        Product productB = factoryB.createProduct();
        productB.operation();
    }
}

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

2.1 模型概述

抽象工厂模式提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。

2.2 应用技巧

  • 定义抽象工厂：提供一个接口，用于创建相关对象的家族。
  • 实现具体工厂：具体工厂实现抽象工厂接口，创建具体的产品。
  • 客户端调用：客户端通过抽象工厂请求产品，无需知道具体产品类。

2.3 代码示例

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

// 具体产品A1
class ConcreteProductA1 implements ProductA {
    public void operation() {
        System.out.println("操作A1");
    }
}

// 抽象产品A2
interface ProductA2 {
    void operation();
}

// 具体产品A2
class ConcreteProductA2 implements ProductA2 {
    public void operation() {
        System.out.println("操作A2");
    }
}

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

// 具体产品B1
class ConcreteProductB1 implements ProductB {
    public void operation() {
        System.out.println("操作B1");
    }
}

// 具体产品B2
class ConcreteProductB2 implements ProductB {
    public void operation() {
        System.out.println("操作B2");
    }
}

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

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

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

// 具体工厂2
class ConcreteFactory2 implements AbstractFactory {
    public ProductA createProductA() {
        return new ConcreteProductA2();
    }

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

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

三、单例模式（Singleton）

3.1 模型概述

单例模式确保一个类只有一个实例，并提供一个全局访问点。

3.2 应用技巧

  • 私有构造函数：防止外部创建实例。
  • 静态实例变量：存储类的唯一实例。
  • 静态访问方法：提供全局访问点。

3.3 代码示例

public class Singleton {
    private static Singleton instance;

    private Singleton() {}

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

四、建造者模式（Builder）

4.1 模型概述

建造者模式将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

4.2 应用技巧

  • 抽象建造者：定义构建产品的接口。
  • 具体建造者：实现构建产品的具体步骤。
  • 指挥者：安排构建过程。

4.3 代码示例

// 产品类
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 + '\'' +
                '}';
    }
}

// 抽象建造者
abstract class Builder {
    public abstract void buildPartA();

    public abstract void buildPartB();

    public abstract Product getResult();
}

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

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

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

    public Product getResult() {
        return product;
    }
}

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

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

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

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

五、原型模式（Prototype）

5.1 模型概述

原型模式通过复制现有的实例来创建新的实例，而不是通过构造函数。

5.2 应用技巧

  • 实现克隆方法：定义一个克隆方法，用于复制对象。
  • 使用克隆方法创建新实例：通过克隆现有实例来创建新实例。

5.3 代码示例

class Prototype implements Cloneable {
    private String field;

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

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    public String getField() {
        return field;
    }

    public void setField(String field) {
        this.field = field;
    }
}

// 客户端
public class Client {
    public static void main(String[] args) throws CloneNotSupportedException {
        Prototype prototype = new Prototype("Original");
        Prototype clone = (Prototype) prototype.clone();
        clone.setField("Cloned");

        System.out.println(prototype.getField()); // 输出: Original
        System.out.println(clone.getField());     // 输出: Cloned
    }
}

以上是五大模型设计模式的解析与应用攻略。这些模式在软件设计中非常有用，可以帮助开发者构建更高质量的代码。

-- 展开阅读全文 --