Java中的设计模式实战：单例、工厂、策略模式的最佳实践
在Java开发中，设计模式是构建高效、可维护、可扩展应用程序的关键。本文将深入探讨三种常见且实用的设计模式：单例模式、工厂模式和策略模式，并通过详细代码实例，展示它们的最佳实践。
单例模式：确保全局唯一性
单例模式是最简单的创建型模式之一，它确保一个类只有一个实例，并提供一个全局访问点。单例模式有多种实现方式，但每种方式都有其适用场景和注意事项。
懒汉式单例
懒汉式单例在类被加载时不会立即实例化，而是在第一次调用getInstance()方法时才创建实例，这样可以延迟初始化，节省资源。
public class Singleton {
private static Singleton instance;
private Singleton() {}
public static synchronized Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
优点： 实现简单，按需初始化。
缺点： 每次调用getInstance()都需要进行同步，可能导致性能问题。
饿汉式单例
饿汉式单例在类加载时就立即实例化，确保了线程安全，但无法延迟初始化。
public class Singleton {
private static final Singleton instance = new Singleton();
private Singleton() {}
public static Singleton getInstance() {
return instance;
}
}
优点： 简单且线程安全。
缺点： 无法延迟初始化，可能导致资源浪费。
双重检查锁定（DCL）单例
DCL单例结合了懒汉式和饿汉式的优点，既实现了延迟初始化，又保证了线程安全。
public class Singleton {
private static volatile Singleton instance;
private Singleton() {}
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}
优点： 实现了延迟初始化，且线程安全。
缺点： 代码相对复杂，需要理解volatile的语义。
最佳实践： 在大多数场景下，推荐使用DCL单例，因为它兼顾了性能和线程安全。
工厂模式：创建对象的抽象
工厂模式是一种创建型模式，它提供一个创建对象的接口，但让子类决定实例化哪个类。工厂模式分为简单工厂模式、工厂方法模式和抽象工厂模式。
简单工厂模式
简单工厂模式定义一个创建对象的类，由这个类来封装实例化的过程。
public class SocialMediaFactory {
public static SocialMedia getService(String type) {
if ("facebook".equals(type)) {
return new FacebookService();
} else if ("twitter".equals(type)) {
return new TwitterService();
} else {
throw new IllegalArgumentException("Unknown type: " + type);
}
}
}
interface SocialMedia {
void connect();
}
class FacebookService implements SocialMedia {
public void connect() {
System.out.println("Connecting to Facebook");
}
}
class TwitterService implements SocialMedia {
public void connect() {
System.out.println("Connecting to Twitter");
}
}
优点： 将对象的创建逻辑集中在一个类中，便于维护。
缺点： 违反开闭原则，添加新类型需要修改工厂类。
工厂方法模式
工厂方法模式定义一个创建对象的接口，但让子类决定实例化哪个类。
abstract class SocialMediaFactory {
abstract SocialMedia createService();
}
class FacebookFactory extends SocialMediaFactory {
@Override
SocialMedia createService() {
return new FacebookService();
}
}
class TwitterFactory extends SocialMediaFactory {
@Override
SocialMedia createService() {
return new TwitterService();
}
}
优点： 符合开闭原则，添加新类型只需添加新工厂类。
缺点： 需要为每个产品类型创建一个工厂类。
抽象工厂模式
抽象工厂模式提供一个创建一系列相关或依赖对象的接口，而不需要指定它们具体的类。
interface PaymentFactory {
Payment createPayment();
}
class CreditCardFactory implements PaymentFactory {
@Override
public Payment createPayment() {
return new CreditCardPayment();
}
}
class PayPalFactory implements PaymentFactory {
@Override
public Payment createPayment() {
return new PayPalPayment();
}
}
abstract class Payment {
abstract void processPayment(double amount);
}
class CreditCardPayment extends Payment {
@Override
void processPayment(double amount) {
System.out.println("Processing credit card payment of $" + amount);
}
}
class PayPalPayment extends Payment {
@Override
void processPayment(double amount) {
System.out.println("Processing PayPal payment of $" + amount);
}
}
优点： 可以创建一系列相关对象，而无需指定具体类。
缺点： 系统中类的数量会显著增加。
最佳实践： 根据需求选择合适的工厂模式。如果对象创建逻辑简单，使用简单工厂；如果需要扩展性，使用工厂方法；如果需要创建一系列相关对象，使用抽象工厂。
策略模式：算法的灵活切换
策略模式是一种行为型模式，它定义一系列算法，把它们一个个封装起来，并使它们可以相互替换。策略模式让算法的变化独立于使用算法的客户。
定义支付策略接口
public interface PaymentStrategy {
void pay(double amount);
}
实现具体支付策略
public class CreditCardPayment implements PaymentStrategy {
private String cardNumber;
public CreditCardPayment(String cardNumber) {
this.cardNumber = cardNumber;
}
@Override
public void pay(double amount) {
System.out.println(amount + " paid with credit card " + cardNumber);
}
}
public class PayPalPayment implements PaymentStrategy {
private String email;
public PayPalPayment(String email) {
this.email = email;
}
@Override
public void pay(double amount) {
System.out.println(amount + " paid using PayPal " + email);
}
}
使用策略上下文
public class ShoppingCart {
private List<Item> items;
private PaymentStrategy paymentStrategy;
public ShoppingCart() {
items = new ArrayList<>();
}
public void addItem(Item item) {
items.add(item);
}
public void setPaymentStrategy(PaymentStrategy paymentStrategy) {
this.paymentStrategy = paymentStrategy;
}
public void checkout() {
double total = calculateTotal();
paymentStrategy.pay(total);
items.clear();
System.out.println("Order processed successfully!");
}
private double calculateTotal() {
double total = 0;
for (Item item : items) {
total += item.getPrice() * item.getQuantity();
}
return total;
}
}
class Item {
private String name;
private double price;
private int quantity;
public Item(String name, double price, int quantity) {
this.name = name;
this.price = price;
this.quantity = quantity;
}
public String getName() {
return name;
}
public double getPrice() {
return price;
}
public int getQuantity() {
return quantity;
}
}
客户端代码
public class Main {
public static void main(String[] args) {
ShoppingCart cart = new ShoppingCart();
cart.addItem(new Item("Book", 20, 1));
cart.addItem(new Item("Laptop", 999, 1));
// 使用信用卡支付
cart.setPaymentStrategy(new CreditCardPayment("1234-5678-9012-3456"));
cart.checkout();
// 切换到PayPal支付
cart.setPaymentStrategy(new PayPalPayment("user@example.com"));
cart.addItem(new Item("Mouse", 19.99, 1));
cart.checkout();
}
}
优点： 策略模式使算法可以独立于使用它的客户端而变化，提供了灵活的算法切换能力。
缺点： 需要为每个具体策略实现一个类，可能导致类数量增加。
最佳实践： 在需要动态切换算法或策略的场景中，优先考虑使用策略模式。例如支付方式选择、算法优化等场景。
总结
单例模式、工厂模式和策略模式是Java开发中非常实用的设计模式。单例模式确保全局唯一性，工厂模式抽象对象创建过程，策略模式提供算法的灵活切换能力。在实际项目中，合理运用这些设计模式，可以显著提高代码的可维护性和可扩展性。
记住，设计模式不是万能的，它们应该根据具体需求谨慎选择和使用。过度使用设计模式可能导致系统复杂度增加，反而降低开发效率。理解每种模式的适用场景，并在实际项目中根据需求灵活运用，是成为优秀Java开发者的必经之路。
