当前位置：首页 > article >正文

深入理解设计模式：工厂模式、单例模式

article 2025/6/28 23:58:42

深入理解设计模式：工厂模式、单例模式

设计模式是软件开发中解决常见问题的可复用方案。本文将详细介绍两种种重要的创建型设计模式：工厂模式、单例模式，并提供Java实现示例。

一、工厂模式

工厂模式是一种创建对象的设计模式，它提供了一种创建对象的最佳方式，而无需向客户端暴露创建逻辑。

1.1 简单工厂模式

简单工厂模式由一个工厂类负责创建所有产品。

// 产品接口
interface Product {void operation();
}// 具体产品A
class ConcreteProductA implements Product {@Overridepublic void operation() {System.out.println("ConcreteProductA operation");}
}// 具体产品B
class ConcreteProductB implements Product {@Overridepublic void operation() {System.out.println("ConcreteProductB operation");}
}// 简单工厂
class SimpleFactory {public static Product createProduct(String type) {if ("A".equals(type)) {return new ConcreteProductA();} else if ("B".equals(type)) {return new ConcreteProductB();}throw new IllegalArgumentException("Unknown product type");}
}// 客户端代码
public class Client {public static void main(String[] args) {Product productA = SimpleFactory.createProduct("A");productA.operation();Product productB = SimpleFactory.createProduct("B");productB.operation();}
}

1.2 工厂方法模式

工厂方法模式将实际创建对象的责任委托给子类。

// 产品接口
interface Product {void operation();
}// 具体产品A
class ConcreteProductA implements Product {@Overridepublic void operation() {System.out.println("ConcreteProductA operation");}
}// 具体产品B
class ConcreteProductB implements Product {@Overridepublic void operation() {System.out.println("ConcreteProductB operation");}
}// 工厂接口
interface Factory {Product createProduct();
}// 具体工厂A
class ConcreteFactoryA implements Factory {@Overridepublic Product createProduct() {return new ConcreteProductA();}
}// 具体工厂B
class ConcreteFactoryB implements Factory {@Overridepublic 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();}
}

1.3 抽象工厂模式

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

// 产品A接口
interface ProductA {void operationA();
}// 产品B接口
interface ProductB {void operationB();
}// 具体产品A1
class ConcreteProductA1 implements ProductA {@Overridepublic void operationA() {System.out.println("ConcreteProductA1 operationA");}
}// 具体产品A2
class ConcreteProductA2 implements ProductA {@Overridepublic void operationA() {System.out.println("ConcreteProductA2 operationA");}
}// 具体产品B1
class ConcreteProductB1 implements ProductB {@Overridepublic void operationB() {System.out.println("ConcreteProductB1 operationB");}
}// 具体产品B2
class ConcreteProductB2 implements ProductB {@Overridepublic void operationB() {System.out.println("ConcreteProductB2 operationB");}
}// 抽象工厂接口
interface AbstractFactory {ProductA createProductA();ProductB createProductB();
}// 具体工厂1
class ConcreteFactory1 implements AbstractFactory {@Overridepublic ProductA createProductA() {return new ConcreteProductA1();}@Overridepublic ProductB createProductB() {return new ConcreteProductB1();}
}// 具体工厂2
class ConcreteFactory2 implements AbstractFactory {@Overridepublic ProductA createProductA() {return new ConcreteProductA2();}@Overridepublic ProductB createProductB() {return new ConcreteProductB2();}
}// 客户端代码
public class Client {public static void main(String[] args) {AbstractFactory factory1 = new ConcreteFactory1();ProductA productA1 = factory1.createProductA();ProductB productB1 = factory1.createProductB();productA1.operationA();productB1.operationB();AbstractFactory factory2 = new ConcreteFactory2();ProductA productA2 = factory2.createProductA();ProductB productB2 = factory2.createProductB();productA2.operationA();productB2.operationB();}
}

1.4 工厂模式的优缺点

优点：

封装了对象的创建过程，客户端无需了解具体产品类
可以轻松添加新产品而不影响现有代码
遵循开闭原则

缺点：

引入了额外的类和接口，增加了系统复杂度
在某些情况下可能会增加系统的抽象程度和理解难度

1.5 适用场景

当一个类不知道它所需要创建的对象的类时
当一个类希望由子类来指定它所创建的对象时
当创建对象的过程涉及到复杂的业务逻辑时

二、单例模式

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

2.1 饿汉式单例

public class EagerSingleton {// 在类加载时就创建实例private static final EagerSingleton INSTANCE = new EagerSingleton();// 私有构造函数，防止外部实例化private EagerSingleton() {// 防止通过反射创建多个实例if (INSTANCE != null) {throw new IllegalStateException("Singleton already initialized");}}// 提供全局访问点public static EagerSingleton getInstance() {return INSTANCE;}// 示例方法public void doSomething() {System.out.println("Singleton is doing something");}
}

2.2 懒汉式单例（线程安全）

public class LazySingleton {// 初始不创建实例private static volatile LazySingleton instance;// 私有构造函数private LazySingleton() {// 防止通过反射创建多个实例if (instance != null) {throw new IllegalStateException("Singleton already initialized");}}// 提供全局访问点，使用双重检查锁定public static LazySingleton getInstance() {if (instance == null) {synchronized (LazySingleton.class) {if (instance == null) {instance = new LazySingleton();}}}return instance;}// 示例方法public void doSomething() {System.out.println("Singleton is doing something");}
}

2.3 枚举实现单例

public enum EnumSingleton {INSTANCE;// 示例方法public void doSomething() {System.out.println("Enum Singleton is doing something");}
}// 使用方式
public class Client {public static void main(String[] args) {EnumSingleton.INSTANCE.doSomething();}
}

2.4 静态内部类实现单例

public class StaticInnerSingleton {// 私有构造函数private StaticInnerSingleton() {}// 静态内部类持有单例实例private static class SingletonHolder {private static final StaticInnerSingleton INSTANCE = new StaticInnerSingleton();}// 提供全局访问点public static StaticInnerSingleton getInstance() {return SingletonHolder.INSTANCE;}// 示例方法public void doSomething() {System.out.println("Static inner class Singleton is doing something");}
}