学习设计模式的应用场景

设计模式是程序开发中的重要思维工具，它提供了一套解决通用问题的经验总结，可以帮助我们编写出更优雅、高效、可维护的代码。在本文中，我们将探讨设计模式的应用场景以及它如何促进优秀编码与程序开发。

1. 单例模式 - Singleton Pattern

单例模式用于创建一个唯一的实例，确保在整个应用程序中只有一个对象存在。这在需要共享资源或控制特定资源的访问时非常有用。例如，数据库连接池、线程池、日志记录和缓存系统等。

public class Singleton {
    private static Singleton instance;

    private Singleton() {}

    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

2. 工厂模式 - Factory Pattern

工厂模式用于封装对象的创建过程，并将其交给子类来决定实例化哪个具体类。它可以减少代码的重复，并提供了一种灵活的方式来创建对象。例如，图形绘制程序中，我们可以根据用户选择的图形类型来创建相应的图形对象。

public interface Shape {
    void draw();
}

public class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a circle.");
    }
}

public class Rectangle implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a rectangle.");
    }
}

public class ShapeFactory {
    public Shape createShape(String type) {
        if (type.equalsIgnoreCase("circle")) {
            return new Circle();
        } else if (type.equalsIgnoreCase("rectangle")) {
            return new Rectangle();
        }
        return null;
    }
}

3. 观察者模式 - Observer Pattern

观察者模式用于实现对象之间的一对多依赖关系，当一个对象的状态发生变化时，它的所有依赖者都会收到通知并更新自己的状态。这种模式比较适用于需要实时响应事件的场景，例如用户界面组件、消息通知系统等。

public interface Observer {
    void update(String message);
}

public class User implements Observer {
    private String name;

    public User(String name) {
        this.name = name;
    }

    @Override
    public void update(String message) {
        System.out.println(name + " received a message: " + message);
    }
}

public interface Subject {
    void registerObserver(Observer observer);
    void removeObserver(Observer observer);
    void notifyObservers(String message);
}

public class MessagePublisher implements Subject {
    private List<Observer> observers = new ArrayList<>();

    @Override
    public void registerObserver(Observer observer) {
        observers.add(observer);
    }

    @Override
    public void removeObserver(Observer observer) {
        observers.remove(observer);
    }

    @Override
    public void notifyObservers(String message) {
        for (Observer observer : observers) {
            observer.update(message);
        }
    }
}

// Usage

MessagePublisher publisher = new MessagePublisher();
User user1 = new User("Alice");
User user2 = new User("Bob");
publisher.registerObserver(user1);
publisher.registerObserver(user2);
publisher.notifyObservers("Hello, everyone!");

4. 策略模式 - Strategy Pattern

策略模式用于根据不同的场景选择不同的算法或行为。它将算法封装为独立的策略类，使得它们可以相互替换，而不影响客户端的代码。这种模式特别适用于需要根据条件进行动态选择的场景，例如排序算法、支付方式等。

public interface PaymentStrategy {
    void pay(int amount);
}

public class CreditCardPaymentStrategy implements PaymentStrategy {
    private String cardNumber;
    private String cvv;

    public CreditCardPaymentStrategy(String cardNumber, String cvv) {
        this.cardNumber = cardNumber;
        this.cvv = cvv;
    }

    @Override
    public void pay(int amount) {
        System.out.println("Paid " + amount + " using credit card " + cardNumber);
    }
}

public class PayPalPaymentStrategy implements PaymentStrategy {
    private String email;
    private String password;

    public PayPalPaymentStrategy(String email, String password) {
        this.email = email;
        this.password = password;
    }

    @Override
    public void pay(int amount) {
        System.out.println("Paid " + amount + " using PayPal account " + email);
    }
}

public class ShoppingCart {
    private List<Item> items = new ArrayList<>();

    public void addItem(Item item) {
        items.add(item);
    }

    public void removeItem(Item item) {
        items.remove(item);
    }

    public int calculateTotal() {
        int total = 0;
        for (Item item : items) {
            total += item.getPrice();
        }
        return total;
    }

    public void pay(PaymentStrategy paymentStrategy) {
        int amount = calculateTotal();
        paymentStrategy.pay(amount);
    }
}

以上仅是几个常见的设计模式及其应用场景。通过学习设计模式，我们可以更好地理解并应用这些模式，提高代码的可读性、可维护性和可扩展性。希望本文能为你提供一些关于设计模式使用的思考。

本文来自极简博客，作者：破碎星辰，转载请注明原文链接：学习设计模式的应用场景