软件设计模式

杰克jk船长

已于 2023-11-13 09:39:01 修改

阅读量54

点赞数

分类专栏：软件设计文章标签：设计模式

于 2023-11-13 01:08:09 首次发布

本文链接：https://blog.csdn.net/qq_40133628/article/details/134368583

版权

软件设计专栏收录该内容

2 篇文章 0 订阅

订阅专栏

软件设计模式

1. 设计模式定义
2. 创建型模式
3. 结构性模式
4. 行为型模式
参考资料

1. 设计模式定义

1.1 什么是设计模式

在 GoF（Gang of Four）的书籍《设计模式-可复用面向对象软件的基础》中是这样定义设计模式的：“每一个模式描述了一个在我们周围不断重复发生的问题以及该问题的解决方案的核心。这样，你就能一次又一次地使用该方案而不必做重复劳动”。

一般而言，设计模式有四个基本要素：

模式名称（pattern name）：一个助记名，它用一两个词来描述模式的问题、解决方案和效果。
问题（problem）：描述了应该在何时使用模式。
解决方案（solution）：描述了设计的组成成分，它们之间的相关关系以及各自的职责和协作方案。
效果（consequences）：描述了模式应用的效果以及使用模式应该权衡的问题。

1.2 设计原则与设计模式

设计原则和设计模式的关系：

设计原则是指导思想，往往是高度概括性和原则性的；设计模式是实现方式，并且往往并非一种实现方式。
设计原则由设计模式共同遵守，一种设计模式往往采用多种设计原则。

1.3 设计原则分类

1.3.1 根据目的来分

创建型模式：抽象了对象的实例化过程，将对象的创建和使用分离。
- 单例模式、工厂方法模式、抽象工厂模式、建造者模式、原型模式
结构型模式：处理类或对象的组合，实现新功能。
- 适配器模式、桥接模式、组合模式、装饰器模式、外观模式、享元模式、代理模式
行为型模式：算法和对象间职责的分配，关注对象间的联系方式。
- 责任链模式、命令模式、解释器模式、迭代器模式、中介者模式、备忘录模式、观察者模式、状态模式、策略模式、模板方法模式、访问者模式

2. 创建型模式

2.1 单例模式（Singleton）

2.1.1 定义

保证一个类仅有一个实例，并提供一个访问它的全局访问点。

单例模式主要解决两个问题：

保证一个类仅有一个实例：
- 作用：（1）防止重复创建导致的资源浪费（2）防止多个实例导致的数据同步问题
- 使用：控制某些共享资源（例如数据库或文件）的访问权限等
- 实现：private 修饰构造函数，在类中创建对象
为该实例提供一个全局访问节点：
- 作用：防止实例数据被覆盖
- 实现：提供全局访问方法

2.1.2 实现

单例模式结构

饿汉式-线程安全

public class Singleton {

    private static Singleton instance = new Singleton();

    private Singleton() {}

    public static Singleton getInstance() {
        return instance;
    }
}

懒汉式-线程不安全

public class Singleton {

    private static Singleton instance;

    private Singleton() {}

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

懒汉式-线程安全

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

懒汉式-双重校验锁-线程安全

public class Singleton {

    private static volatile Singleton instance; // volatile 防止JVM对指令进行重排

    private Singleton() {}

    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) { // 防止两个线程都在第一个if判断instance为null，先后进入锁创建实例
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

静态内部类

使用内部类的好处是，静态内部类不会在单例加载时就加载，而是在调用 getInstance() 方法时才进行加载，而且由 JVM 提供了对线程安全的支持。

public class Singleton {

    private Singleton() {
    }

    private static class SingletonHolder {
        private static Singleton instance = new Singleton();
    }

    public static Singleton getInstance() {
        return SingletonHolder.instance;
    }
}

枚举实现

单例模式的最佳实现，能保证只有一个实例且线程安全，并且在面对复杂的序列化或者反射攻击的时候，能够防止实例化多次，唯一缺点是无法适用继承场景。

public enum Singleton {
    instance;
}

2.2 工厂方法模式（Factory Method）

2.2.1 定义

定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory Method 使一个类的实例化延迟到其子类。

2.2.2 实现

2.3 抽象工厂模式（Abstract Factory）

2.3.1 定义

提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

2.3.2 实现

2.4 建造者模式（Builder）

2.4.1 定义

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

2.4.2 实现

以下是一个简易的 StringBuilder 实现，参考了 JDK 1.8 源码。

abstract class AbstractStringBuilder {
    char[] value;
    int count;
    
    AbstractStringBuilder() {
    }

    AbstractStringBuilder(int capacity) {
        value = new char[capacity];
    }
    
    public AbstractStringBuilder append(char c) {
        ensureCapacityInternal(count + 1);
        value[count++] = c;
        return this;
    }
    
    private void ensureCapacityInternal(int minimumCapacity) {
        // overflow-conscious code
        if (minimumCapacity - value.length > 0) {
            value = Arrays.copyOf(value,
                    newCapacity(minimumCapacity));
        }
    }
    
    private int expandCapacity(int minCapacity) {
        int newCapacity = value.length * 2 + 2;
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity <= 0 || MAX_ARRAY_SIZE - newCapacity < 0) {
            if (Integer.MAX_VALUE - minCapacity < 0) // overflow
                throw new OutOfMemoryError();
            newCapacity = (minCapacity > MAX_ARRAY_SIZE) ? minCapacity : MAX_ARRAY_SIZE;
        }
		return newCapacity;
    }
    
    public abstract String toString();
}

public final class StringBuilder extends AbstractStringBuilder {
    public StringBuilder() {
        super(16);
    }
    
    @Override
    public StringBuilder append(char c) {
        super.append(c);
        return this;
    }
    
	@Override
    public String toString() {
        // Create a copy, don't share the array
        return new String(value, 0, count);
    }
}