java设计模式代码示例

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();    }}

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();    }}

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(); // 输出：绘制矩形    }}

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元    }}