设计模式示例：让你的代码更优雅

设计模式示例：让你的代码更优雅

在软件开发中，设计模式是解决常见问题的一套被反复使用、经过实践验证的解决方案。它们不仅提高了代码的可读性、可维护性，还能让开发者在面对复杂问题时有章可循。本文将为大家介绍几种常见的设计模式示例，并探讨它们的应用场景。

1. 单例模式（Singleton Pattern）

单例模式确保一个类只有一个实例，并提供一个全局访问点。它的应用非常广泛，例如在配置文件管理、日志记录、数据库连接池等场景中。

示例：

public class Singleton {
    private static Singleton instance;
    private Singleton() {}
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                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("Inside Circle::draw() method.");
    }
}

public class ShapeFactory {
    public Shape getShape(String shapeType) {
        if (shapeType == null) {
            return null;
        }
        if (shapeType.equalsIgnoreCase("CIRCLE")) {
            return new Circle();
        }
        return null;
    }
}

3. 观察者模式（Observer Pattern）

观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生变化时，会通知所有观察者对象，使它们能够自动更新自己。

示例：

import java.util.ArrayList;
import java.util.List;

interface Observer {
    void update();
}

class Subject {
    private List<Observer> observers = new ArrayList<>();
    private int state;

    public int getState() {
        return state;
    }

    public void setState(int state) {
        this.state = state;
        notifyAllObservers();
    }

    public void attach(Observer observer) {
        observers.add(observer);
    }

    public void notifyAllObservers() {
        for (Observer observer : observers) {
            observer.update();
        }
    }
}

class BinaryObserver implements Observer {
    private Subject subject;

    public BinaryObserver(Subject subject) {
        this.subject = subject;
        this.subject.attach(this);
    }

    @Override
    public void update() {
        System.out.println("Binary String: " + Integer.toBinaryString(subject.getState()));
    }
}

4. 策略模式（Strategy Pattern）

策略模式定义了一系列的算法，把它们一个个封装起来，并且使它们可以相互替换。该模式让算法的变化独立于使用算法的客户。

示例：

interface Strategy {
    int doOperation(int num1, int num2);
}

class OperationAdd implements Strategy {
    @Override
    public int doOperation(int num1, int num2) {
        return num1 + num2;
    }
}

class Context {
    private Strategy strategy;

    public Context(Strategy strategy) {
        this.strategy = strategy;
    }

    public int executeStrategy(int num1, int num2) {
        return strategy.doOperation(num1, num2);
    }
}

应用场景

单例模式适用于需要全局唯一实例的场景，如配置管理、日志记录等。
工厂模式在需要创建复杂对象或根据条件创建不同类型对象时非常有用，如数据库连接池的创建。
观察者模式常用于事件处理系统、发布-订阅系统等。
策略模式在需要动态选择算法或行为的场景中非常有效，如支付系统中的不同支付方式。

通过这些设计模式示例，我们可以看到它们如何帮助我们编写更清晰、更易维护的代码。设计模式不仅是解决问题的工具，更是一种思维方式，帮助我们更好地理解和设计软件系统。希望本文能为大家提供一些启发，助力于编程之路。