Java中的设计模式：实战案例分享
设计模式是软件开发中的宝贵工具，它们为常见的问题提供了经过验证的解决方案，帮助开发者编写出可维护、可扩展的代码。在Java编程中，设计模式更是发挥了重要作用。本文将分享几种常见的Java设计模式，并通过实战案例来展示它们的实际应用。
一、单例模式（Singleton Pattern）
1. 模式简介
单例模式确保一个类只有一个实例，并提供一个全局访问点。它常用于需要全局唯一实例的场景，如配置管理、日志记录等。
2. 实战案例
假设我们需要设计一个日志记录器，确保整个系统中只有一个日志记录器实例。
public class Logger {
private static Logger instance;
private Logger() {
// 私有构造函数
}
public static Logger getInstance() {
if (instance == null) {
synchronized (Logger.class) {
if (instance == null) {
instance = new Logger();
}
}
}
return instance;
}
public void log(String message) {
System.out.println(message);
}
}
public class Main {
public static void main(String[] args) {
Logger logger = Logger.getInstance();
logger.log("This is a log message.");
}
}二、工厂模式（Factory Pattern）
1. 模式简介
工厂模式定义了一个创建对象的接口，但由子类决定实例化哪一个类。它通过延迟到子类来实现实例化，提供了对象创建的灵活性。
2. 实战案例
假设我们需要设计一个形状工厂，根据不同的参数生成不同的形状对象。
// 定义形状接口
interface Shape {
void draw();
}
// 实现具体的形状类
class Circle implements Shape {
public void draw() {
System.out.println("Drawing a Circle");
}
}
class Square implements Shape {
public void draw() {
System.out.println("Drawing a Square");
}
}
// 创建形状工厂
class ShapeFactory {
public Shape getShape(String shapeType) {
if (shapeType == null) {
return null;
}
if (shapeType.equalsIgnoreCase("CIRCLE")) {
return new Circle();
} else if (shapeType.equalsIgnoreCase("SQUARE")) {
return new Square();
}
return null;
}
}
// 使用工厂生成对象
public class Main {
public static void main(String[] args) {
ShapeFactory shapeFactory = new ShapeFactory();
Shape shape1 = shapeFactory.getShape("CIRCLE");
shape1.draw();
Shape shape2 = shapeFactory.getShape("SQUARE");
shape2.draw();
}
}三、观察者模式（Observer Pattern）
1. 模式简介
观察者模式定义了对象间的一对多依赖关系，当一个对象的状态发生变化时，所有依赖于它的对象都会收到通知并自动更新。该模式常用于事件处理系统中。
2. 实战案例
假设我们设计一个新闻发布系统，当有新新闻发布时，所有订阅者都会收到通知。
import java.util.ArrayList;
import java.util.List;
// 定义观察者接口
interface Observer {
void update(String message);
}
// 实现具体的观察者
class Subscriber implements Observer {
private String name;
public Subscriber(String name) {
= name;
}
@Override
public void update(String message) {
System.out.println(name + " received: " + message);
}
}
// 定义被观察者接口
interface Subject {
void attach(Observer observer);
void detach(Observer observer);
void notifyObservers();
}
// 实现具体的被观察者
class NewsPublisher implements Subject {
private List<Observer> observers = new ArrayList<>();
private String news;
public void setNews(String news) {
this.news = news;
notifyObservers();
}
@Override
public void attach(Observer observer) {
observers.add(observer);
}
@Override
public void detach(Observer observer) {
observers.remove(observer);
}
@Override
public void notifyObservers() {
for (Observer observer : observers) {
observer.update(news);
}
}
}
// 使用观察者模式
public class Main {
public static void main(String[] args) {
NewsPublisher publisher = new NewsPublisher();
Subscriber subscriber1 = new Subscriber("Alice");
Subscriber subscriber2 = new Subscriber("Bob");
publisher.attach(subscriber1);
publisher.attach(subscriber2);
publisher.setNews("Breaking News: Java Design Patterns are awesome!");
publisher.detach(subscriber1);
publisher.setNews("Update: Observer Pattern in action!");
}
}四、策略模式（Strategy Pattern）
1. 模式简介
策略模式定义了一系列算法，并将每个算法封装起来，使它们可以相互替换。策略模式使得算法可以独立于使用它的客户端变化。
2. 实战案例
假设我们设计一个支付系统，可以根据不同的支付方式（如信用卡、PayPal）来执行支付操作。
// 定义支付策略接口
interface PaymentStrategy {
void pay(int amount);
}
// 实现具体的支付策略
class CreditCardPayment implements PaymentStrategy {
@Override
public void pay(int amount) {
System.out.println("Paid " + amount + " using Credit Card");
}
}
class PayPalPayment implements PaymentStrategy {
@Override
public void pay(int amount) {
System.out.println("Paid " + amount + " using PayPal");
}
}
// 创建上下文使用策略
class ShoppingCart {
private PaymentStrategy paymentStrategy;
public void setPaymentStrategy(PaymentStrategy paymentStrategy) {
this.paymentStrategy = paymentStrategy;
}
public void checkout(int amount) {
paymentStrategy.pay(amount);
}
}
// 使用策略模式
public class Main {
public static void main(String[] args) {
ShoppingCart cart = new ShoppingCart();
cart.setPaymentStrategy(new CreditCardPayment());
cart.checkout(100);
cart.setPaymentStrategy(new PayPalPayment());
cart.checkout(200);
}
}五、总结
设计模式为软件开发提供了一套最佳实践，帮助开发者编写出高质量、易维护的代码。本文分享了单例模式、工厂模式、观察者模式和策略模式的实战案例，展示了这些模式在实际项目中的应用。掌握并正确应用设计模式，可以大大提高开发效率和代码质量。
