java中的设计模式-EW帮帮网

1. 单例模式（Singleton）

确保一个类只有一个实例，并提供全局访问点。
应用场景：线程池、数据库连接池、配置管理器。
示例代码：

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）

通过工厂类创建对象，将对象创建和使用分离。
应用场景：根据不同条件创建不同类型的对象（如形状、数据库连接）。
示例代码

// 接口
interface Shape {
    void draw();
}

// 实现类
class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("绘制圆形");
    }
}

class Rectangle implements Shape {
    @Override
    public void draw() {
        System.out.println("绘制矩形");
    }
}

// 工厂类
class ShapeFactory {
    public Shape createShape(String type) {
        if ("CIRCLE".equalsIgnoreCase(type)) {
            return new Circle();
        } else if ("RECTANGLE".equalsIgnoreCase(type)) {
            return new Rectangle();
        }
        return null;
    }
}

3. 观察者模式（Observer）

定义对象间的一对多依赖关系，当一个对象状态改变时，所有依赖它的对象都会被通知。
应用场景：事件监听、消息订阅系统。
示例代码：

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

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

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

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

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

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

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

    public void setNews(String news) {
        this.news = news;
        notifyObservers();
    }
}

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

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

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

4. 装饰器模式（Decorator）

动态地给对象添加额外功能，比继承更灵活。
应用场景：IO 流包装（如BufferedInputStream）、权限控制。
示例代码

// 组件接口
interface Coffee {
    String getDescription();
    double cost();
}

// 具体组件
class SimpleCoffee implements Coffee {
    @Override
    public String getDescription() {
        return "简单咖啡";
    }

    @Override
    public double cost() {
        return 1.0;
    }
}

// 装饰器抽象类
abstract class CoffeeDecorator implements Coffee {
    protected Coffee coffee;

    public CoffeeDecorator(Coffee coffee) {
        this.coffee = coffee;
    }

    @Override
    public String getDescription() {
        return coffee.getDescription();
    }

    @Override
    public double cost() {
        return coffee.cost();
    }
}

// 具体装饰器
class MilkDecorator extends CoffeeDecorator {
    public MilkDecorator(Coffee coffee) {
        super(coffee);
    }

    @Override
    public String getDescription() {
        return coffee.getDescription() + ", 加牛奶";
    }

    @Override
    public double cost() {
        return coffee.cost() + 0.5;
    }
}

5. 策略模式（Strategy）

定义一系列算法，将每个算法封装起来，并使它们可以互换。
应用场景：排序算法切换、支付方式选择。
示例代码：

/ 策略接口
interface PaymentStrategy {
    void pay(double amount);
}

// 具体策略
class CreditCardPayment implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        System.out.println("使用信用卡支付: " + amount + "元");
    }
}

class PayPalPayment implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        System.out.println("使用PayPal支付: " + amount + "元");
    }
}

// 上下文
class ShoppingCart {
    private PaymentStrategy paymentStrategy;

    public void setPaymentStrategy(PaymentStrategy paymentStrategy) {
        this.paymentStrategy = paymentStrategy;
    }

    public void checkout(double amount) {
        paymentStrategy.pay(amount);
    }
}

设计模式的核心原则

开闭原则：对扩展开放，对修改关闭。
依赖倒置原则：依赖抽象而非具体实现。
单一职责原则：一个类只负责一项职责。
接口隔离原则：使用多个专门的接口，而非单一庞大接口。
迪米特法则：一个对象应尽量少与其他对象交互。

一、创建型模式（5 种）

用于对象的创建过程，封装复杂的创建逻辑。

单例模式（Singleton）
- 意图：确保类只有一个实例，并提供全局访问点。
- 应用：线程池、配置管理器、日志记录器。
工厂模式（Factory）
- 意图：定义创建对象的接口，让子类决定实例化哪个类。
- 应用：根据参数创建不同类型的对象（如数据库连接）。
抽象工厂模式（Abstract Factory）
- 意图：提供创建一系列相关对象的接口，无需指定具体类。
- 应用：创建跨平台 UI 组件（如 Windows/Linux 按钮）。
建造者模式（Builder）
- 意图：将复杂对象的构建与表示分离，允许按步骤创建。
- 应用：构造参数繁多的对象（如StringBuilder）。
原型模式（Prototype）
- 意图：通过复制现有对象创建新对象，避免复杂初始化。
- 应用：复制资源密集型对象（如图形、配置）。

二、结构型模式（7 种）

关注如何将类或对象组合成更大的结构。

代理模式（Proxy）
- 意图：为其他对象提供代理以控制对该对象的访问。
- 应用：远程代理（如 RMI）、虚拟代理（延迟加载）。
装饰器模式（Decorator）
- 意图：动态添加功能到对象，比继承更灵活。
- 应用：Java IO 流（如BufferedInputStream）。
适配器模式（Adapter）
- 意图：将一个类的接口转换成用户期望的另一个接口。
- 应用：兼容不兼容的类（如Enumeration转Iterator）。
桥接模式（Bridge）
- 意图：将抽象部分与实现部分分离，使它们可以独立变化。
- 应用：跨平台图形绘制（抽象 API 与具体实现分离）。
组合模式（Composite）
- 意图：将对象组合成树形结构以表示 “部分 - 整体” 层次。
- 应用：文件系统、菜单组件。
外观模式（Facade）
- 意图：为复杂子系统提供统一接口，简化客户端调用。
- 应用：封装底层 API（如java.net.URL）。
享元模式（Flyweight）
- 意图：通过共享技术高效支持大量细粒度对象。
- 应用：文本编辑器中的字符对象、图形符号。

三、行为型模式（11 种）

关注对象间的通信和职责分配。

观察者模式（Observer）
- 意图：定义对象间的一对多依赖，当一个对象改变时通知所有依赖者。
- 应用：事件监听、消息发布 - 订阅系统。
策略模式（Strategy）
- 意图：定义一系列算法，封装每个算法并使它们可互换。
- 应用：排序算法切换、支付方式选择。
模板方法模式（Template Method）
- 意图：定义算法骨架，将一些步骤延迟到子类实现。
- 应用：HttpServlet 的doGet()/doPost()方法。
责任链模式（Chain of Responsibility）
- 意图：将请求传递给一系列处理者，直到有一个处理者处理它。
- 应用：Servlet 过滤器链、异常处理链。
命令模式（Command）
- 意图：将请求封装为对象，允许参数化客户端、排队或记录请求。
- 应用：撤销操作、任务队列。
状态模式（State）
- 意图：允许对象在内部状态改变时改变行为，看起来像修改了类。
- 应用：工作流引擎、游戏角色状态转换。
访问者模式（Visitor）
- 意图：将算法与对象结构分离，在不改变结构的前提下添加新操作。
- 应用：编译器语法树遍历、XML 解析。
中介者模式（Mediator）
- 意图：定义一个中介对象来封装一系列对象间的交互。
- 应用：聊天室、GUI 组件协调。
迭代器模式（Iterator）
- 意图：提供一种方法顺序访问聚合对象的元素，而不暴露内部结构。
- 应用：Java 集合框架的Iterator接口。
解释器模式（Interpreter）
- 意图：给定一个语言，定义它的文法表示，并定义一个解释器。
- 应用：正则表达式解析、SQL 语句解释。
备忘录模式（Memento）
- 意图：在不破坏封装的前提下，捕获并外部化对象的内部状态。
- 应用：游戏存档、撤销操作。

常见应用场景

Spring 框架：单例模式（Bean 默认作用域）、工厂模式（BeanFactory）、代理模式（AOP）。
Java 集合框架：迭代器模式（Iterator）、组合模式（树形结构）。
Java IO：装饰器模式（InputStream子类）、适配器模式（InputStreamReader）。

java中的设计模式