1. 单例模式（Singleton Pattern）:
确保一个类只有一个实例，并提供一个全局访问点。
public class Singleton {
private static Singleton instance;
private Singleton() {
// 私有构造方法，防止外部实例化
}
public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}此外，还有使用枚举（Enum）的写法，一种简单而线程安全的方式
public enum SingletonEnum {
INSTANCE;
// 可以在枚举中定义其他成员变量和方法
// 例如:
// private int value;
// 枚举的构造方法默认是私有的，确保单例
private SingletonEnum() {
// 初始化操作
}
// 可以在枚举中定义其他方法
// 例如:
// public void doSomething() {
// // 实现方法逻辑
// }
}
// .... 使用方法
public class Main {
public static void main(String[] args) {
// 获取单例实例
SingletonEnum instance1 = SingletonEnum.INSTANCE;
SingletonEnum instance2 = SingletonEnum.INSTANCE;
// 验证是否为同一实例
System.out.println(instance1 == instance2); // 输出 true
}
}在这里，INSTANCE 是一个枚举类型的实例，它在加载时被初始化，并且由于枚举类型的特性，它确保了线程安全和单例实例的唯一性。这是一种简洁而安全的单例模式实现方式。
2. 抽象工厂模式（Abstract Factory Pattern）:
定义一个用于创建对象的接口，但由子类决定实例化哪个类。
// 抽象产品
interface Product {
void create();
}
// 具体产品
class ConcreteProductA implements Product {
public void create() {
System.out.println("Product A created");
}
}
class ConcreteProductB implements Product {
public void create() {
System.out.println("Product B created");
}
}
// 抽象工厂
interface Factory {
Product createProduct();
}
// 具体工厂
class ConcreteFactoryA implements Factory {
public Product createProduct() {
return new ConcreteProductA();
}
}
class ConcreteFactoryB implements Factory {
public Product createProduct() {
return new ConcreteProductB();
}
}3. 工厂方法模式（Factory Method Pattern）
// 抽象产品
interface Product {
void create();
}
// 具体产品 A
class ConcreteProductA implements Product {
public void create() {
System.out.println("Product A created");
}
}
// 具体产品 B
class ConcreteProductB implements Product {
public void create() {
System.out.println("Product B created");
}
}
// 工厂接口
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) {
// 通过具体工厂 A 创建产品 A
Factory factoryA = new ConcreteFactoryA();
Product productA = factoryA.createProduct();
productA.create();
// 通过具体工厂 B 创建产品 B
Factory factoryB = new ConcreteFactoryB();
Product productB = factoryB.createProduct();
productB.create();
}
}4. 简单工厂模式
简单工厂模式（Simple Factory Pattern）是工厂模式的一种简化形式。在简单工厂模式中，一个工厂类负责创建多个产品类的实例，客户端通过工厂类来创建所需的对象，而不直接实例化具体的产品类。下面是简单工厂模式的一个简单示例：
// 抽象产品
interface Product {
void create();
}
// 具体产品 A
class ConcreteProductA implements Product {
public void create() {
System.out.println("Product A created");
}
}
// 具体产品 B
class ConcreteProductB implements Product {
public void create() {
System.out.println("Product B created");
}
}
// 简单工厂类
class SimpleFactory {
public static Product createProduct(String type) {
if ("A".equals(type)) {
return new ConcreteProductA();
} else if ("B".equals(type)) {
return new ConcreteProductB();
} else {
throw new IllegalArgumentException("Invalid product type");
}
}
}
// 客户端代码
public class Client {
public static void main(String[] args) {
// 通过简单工厂创建产品 A
Product productA = SimpleFactory.createProduct("A");
productA.create();
// 通过简单工厂创建产品 B
Product productB = SimpleFactory.createProduct("B");
productB.create();
}
}5. 建造者模式
建造者模式是一种创建型设计模式，用于创建复杂对象。它允许你逐步构造一个对象，同时隐藏构建细节。这有助于将构造复杂对象的过程与其表示相分离，使得同样的构建过程可以创建不同的表示。
动机：Client（使用者）只想知道怎么用，但不想知道具体细节的情况。
建造者模式包含以下主要角色：
Director（指挥者）：负责构建复杂对象。Director 将具体的构建步骤委托给 Builder 接口来执行。
Builder（构建者）：定义构建复杂对象各个部分的接口，通常包括构建部件的方法和返回最终产品的方法。
ConcreteBuilder（具体构建者）：实现 Builder 接口，负责构建复杂对象的各个部分，并提供一个方法返回构建好的对象。
Product（产品）：表示被构建的复杂对象。通常包含多个部分。
下面是一个简单的示例，以创建一个包含不同属性的计算机为例：
// 产品类
class Computer {
private String cpu;
private String memory;
private String storage;
// 构造方法私有，防止直接实例化
private Computer() {
}
// Getter 方法...
// 静态内部类，负责构建 Computer 对象
static class ComputerBuilder {
private Computer computer = new Computer();
// 设置 CPU
ComputerBuilder setCpu(String cpu) {
computer.cpu = cpu;
return this;
}
// 设置内存
ComputerBuilder setMemory(String memory) {
computer.memory = memory;
return this;
}
// 设置存储
ComputerBuilder setStorage(String storage) {
computer.storage = storage;
return this;
}
// 构建最终的 Computer 对象
Computer build() {
return computer;
}
}
}
// 指挥者类
class Director {
// 指挥者通过 Builder 构建复杂对象
Computer construct(Computer.ComputerBuilder builder) {
return builder
.setCpu("Intel i7")
.setMemory("16GB")
.setStorage("512GB SSD")
.build();
}
}
public class BuilderPatternExample {
public static void main(String[] args) {
// 客户端通过指挥者来构建对象
Director director = new Director();
Computer.ComputerBuilder builder = new Computer.ComputerBuilder();
Computer computer = director.construct(builder);
// 客户端得到构建好的对象
System.out.println("Computer details: " + computer);
}
}在上述例子中，Computer 是产品类，Computer.ComputerBuilder 是具体构建者，Director 是指挥者。通过调用指挥者的 construct 方法，客户端可以得到一个构建好的 Computer 对象。建造者模式的主要优点是，客户端可以更加灵活地构建对象，可以选择性地设置属性，而不需要关心构建的具体细节。
在Lombok中，我们同样可以使用@Builder实现建造者模式。
