探索Java中的设计模式：原则与实例_如何理解java设计原则和模式-优快云博客

探索Java中的设计模式：原则与实例

大家好，我是微赚淘客系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！今天，我们将深入探讨Java中的设计模式，包括一些关键的设计原则和具体的实例。设计模式是软件工程中的重要组成部分，它们提供了一套经过验证的解决方案来应对常见的设计问题。

一、设计模式的基本原则

单一职责原则（SRP）

一个类应该只有一个原因引起它的变化。简单来说，就是每个类应该有且仅有一个责任。
开放-关闭原则（OCP）

软件实体（类、模块、函数等）应该对扩展开放，对修改关闭。换句话说，应该通过扩展来增加功能，而不是修改已有代码。
里氏替换原则（LSP）

子类对象应该能够替换掉所有父类对象，并且程序的行为不会改变。这确保了继承的正确性。
接口隔离原则（ISP）

一个类对另一个类的依赖应当建立在最小的接口上。即一个接口应该尽量小，避免创建过多的方法。
依赖倒置原则（DIP）

高层模块不应该依赖低层模块，二者都应该依赖抽象；抽象不应该依赖细节，细节应该依赖抽象。

二、常见设计模式及其Java实现

单例模式（Singleton Pattern）

单例模式确保一个类只有一个实例，并提供一个全局访问点。它常用于需要全局共享的资源，如配置管理器。

package cn.juwatech.singleton;

public class Singleton {
    private static Singleton instance;

    private Singleton() {
        // 私有构造函数防止外部实例化
    }

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

该实现使用了双重检查锁定，以减少同步开销。

工厂模式（Factory Pattern）

工厂模式提供了一个创建对象的接口，但由子类决定实例化哪一个类。它用于创建复杂对象。

package cn.juwatech.factory;

// 产品接口
interface Product {
    void use();
}

// 具体产品
class ConcreteProductA implements Product {
    @Override
    public void use() {
        System.out.println("Using Product A");
    }
}

class ConcreteProductB implements Product {
    @Override
    public void use() {
        System.out.println("Using Product B");
    }
}

// 工厂类
public class ProductFactory {
    public static Product createProduct(String type) {
        switch (type) {
            case "A":
                return new ConcreteProductA();
            case "B":
                return new ConcreteProductB();
            default:
                throw new IllegalArgumentException("Unknown product type");
        }
    }
}

客户端代码使用ProductFactory来创建具体的产品实例，而无需知道具体的实现类。

观察者模式（Observer Pattern）

观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一主题对象。当主题对象发生改变时，所有依赖于它的观察者都会收到通知。

package cn.juwatech.observer;

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

// 主题接口
interface Subject {
    void addObserver(Observer observer);
    void removeObserver(Observer observer);
    void notifyObservers();
}

// 观察者接口
interface Observer {
    void update(String message);
}

// 具体主题
class ConcreteSubject implements Subject {
    private final List<Observer> observers = new ArrayList<>();
    private String state;

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

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

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

    public void setState(String state) {
        this.state = state;
        notifyObservers();
    }
}

// 具体观察者
class ConcreteObserver implements Observer {
    private final String name;

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

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

// 测试观察者模式
public class ObserverExample {
    public static void main(String[] args) {
        ConcreteSubject subject = new ConcreteSubject();
        Observer observer1 = new ConcreteObserver("Observer 1");
        Observer observer2 = new ConcreteObserver("Observer 2");

        subject.addObserver(observer1);
        subject.addObserver(observer2);

        subject.setState("New State");
    }
}

以上代码展示了如何使用观察者模式来实现主题和观察者之间的通知机制。

策略模式（Strategy Pattern）

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

package cn.juwatech.strategy;

// 策略接口
interface Strategy {
    int execute(int a, int b);
}

// 具体策略
class AddStrategy implements Strategy {
    @Override
    public int execute(int a, int b) {
        return a + b;
    }
}

class SubtractStrategy implements Strategy {
    @Override
    public int execute(int a, int b) {
        return a - b;
    }
}

// 上下文
public class Context {
    private final Strategy strategy;

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

    public int executeStrategy(int a, int b) {
        return strategy.execute(a, b);
    }
}

// 测试策略模式
public class StrategyExample {
    public static void main(String[] args) {
        Context context = new Context(new AddStrategy());
        System.out.println("Add: " + context.executeStrategy(5, 3));

        context = new Context(new SubtractStrategy());
        System.out.println("Subtract: " + context.executeStrategy(5, 3));
    }
}