在软件开发中，设计模式是一种被广泛接受和应用的工程设计经验总结。软件设计模式能够提高软件的可重用性、可扩展性、可维护性和可测试性。本文将介绍一些常见的软件设计模式，以及它们在面向对象软件开发中的应用。
单例模式（Singleton）
单例模式是一种创建型设计模式，保证一个类只有一个实例，并提供一个全局访问点。单例模式常用于系统的资源管理、日志记录、数据库连接等场景中。
public class Singleton {
private static Singleton instance;
private Singleton() {}
public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
工厂模式（Factory）
工厂模式是一种创建型设计模式，提供一种创建对象的工厂接口，将对象的实例化过程封装在工厂类中，客户端通过工厂类来创建对象。工厂模式常用于对象创建过程复杂、需要隐藏创建细节的场景。
public interface Product {
void operation();
}
public class ConcreteProduct implements Product {
@Override
public void operation() {
// 具体操作逻辑
}
}
public interface Factory {
Product createProduct();
}
public class ConcreteFactory implements Factory {
@Override
public Product createProduct() {
return new ConcreteProduct();
}
}
public class Client {
public static void main(String[] args) {
Factory factory = new ConcreteFactory();
Product product = factory.createProduct();
product.operation();
}
}
装饰器模式（Decorator）
装饰器模式是一种结构型设计模式，通过动态地将责任添加到对象上，可以实现对象功能的扩展和修改，而无需修改原始类。装饰器模式常用于需要动态地给对象添加功能的场景。
public interface Component {
void operation();
}
public class ConcreteComponent implements Component {
@Override
public void operation() {
// 具体操作逻辑
}
}
public abstract class Decorator implements Component {
protected Component component;
public Decorator(Component component) {
this.component = component;
}
@Override
public void operation() {
component.operation();
}
}
public class ConcreteDecorator extends Decorator {
public ConcreteDecorator(Component component) {
super(component);
}
@Override
public void operation() {
// 扩展操作逻辑
super.operation();
// 扩展操作逻辑
}
}
public class Client {
public static void main(String[] args) {
Component component = new ConcreteComponent();
Component decorator = new ConcreteDecorator(component);
decorator.operation();
}
}
观察者模式（Observer）
观察者模式是一种行为型设计模式，定义了一种一对多的依赖关系，当被观察对象的状态发生变化时，其依赖的观察者对象会自动接收通知并更新。观察者模式常用于对象之间的状态同步和事件通知。
public interface Observer {
void update();
}
public class ConcreteObserver implements Observer {
@Override
public void update() {
// 更新操作逻辑
}
}
public interface Subject {
void attach(Observer observer);
void detach(Observer observer);
void notifyObservers();
}
public class ConcreteSubject implements Subject {
private List<Observer> observers = new ArrayList<>();
@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();
}
}
}
public class Client {
public static void main(String[] args) {
Subject subject = new ConcreteSubject();
subject.attach(new ConcreteObserver());
subject.notifyObservers();
}
}
策略模式（Strategy）
策略模式是一种行为型设计模式，定义了一系列算法，并将其封装在各自的策略类中，使它们可以互相替换。策略模式可以实现对算法的独立变化，客户端可以根据需要选择不同的策略。
public interface Strategy {
void algorithm();
}
public class ConcreteStrategy1 implements Strategy {
@Override
public void algorithm() {
// 具体算法1
}
}
public class ConcreteStrategy2 implements Strategy {
@Override
public void algorithm() {
// 具体算法2
}
}
public class Context {
private Strategy strategy;
public Context(Strategy strategy) {
this.strategy = strategy;
}
public void performAlgorithm() {
strategy.algorithm();
}
}
public class Client {
public static void main(String[] args) {
Context context1 = new Context(new ConcreteStrategy1());
context1.performAlgorithm();
Context context2 = new Context(new ConcreteStrategy2());
context2.performAlgorithm();
}
}
总结
软件设计模式为解决软件设计中的常见问题提供了一些规范化的解决方案。本文介绍了一些常见的软件设计模式，包括单例模式、工厂模式、装饰器模式、观察者模式和策略模式。掌握这些设计模式可以帮助开发人员编写更加可复用、可扩展、可维护和可测试的面向对象软件。
本文来自极简博客，作者：软件测试视界，转载请注明原文链接：软件设计模式：可复用面向对象软件的基础
