面对复杂问题，Java设计模式的应用实例

原创 - 日理万妓 2024-11-14 09:06 10阅读 0赞

Java设计模式是一套被广泛认可的最佳实践，用于解决特定类型的设计问题。以下是一些常见的设计模式及其在面对复杂问题时的应用实例：

1. **单例模式（Singleton）**
- **问题**：需要确保某个类只有一个实例，并提供一个全局访问点。
- **实例**：数据库连接池，配置管理器等。

```java public class Singleton {
 private static Singleton instance;
 private Singleton() {}
 public static Singleton getInstance() {
if (instance == null) {
 instance = new Singleton();
 }
 return instance;
 }
 }
 ```2. **工厂方法模式（Factory Method）**
- **问题**：需要创建对象，但不知道具体要创建哪个类的对象。
- **实例**：创建不同类型的报告，如PDF报告、Word报告等。

```java interface Report {
 void generate();
 }
 class PDFReport implements Report {
 public void generate() { System.out.println("Generating PDF report."); }
 }
 class WordReport implements Report {
 public void generate() { System.out.println("Generating Word report."); }
 }
 class ReportFactory {
 public Report getReport(String type) {
if ("PDF".equalsIgnoreCase(type)) {
 return new PDFReport();
} else {
 return new WordReport();
 }
 }
 }
 ```3. **策略模式（Strategy）**
- **问题**：需要在运行时选择算法或行为。
- **实例**：支付系统，支持多种支付方式（信用卡、PayPal、微信支付等）。

```java interface PaymentStrategy {
 void pay(int amount);
 }
 class CreditCardStrategy implements PaymentStrategy {
 public void pay(int amount) { System.out.println("Paying with credit card: " + amount); }
 }
 class PayPalStrategy implements PaymentStrategy {
 public void pay(int amount) { System.out.println("Paying with PayPal: " + amount); }
 }
 class ShoppingCart {
 private PaymentStrategy paymentStrategy;
 public ShoppingCart(PaymentStrategy paymentStrategy) {
 this.paymentStrategy = paymentStrategy;
 }
 public void checkout(int amount) {
 paymentStrategy.pay(amount);
 }
 }
 ```4. **观察者模式（Observer）**
- **问题**：需要在对象间建立一对多的依赖关系。
- **实例**：新闻发布系统，当新闻更新时，所有订阅者都会收到通知。

```java interface Observer {
 void update(String message);
 }
 interface Subject {
 void registerObserver(Observer o);
 void removeObserver(Observer o);
 void notifyObservers();
 }
 class NewsPublisher implements Subject {
 private List<Observer> observers = new ArrayList<>();
 private String message;
 public void registerObserver(Observer o) { observers.add(o); }
 public void removeObserver(Observer o) { observers.remove(o); }
 public void notifyObservers() {
 for (Observer observer : observers) {
 observer.update(message);
 }
 }
 public void setMessage(String message) {
 this.message = message;
 notifyObservers();
 }
 }
 ```5. **装饰器模式（Decorator）**
- **问题**：需要动态地给一个对象添加额外的职责。
- **实例**：咖啡店，可以给咖啡添加不同的调料（糖、牛奶等）。

```java interface Coffee {
 double cost();
 }
 class SimpleCoffee implements Coffee {
 public double cost() { return1.0; }
 }
 abstract class CoffeeDecorator implements Coffee {
 protected Coffee decoratedCoffee;
 public CoffeeDecorator(Coffee coffee) {
 this.decoratedCoffee = coffee;
 }
 public double cost() {
 return decoratedCoffee.cost();
 }
 }
 class MilkCoffee extends CoffeeDecorator {
 public MilkCoffee(Coffee coffee) { super(coffee); }
 public double cost() {
 return super.cost() +0.5;
 }
 }
 ```这些模式可以帮助你以更灵活、可扩展和可维护的方式解决复杂问题。在实际应用中，根据具体需求选择合适的设计模式是非常重要的。