1. 单例模式（Singleton Pattern）
核心思想：确保一个类在整个应用中只有一个实例，并提供全局唯一的访问入口。
常用实现方式
方式 1：饿汉式（线程安全，饿加载）
加载类时就初始化实例，优点是简单、线程安全；缺点是可能造成资源浪费（即使没用到也会初始化）。
java运行/** * 饿汉式单例模式 */public class HungrySingleton { // 1. 私有静态常量：类加载时就初始化唯一实例 private static final HungrySingleton INSTANCE = new HungrySingleton(); // 2. 私有构造方法：禁止外部通过new创建实例 privateHungrySingleton() {} // 3. 公共静态方法：提供全局访问入口 publicstatic HungrySingleton getInstance() { return INSTANCE; } // 测试方法 publicvoidsayHello() { System.out.println("饿汉式单例：Hello Singleton!"); } // 测试 publicstaticvoidmain(String[] args) { HungrySingleton instance1 = HungrySingleton.getInstance(); HungrySingleton instance2 = HungrySingleton.getInstance(); // 输出true，证明是同一个实例 System.out.println(instance1 == instance2); instance1.sayHello(); }}
方式 2：懒汉式（双重检查锁，线程安全 + 懒加载）
只有首次调用getInstance()时才初始化实例，兼顾性能和线程安全，是工业级常用写法。
java运行/** * 懒汉式单例（双重检查锁） */public class LazySingleton { // 1. 私有静态变量：volatile防止指令重排，保证实例初始化完成后再被访问 private static volatile LazySingleton INSTANCE; // 2. 私有构造方法 privateLazySingleton() {} // 3. 公共静态方法：双重检查锁实现懒加载+线程安全 publicstatic LazySingleton getInstance() { // 第一层检查：避免每次调用都加锁（提升性能） if (INSTANCE == null) { // 加锁：保证多线程下只有一个线程能进入初始化逻辑 synchronized (LazySingleton.class) { // 第二层检查：防止多个线程等待锁后重复初始化 if (INSTANCE == null) { INSTANCE = new LazySingleton(); } } } return INSTANCE; } // 测试方法 publicvoidsayHello() { System.out.println("懒汉式单例：Hello Lazy Singleton!"); } // 测试 publicstaticvoidmain(String[] args) { LazySingleton instance1 = LazySingleton.getInstance(); LazySingleton instance2 = LazySingleton.getInstance(); System.out.println(instance1 == instance2); // true instance1.sayHello(); }}
2. 简单工厂模式（Simple Factory Pattern）
核心思想：定义一个工厂类，根据传入的参数创建不同类型的产品实例，将对象创建逻辑与业务逻辑解耦。
java运行// 步骤1：定义产品接口public interface Shape { void draw();}// 步骤2：实现具体产品类// 圆形public class Circle implements Shape { @Override public void draw() { System.out.println("绘制圆形"); }}// 矩形public class Rectangle implements Shape { @Override public void draw() { System.out.println("绘制矩形"); }}// 步骤3：定义工厂类（核心）public class ShapeFactory { // 根据参数创建不同的Shape实例 public static Shape createShape(String shapeType) { if (shapeType == null) { return null; } switch (shapeType.toLowerCase()) { case "circle": return new Circle(); case "rectangle": return new Rectangle(); default: throw new IllegalArgumentException("不支持的图形类型：" + shapeType); } }}// 测试类public class FactoryTest { public static void main(String[] args) { // 客户端只需要调用工厂方法，无需关心对象创建细节 Shape circle = ShapeFactory.createShape("circle"); circle.draw(); // 输出：绘制圆形 Shape rectangle = ShapeFactory.createShape("rectangle"); rectangle.draw(); // 输出：绘制矩形 }}
3. 策略模式（Strategy Pattern）
核心思想：定义一系列算法，将每个算法封装成独立的策略类，使它们可以互相替换，算法变化不影响使用算法的客户端。
java运行// 步骤1：定义策略接口（算法抽象）public interface PaymentStrategy { void pay(double amount);}// 步骤2：实现具体策略类（不同算法）// 支付宝支付public class AlipayStrategy implements PaymentStrategy { @Override public void pay(double amount) { System.out.println("使用支付宝支付：" + amount + "元"); }}// 微信支付public class WechatPayStrategy implements PaymentStrategy { @Override public void pay(double amount) { System.out.println("使用微信支付：" + amount + "元"); }}// 步骤3：定义上下文类（封装策略调用，供客户端使用）public class PaymentContext { // 持有策略对象 private PaymentStrategy strategy; // 构造方法：注入策略 public PaymentContext(PaymentStrategy strategy) { this.strategy = strategy; } // 提供统一的支付方法 public void executePay(double amount) { strategy.pay(amount); }}// 测试类public class StrategyTest { public static void main(String[] args) { // 客户端可以灵活切换策略，无需修改核心逻辑 double amount = 100.0; // 使用支付宝支付 PaymentContext alipayContext = new PaymentContext(new AlipayStrategy()); alipayContext.executePay(amount); // 输出：使用支付宝支付：100.0元 // 切换为微信支付（仅需替换策略对象） PaymentContext wechatContext = new PaymentContext(new WechatPayStrategy()); wechatContext.executePay(amount); // 输出：使用微信支付：100.0元 }}
关键点回顾
- 1.单例模式：核心是私有构造方法 + 静态唯一实例 + 全局访问方法，饿汉式简单但懒加载差，双重检查锁的懒汉式兼顾性能和线程安全，是首选。
- 2.简单工厂模式：将对象创建逻辑集中到工厂类，客户端无需直接 new 对象，降低耦合，但新增产品需修改工厂类（违反开闭原则）。
- 3.策略模式：将算法封装为独立策略类，客户端可动态切换算法，核心是策略接口 + 具体策略 + 上下文类，符合开闭原则。
