15.Java设计模式-23/05/08-CSDN博客

本文链接：https://blog.csdn.net/LB_bei/article/details/130558630

本文介绍了设计模式中的创建型模式，包括单例模式（懒汉式、饿汉式）、工厂模式（简单工厂、工厂方法、抽象工厂），以及建造者模式。此外，还提及了结构型模式中的代理模式，行为型模式中的观察者模式。这些模式在软件设计中用于创建对象、组合对象以及管理对象间的交互，提高了代码的可复用性和可维护性。

摘要由CSDN通过智能技术生成

一、创建型模式：

用于创建对象的模式，包括单例模式、工厂模式、抽象工厂模式、建造者模式、原型模式等。

1.单列模式

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

将默认构造函数设置为私有，新建一个共有静态构建方法作为构造函数，该方法会在最初调用构造函数创建对象，并将该对象保存在一个静态成员变量中，此后所有对于该函数的调用都将返回这一缓存对象

注意：单例模式违反了单一职责原则，多线程下需要特殊处理

1.1懒汉式

在第一次使用时才创建实例，线程不安全

public class Singleton {
    private static Singleton instance;
    //定义一个私有的静态的类型为自己本身的变量
    private Singleton() {
        // 私有构造函数，防止外部创建实例
    }
    //定义公共静态返回值为自己本身类型的方法
    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

由于懒汉式单例模式在多线程环境下可能存在线程安全问题，因此我们在 getInstance 方法上添加了 synchronized 关键字来保证线程安全。

/**synchronized是Java中的一个关键字，用于实现同步机制，可以用于修饰方法和代码块。*/

1.2饿汉式

在类加载时就创建实例，线程安全，但是，如果应用程序从未使用 Singleton 实例，那么就会浪费内存，因为在 JVM 加载 Singleton 类时就会创建实例。

public class Singleton {
    //定义一个私有的静态的最终的类型为自己本身的变量并且初始化 
    private static final Singleton instance = new Singleton();
    // 私有构造函数，防止外部创建实例
    private Singleton() {}
    //定义公共静态返回值为自己本身类型
    public static Singleton getInstance() {
        return instance;
    }
}

懒汉式单例模式在第一次调用时创建实例，因此如果该实例的创建需要耗费大量时间或者资源，那么应该考虑使用饿汉式单例模式。

2.工厂设计模式

提供了一种创建对象的方式，而不需要在代码中直接实例化对象。它通常包括一个抽象工厂类和一个或多个实现工厂类，用于创建一组相关的对象。

能降低代码的耦合度

2.1简单工厂模式（Simple Factory Pattern）

创建一个工厂类，根据传入的类型，创建不同的类并返回。

简单工厂模式又叫静态工厂模式。

实现：

1.把创建对象抽象成一个类

2.创建工厂类，在工厂类中创建静态方法，根据方法参数确定创建对象

缺点：当程序新增类或修改某个类，需要修改程序源代码，违反了开闭原则。

// 简单工厂类，负责创建各种类型的产品
public class SimpleFactory {
    public static Product createProduct(String type) {
        if (type.equals("A")) {
            return new ConcreteProductA();
        } else if (type.equals("B")) {
            return new ConcreteProductB();
        } else {
            return null;
        }
    }
}
// 产品接口，定义产品的共同行为
public interface Product {
    void operation();
}
// 具体产品A
public class ConcreteProductA implements Product {
    @Override
    public void operation() {
        System.out.println("This is ConcreteProductA");
    }
}

2.2工厂方法模式（Factory Method Pattern）

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

实现：

1.把工厂类抽象成接口

2.创建不同工厂实现类实现接口

// 工厂接口，定义创建产品的方法
public interface Factory {
    Product createProduct();
}
// 具体工厂A，实现创建产品A的方法
public class ConcreteFactoryA implements Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductA();
    }
}
// 测试类
public class FactoryMethodTest {
    public static void main(String[] args) {
        Factory factoryA = new ConcreteFactoryA();
        Product productA = factoryA.createProduct();
        productA.operation(); // 输出：This is ConcreteProductA
    }
}

2.3抽象工厂模式（Abstract Factory Pattern）

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

2.4利用简单工厂设计模式，实现创建任意类型的工厂类

这种方式比起之前的简单工厂模式的实现，更加灵活，可以创建任意类型的对象，不需要在工厂类中添加新的方法。同时，也避免了直接使用 new 来创建对象时，需要知道具体类名的问题。

/**
 *     实现创建任意类型的工厂类
 */
public class FactoryBean { /**BeanFactory和faCtoryBean*/
    public static <T> T getBean(Class<T> clazz) {
        try {
            return clazz.newInstance(); //创建指定类型的对象
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}