IT技术社区_专业开发者平台_最新编程教程与解决方案 -沐辰社区

Java设计模式实践案例

wen java案例 2

本文目录导读：

Java设计模式实践案例

  1. 工厂模式（Factory Pattern）
  2. 单例模式（Singleton Pattern）
  3. 观察者模式（Observer Pattern）
  4. 策略模式（Strategy Pattern）
  5. 适配器模式（Adapter Pattern）
  6. 装饰器模式（Decorator Pattern）
  7. 构建器模式（Builder Pattern）
  8. 责任链模式（Chain of Responsibility）

我来为你提供几个Java设计模式的实践案例,每个都包含具体的代码示例和应用场景。

工厂模式（Factory Pattern）

场景：支付系统

// 支付接口
public interface Payment {
    void pay(double amount);
}
// 具体支付方式
public class Alipay implements Payment {
    @Override
    public void pay(double amount) {
        System.out.println("使用支付宝支付：" + amount + "元");
    }
}
public class WechatPay implements Payment {
    @Override
    public void pay(double amount) {
        System.out.println("使用微信支付：" + amount + "元");
    }
}
// 工厂类
public class PaymentFactory {
    public static Payment createPayment(String type) {
        switch (type) {
            case "alipay":
                return new Alipay();
            case "wechat":
                return new WechatPay();
            default:
                throw new IllegalArgumentException("不支持的支付方式");
        }
    }
}
// 使用示例
public class Main {
    public static void main(String[] args) {
        Payment payment = PaymentFactory.createPayment("alipay");
        payment.pay(100.0);
    }
}

单例模式（Singleton Pattern）

场景：数据库连接池

public class DatabaseConnectionPool {
    // 使用volatile确保多线程下的可见性
    private static volatile DatabaseConnectionPool instance;
    private List<Connection> connections;
    private DatabaseConnectionPool() {
        // 私有构造函数
        connections = new ArrayList<>();
        // 初始化连接...
    }
    // 双重检查锁定
    public static DatabaseConnectionPool getInstance() {
        if (instance == null) {
            synchronized (DatabaseConnectionPool.class) {
                if (instance == null) {
                    instance = new DatabaseConnectionPool();
                }
            }
        }
        return instance;
    }
    public Connection getConnection() {
        // 获取连接逻辑
        return connections.remove(0);
    }
}

观察者模式（Observer Pattern）

场景：天气预警系统

import java.util.ArrayList;
import java.util.List;
// 观察者接口
interface Observer {
    void update(String weatherData);
}
// 被观察者（主题）
class WeatherStation {
    private List<Observer> observers = new ArrayList<>();
    private String weatherData;
    public void addObserver(Observer observer) {
        observers.add(observer);
    }
    public void removeObserver(Observer observer) {
        observers.remove(observer);
    }
    public void setWeatherData(String data) {
        this.weatherData = data;
        notifyObservers();
    }
    private void notifyObservers() {
        for (Observer observer : observers) {
            observer.update(weatherData);
        }
    }
}
// 具体观察者：气象台
class MeteorologicalBureau implements Observer {
    private String name;
    public MeteorologicalBureau(String name) {
        this.name = name;
    }
    @Override
    public void update(String weatherData) {
        System.out.println(name + " 收到天气预报：" + weatherData);
    }
}
// 使用示例
public class WeatherSystem {
    public static void main(String[] args) {
        WeatherStation station = new WeatherStation();
        MeteorologicalBureau beijing = new MeteorologicalBureau("北京气象台");
        MeteorologicalBureau shanghai = new MeteorologicalBureau("上海气象台");
        station.addObserver(beijing);
        station.addObserver(shanghai);
        station.setWeatherData("晴，25℃");
    }
}

策略模式（Strategy Pattern）

场景：商品促销系统

// 策略接口
interface DiscountStrategy {
    double calculateDiscount(double price);
}
// 具体策略：无折扣
class NoDiscount implements DiscountStrategy {
    @Override
    public double calculateDiscount(double price) {
        return price;
    }
}
// 具体策略：7折
class SevenFoldDiscount implements DiscountStrategy {
    @Override
    public double calculateDiscount(double price) {
        return price * 0.7;
    }
}
// 具体策略：满100减20
class FullReductionDiscount implements DiscountStrategy {
    @Override
    public double calculateDiscount(double price) {
        if (price >= 100) {
            return price - 20;
        }
        return price;
    }
}
// 使用策略的上下文类
class CheckoutService {
    private DiscountStrategy discountStrategy;
    public CheckoutService(DiscountStrategy discountStrategy) {
        this.discountStrategy = discountStrategy;
    }
    public double getFinalPrice(double originalPrice) {
        return discountStrategy.calculateDiscount(originalPrice);
    }
    public void setDiscountStrategy(DiscountStrategy strategy) {
        this.discountStrategy = strategy;
    }
}
// 使用示例
public class ShoppingCart {
    public static void main(String[] args) {
        double originalPrice = 150.0;
        CheckoutService checkout = new CheckoutService(new NoDiscount());
        System.out.println("无折扣价格：" + checkout.getFinalPrice(originalPrice));
        checkout.setDiscountStrategy(new SevenFoldDiscount());
        System.out.println("7折价格：" + checkout.getFinalPrice(originalPrice));
        checkout.setDiscountStrategy(new FullReductionDiscount());
        System.out.println("满减价格：" + checkout.getFinalPrice(originalPrice));
    }
}

适配器模式（Adapter Pattern）

场景：不同接口的对接

// 目标接口
interface JsonParser {
    String parseToJson(String xmlData);
}
// 已有的XML解析器
class XmlParser {
    public String parseXmlToObj(String xml) {
        return "Object from XML: " + xml;
    }
}
// 适配器类
class XmlToJsonAdapter implements JsonParser {
    private XmlParser xmlParser;
    public XmlToJsonAdapter(XmlParser xmlParser) {
        this.xmlParser = xmlParser;
    }
    @Override
    public String parseToJson(String xmlData) {
        // 将XML数据转换为对象，然后再转成JSON格式
        String object = xmlParser.parseXmlToObj(xmlData);
        return "{\"data\":\"" + object + "\"}";
    }
}
// 使用示例
public class DataSystem {
    public static void main(String[] args) {
        XmlParser xmlParser = new XmlParser();
        JsonParser adapter = new XmlToJsonAdapter(xmlParser);
        String xmlData = "<user>Java</user>";
        String jsonData = adapter.parseToJson(xmlData);
        System.out.println("转换结果：" + jsonData);
    }
}

装饰器模式（Decorator Pattern）

场景：咖啡店

// 基础接口
interface Coffee {
    double getCost();
    String getDescription();
}
// 具体组件：基础咖啡
class SimpleCoffee implements Coffee {
    @Override
    public double getCost() {
        return 10.0;
    }
    @Override
    public String getDescription() {
        return "基础咖啡";
    }
}
// 装饰器抽象类
abstract class CoffeeDecorator implements Coffee {
    protected Coffee decoratedCoffee;
    public CoffeeDecorator(Coffee coffee) {
        this.decoratedCoffee = coffee;
    }
    @Override
    public double getCost() {
        return decoratedCoffee.getCost();
    }
    @Override
    public String getDescription() {
        return decoratedCoffee.getDescription();
    }
}
// 具体装饰器：加牛奶
class MilkDecorator extends CoffeeDecorator {
    public MilkDecorator(Coffee coffee) {
        super(coffee);
    }
    @Override
    public double getCost() {
        return super.getCost() + 5.0;
    }
    @Override
    public String getDescription() {
        return super.getDescription() + "，加牛奶";
    }
}
// 具体装饰器：加糖
class SugarDecorator extends CoffeeDecorator {
    public SugarDecorator(Coffee coffee) {
        super(coffee);
    }
    @Override
    public double getCost() {
        return super.getCost() + 2.0;
    }
    @Override
    public String getDescription() {
        return super.getDescription() + "，加糖";
    }
}
// 使用示例
public class CoffeeShop {
    public static void main(String[] args) {
        Coffee coffee = new SimpleCoffee();
        System.out.println(coffee.getDescription() + " - " + coffee.getCost() + "元");
        coffee = new MilkDecorator(coffee);
        coffee = new SugarDecorator(coffee);
        System.out.println(coffee.getDescription() + " - " + coffee.getCost() + "元");
    }
}

构建器模式（Builder Pattern）

场景：创建复杂对象

public class User {
    // 必填字段
    private final String name;
    private final int age;
    // 可选字段
    private final String email;
    private final String phone;
    private User(UserBuilder builder) {
        this.name = builder.name;
        this.age = builder.age;
        this.email = builder.email;
        this.phone = builder.phone;
    }
    // 静态内部类Builder
    public static class UserBuilder {
        private final String name;
        private final int age;
        private String email;
        private String phone;
        public UserBuilder(String name, int age) {
            this.name = name;
            this.age = age;
        }
        public UserBuilder email(String email) {
            this.email = email;
            return this;
        }
        public UserBuilder phone(String phone) {
            this.phone = phone;
            return this;
        }
        public User build() {
            return new User(this);
        }
    }
    // Getter方法...
    public String getName() { return name; }
    public int getAge() { return age; }
    public String getEmail() { return email; }
    public String getPhone() { return phone; }
}
// 使用示例
public class UserService {
    public static void main(String[] args) {
        User user = new User.UserBuilder("张三", 25)
                .email("zhangsan@example.com")
                .phone("13800138000")
                .build();
        System.out.println("用户信息：" + user.getName() + ", " + user.getAge() + 
                         ", " + user.getEmail() + ", " + user.getPhone());
    }
}

责任链模式（Chain of Responsibility）

场景：请假审批系统

// 审批处理器抽象类
abstract class Approver {
    protected Approver nextApprover;
    public void setNextApprover(Approver next) {
        this.nextApprover = next;
    }
    public abstract void approveRequest(int days);
}
// 具体处理器：主管
class Supervisor extends Approver {
    @Override
    public void approveRequest(int days) {
        if (days <= 3) {
            System.out.println("主管批准了" + days + "天的请假");
        } else if (nextApprover != null) {
            System.out.println("主管无权审批，转交上级");
            nextApprover.approveRequest(days);
        }
    }
}
// 具体处理器：部门经理
class DepartmentManager extends Approver {
    @Override
    public void approveRequest(int days) {
        if (days <= 7) {
            System.out.println("部门经理批准了" + days + "天的请假");
        } else if (nextApprover != null) {
            System.out.println("部门经理无权审批，转交上级");
            nextApprover.approveRequest(days);
        }
    }
}
// 具体处理器：总经理
class GeneralManager extends Approver {
    @Override
    public void approveRequest(int days) {
        System.out.println("总经理批准了" + days + "天的请假");
    }
}
// 使用示例
public class ApprovalSystem {
    public static void main(String[] args) {
        Approver supervisor = new Supervisor();
        Approver manager = new DepartmentManager();
        Approver generalManager = new GeneralManager();
        // 构建责任链
        supervisor.setNextApprover(manager);
        manager.setNextApprover(generalManager);
        // 测试不同天数的请假
        supervisor.approveRequest(2);
        supervisor.approveRequest(5);
        supervisor.approveRequest(10);
    }
}

这些设计模式的核心价值：

  • 工厂模式：解耦对象创建和使用
  • 单例模式：确保全局唯一，节省资源
  • 观察者模式：实现事件驱动和松耦合
  • 策略模式：算法封装和灵活切换
  • 适配器模式：接口兼容和桥梁
  • 装饰器模式：动态扩展功能
  • 构建器模式：创建复杂对象，提高可读性
  • 责任链模式：请求处理链，灵活分派

在实际项目中,通常会组合使用多个设计模式来解决问题，选择设计模式时要考虑：

  • 是否有足够的灵活性需求
  • 是否增加过度设计
  • 是否符合开闭原则
  • 团队的理解和维护成本

建议：从简单场景开始练习，逐步掌握每种模式的使用时机和优劣势。

上一篇建造者模式案例

下一篇Java注解实现ORM案例

相关文章

抱歉，评论功能暂时关闭!