掌握设计模式与Java编程：实战示例源码解析-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_36300623/article/details/144115419

简介：设计模式是软件开发中解决问题的有效方案，包括创建型、结构型和行为型三大类。本资源详述了这些模式，并以Java语言为例，提供源码以加深理解。设计模式能够增强代码的可维护性和可扩展性，遵循开闭原则。通过实例分析，本课程帮助开发者掌握如何在实际项目中应用设计模式，提高问题解决能力，深入理解Java的面向对象特性。常用设计模式及 Java程序设计(含java源码)

1. 设计模式概述

设计模式是软件工程中被广泛认可的一种针对特定问题的通用解决方案。它们提供了在特定上下文中重复使用对象和类的最佳实践。设计模式不仅仅是面向对象编程的核心，而且是构建可维护和可扩展软件的关键。

1.1 设计模式的起源与发展

设计模式的概念最早由建筑学领域引入软件工程界。1994年，Erich Gamma、Richard Helm、Ralph Johnson和John Vlissides四人共同著作了《设计模式：可复用面向对象软件的基础》（也被称为“Gang of Four”或GoF），将设计模式标准化。这本书详细介绍了23种设计模式，并将它们分为三大类：创建型、结构型和行为型。

1.2 设计模式的重要性

在IT行业中，设计模式提供了一种共享和沟通复杂设计结构的语言。它们有助于提高代码的可读性和系统的可维护性。当团队成员对特定模式有共同的理解时，就能在更短的时间内达成共识，减少沟通成本。此外，由于设计模式是经过验证的解决方案，它们可以帮助开发者避免在开发中犯常见的错误，提高软件质量。

1.3 设计模式的分类与应用

设计模式通常被分为三类： - 创建型模式 ：这些模式提供了对象创建的最佳方法，包括单例、工厂、建造者、原型等。 - 结构型模式 ：这些模式关注如何组合类和对象以获得更大的结构，包括适配器、装饰器、代理、桥接等。 - 行为型模式 ：这些模式关注对象间的职责分配，包括策略、模板方法、观察者、命令等。

在软件开发中，正确地选择和应用设计模式可以显著提高项目的灵活性和可维护性，从而使软件更容易适应需求的变化。下一章我们将深入探讨创建型模式的实现与应用。

2. 创建型模式详解与应用

创建型模式是设计模式中的一类，旨在更好地创建对象，同时隐藏创建逻辑，而不是使用new直接实例化对象。这样做的好处是代码更灵活、易于扩展，也便于维护。本章主要介绍和应用四种创建型模式：单例模式、工厂模式、建造者模式和原型模式。

2.1 单例模式的实现与扩展

2.1.1 单例模式的基本概念

单例模式是一种确保一个类只有一个实例，并提供一个全局访问点以供访问它的设计模式。单例模式的使用场景很广泛，比如配置管理器、日志记录器等。单例模式的关键点在于私有的构造函数、一个私有静态变量以及一个公有的静态访问点。

2.1.2 单例模式的几种实现方式

在Java中，单例模式的实现方式有好几种，包括懒汉式、饿汉式、双重校验锁（DCL）和静态内部类等。每种方式都有其适用的场景和利弊。例如：

懒汉式 适合实例的创建开销较大时，但线程不安全。
饿汉式 在类加载时就创建好实例，简单但可能会造成资源浪费。
双重校验锁 解决了懒汉式线程不安全的问题，并且实现了延迟加载。
静态内部类 则是利用了类加载机制来保证线程安全，而且只在需要时加载。

2.1.3 Java中的单例模式实现技巧

下面是一个双重校验锁方式的单例模式的实现代码：

public class Singleton {
    // 保证instance不会被反序列化重新创建新的对象
    private Singleton() {
        if (null != instance) {
            throw new IllegalStateException("Already initialized.");
        }
    }

    // volatile保证可见性和有序性
    private static volatile Singleton instance = null;

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

代码逻辑逐行分析

private Singleton() ：构造函数私有，防止外部通过new创建实例。
private static volatile Singleton instance = null; ：私有静态变量instance用于存储唯一实例， volatile 保证了多线程环境下的可见性和有序性。
getInstance() 方法首先检查 instance 是否为null，如果是，则进入同步块。
在同步块内再次检查 instance 是否为null，因为可能在第一次检查和进入同步块之间，其他线程已经创建了实例。
如果实例为空，执行 instance = new Singleton(); 创建新的实例。

2.2 工厂模式的原理与实践

2.2.1 工厂方法模式与抽象工厂模式

工厂模式提供了一种创建对象的最佳方式。工厂模式分为简单工厂、工厂方法模式和抽象工厂模式。工厂方法模式使用了工厂类和产品接口，通过工厂类创建具体的产品对象。抽象工厂模式则是工厂方法模式的升级版本，抽象工厂模式解决了多个产品等级结构的问题。

2.2.2 Java工厂模式的设计与应用

以工厂方法模式为例，假设有一个 Computer 接口和几个实现类，分别是 Laptop 和 Desktop 。可以创建一个 ComputerFactory 接口，其具体实现根据参数返回相应的产品实现：

public interface Computer {
    void powerOn();
}

public class Laptop implements Computer {
    @Override
    public void powerOn() {
        System.out.println("Laptop is powered on!");
    }
}

public class Desktop implements Computer {
    @Override
    public void powerOn() {
        System.out.println("Desktop is powered on!");
    }
}

public interface ComputerFactory {
    Computer create();
}

public class LaptopFactory implements ComputerFactory {
    @Override
    public Computer create() {
        return new Laptop();
    }
}

public class DesktopFactory implements ComputerFactory {
    @Override
    public Computer create() {
        return new Desktop();
    }
}

public class Client {
    public static void main(String[] args) {
        ComputerFactory factory = new LaptopFactory();
        Computer computer = factory.create();
        computer.powerOn();
    }
}

通过上述代码，客户端只需通过工厂获取到具体的产品对象，并调用其方法即可。如果需求变更需要其他类型的 Computer ，只需更换相应的工厂即可，无需改动客户端代码。

在这一部分中，我们看到了创建型模式的一些基本概念和实现，以及如何在Java中进行应用。这些模式在软件工程中被广泛使用，特别是在需要对实例化过程进行封装时。接下来，我们将深入探讨建造者模式和原型模式的构造与优化。

3. 结构型模式深入与实战

3.1 适配器模式的桥梁作用

3.1.1 适配器模式的分类及适用场景

适配器模式是一种结构型设计模式，它的目的是使得原本由于接口不兼容而不能一起工作的类可以协同工作。适配器模式主要分为两类：类适配器模式和对象适配器模式。

类适配器模式利用了多重继承的特性，通过创建一个继承自目标接口和被适配类的适配器类，将被适配类的接口转换成目标接口的接口。
对象适配器模式则是在适配器中组合一个被适配的对象，通过在适配器类中定义新接口，并在适配器类中调用被适配类的方法，来实现接口的转换。

适配器模式适用于以下场景：

当你想要使用一个已经存在的类，但是其接口不符合你的需求时。
当你想创建一个可以复用的类，该类可以与其他不相关的或未来可能不相关的类一起工作时。

3.1.2 Java中适配器模式的代码实现

以下是一个简单的类适配器和对象适配器模式的代码示例：

// 目标接口
public interface Target {
    void request();
}

// 被适配类
class Adaptee {
    public void specificRequest() {
        System.out.println("Adaptee specificRequest.");
    }
}

// 类适配器
class ClassAdapter extends Adaptee implements Target {
    @Override
    public void request() {
        specificRequest(); // 调用被适配类的方法
    }
}

// 对象适配器
class ObjectAdapter implements Target {
    private Adaptee adaptee = new Adaptee();

    @Override
    public void request() {
        adaptee.specificRequest(); // 调用被适配类的方法
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Target target = new ClassAdapter();
        target.request();
        Target target2 = new ObjectAdapter();
        target2.request();
    }
}

在上面的代码中， ClassAdapter 类通过继承实现了目标接口和被适配类的结合。而 ObjectAdapter 类则通过组合持有被适配类的实例，并实现目标接口，内部调用被适配类的方法。客户端代码通过调用 request 方法即可不感知适配器的存在，同时使用被适配类的功能。

3.1.3 适配器模式的扩展与优化

适配器模式可以容易地扩展，以支持更多类的适配。同时，可以通过增加方法映射或使用装饰器模式来优化其性能。例如，如果适配器需要支持多个被适配类，可以通过一个适配器工厂来决定使用哪个适配器。

适配器模式的优化通常围绕提高灵活性和减少依赖。例如，可以使用依赖注入来提供不同的被适配类给适配器，这样在适配器内部就不需要知道具体使用哪一个被适配类的实例。

3.2 装饰器模式的灵活应用

3.2.1 装饰器模式的基本原理

装饰器模式允许用户在不改变对象的接口的前提下，给对象添加新的功能。它通过创建一个包装对象来包裹原有的对象，然后在包装对象中添加新的行为或者属性。

装饰器模式的关键角色包括：

Component：定义一个对象接口，可以给这些对象动态地添加职责。
ConcreteComponent：定义了一个具体的对象，也可以给这个对象添加一些职责。
Decorator：维持一个指向Component对象的引用，并定义一个与Component接口一致的接口。
ConcreteDecorator：具体的装饰对象，实现了在Component接口定义的操作，每个装饰对象可以在被装饰后的对象上增加新的行为。

3.2.2 Java装饰器模式的使用技巧

在Java中，装饰器模式经常用于动态地扩展对象的行为。它的一个典型应用是在IO包中，如 InputStream 、 OutputStream 、 Reader 和 Writer 等抽象类都广泛地使用了装饰器模式。

以下是一个简单的装饰器模式使用示例：

// 抽象组件
interface Component {
    void operation();
}

// 具体组件
class ConcreteComponent implements Component {
    @Override
    public void operation() {
        System.out.println("ConcreteComponent operation");
    }
}

// 装饰器抽象类
abstract class Decorator implements Component {
    protected Component component;

    public Decorator(Component component) {
        this.component = component;
    }

    @Override
    public void operation() {
        component.operation();
    }
}

// 具体装饰器
class ConcreteDecorator extends Decorator {
    public ConcreteDecorator(Component component) {
        super(component);
    }

    @Override
    public void operation() {
        super.operation();
        addedBehavior();
    }

    private void addedBehavior() {
        System.out.println("ConcreteDecorator added behavior");
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Component component = new ConcreteComponent();
        Component decorator1 = new ConcreteDecorator(component);
        decorator1.operation();
    }
}

在这个示例中， ConcreteDecorator 装饰了 ConcreteComponent ，在 operation 方法调用中增加了额外的行为。客户端代码通过调用装饰后的对象的 operation 方法，实现了原有操作与额外操作的结合。这种模式非常灵活，可以轻易地添加更多的装饰器来进一步增强功能。

装饰器模式的一个关键优势是它不会改变原有对象的接口，而是创建一个新的接口。这使得它非常适合用于增加对象的职责，尤其是在这些职责需要被多个对象共享，或者在不修改现有系统的情况下动态地增加新职责的场景。

4. 行为型模式的原理与案例分析

行为型设计模式关注对象之间的职责划分和通信，定义了对象间相互通信的方式，使得它们可以协同工作。行为型模式包括策略模式、模板方法模式、观察者模式等，它们通过不同的方式控制对象的行为，使代码更加灵活和可重用。

4.1 策略模式的灵活决策

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

4.1.1 策略模式的定义和实现步骤

策略模式由两部分组成：上下文(context)和一组策略(strategy)。策略接口定义了算法族，具体策略类实现了这些算法。

实现步骤如下： 1. 创建一个策略接口，定义一个算法族。 2. 实现具体策略类。 3. 创建一个上下文，它持有一个策略的引用，并通过调用策略接口中的方法来执行策略。 4. 客户端代码可以动态地选择不同的策略。

4.1.2 Java中策略模式的应用实例

以下是一个使用策略模式实现不同支付方式的示例。

// 支付策略接口
public interface PaymentStrategy {
    void pay(int amount);
}

// 信用卡支付策略
public class CreditCardStrategy implements PaymentStrategy {
    private String name;
    private String cardNumber;
    private String cvv;
    private String dateOfExpiry;

    public CreditCardStrategy(String nm, String ccNumber, String cvv, String expiryDate) {
        this.name = nm;
        this.cardNumber = ccNumber;
        this.cvv = cvv;
        this.dateOfExpiry = expiryDate;
    }

    @Override
    public void pay(int amount) {
        System.out.println(amount + " paid with credit/debit card");
    }
}

// PayPal支付策略
public class PaypalStrategy implements PaymentStrategy {
    private String emailId;
    private String password;

    public PaypalStrategy(String email, String pwd) {
        this.emailId = email;
        this.password = pwd;
    }

    @Override
    public void pay(int amount) {
        System.out.println(amount + " paid using Paypal.");
    }
}

// 支付上下文
public class ShoppingCart {
    public void checkout(PaymentStrategy paymentStrategy, int amount) {
        paymentStrategy.pay(amount);
    }
}

// 客户端代码
public class StrategyPatternDemo {
    public static void main(String[] args) {
        ShoppingCart cart = new ShoppingCart();

        // 客户选择信用卡支付
        PaymentStrategy creditCard = new CreditCardStrategy("John Doe", "1234567890123456", "786", "12/15");
        cart.checkout(creditCard, 200);

        // 客户选择PayPal支付
        PaymentStrategy paypal = new PaypalStrategy("john.doe@example.com", "mypassword");
        cart.checkout(paypal, 300);
    }
}

在这个例子中， ShoppingCart 是上下文，可以接受不同的支付策略。客户端代码可以动态地切换支付方式，实现灵活的支付逻辑。

4.2 模板方法模式的固定框架

模板方法模式定义了一个算法的骨架，并将某些步骤延迟到子类中实现。模板方法允许子类重新定义算法的某些步骤，而不用改变算法的结构。

4.2.1 模板方法模式的核心思想

模板方法模式包含两部分：抽象类和具体子类。抽象类中定义了算法的骨架，包括模板方法和其它抽象方法，子类负责实现这些抽象方法。

核心思想是： - 在抽象类中定义操作的算法骨架，将某些步骤延迟到子类中。 - 子类可以重写这些步骤。

4.2.2 Java中模板方法模式的实现

以下是一个简单的模板方法模式实现示例：

// 抽象类
public abstract class AbstractClass {
    // 模板方法定义了算法的骨架
    public final void templateMethod() {
        primitiveOperation1();
        primitiveOperation2();
    }

    // 抽象方法，延迟到子类实现
    protected abstract void primitiveOperation1();
    protected abstract void primitiveOperation2();
}

// 具体子类1
public class ConcreteClass1 extends AbstractClass {
    @Override
    protected void primitiveOperation1() {
        System.out.println("ConcreteClass1.primitiveOperation1");
    }

    @Override
    protected void primitiveOperation2() {
        System.out.println("ConcreteClass1.primitiveOperation2");
    }
}

// 具体子类2
public class ConcreteClass2 extends AbstractClass {
    @Override
    protected void primitiveOperation1() {
        System.out.println("ConcreteClass2.primitiveOperation1");
    }

    @Override
    protected void primitiveOperation2() {
        System.out.println("ConcreteClass2.primitiveOperation2");
    }
}

// 客户端代码
public class TemplatePatternDemo {
    public static void main(String[] args) {
        AbstractClass c1 = new ConcreteClass1();
        AbstractClass c2 = new ConcreteClass2();

        c1.templateMethod();
        c2.templateMethod();
    }
}

在这个例子中， AbstractClass 定义了算法的骨架， primitiveOperation1 和 primitiveOperation2 是需要子类实现的方法。 ConcreteClass1 和 ConcreteClass2 是具体的子类，它们分别实现了自己的操作。客户端代码通过调用模板方法来执行算法，但具体的步骤是由子类定义的。

4.3 观察者模式的发布与订阅

观察者模式定义了对象之间的一对多依赖关系，当一个对象改变状态时，它的所有依赖者都会收到通知并自动更新。

4.3.1 观察者模式的基本原理

观察者模式由三个部分组成：主题(subject)、观察者(observer)和具体主题具体观察者。

主题持有一个观察者列表，当主题状态改变时，会通知所有观察者。
观察者实现了一个更新接口，以便当主题的状态改变时得到通知。
具体主题和具体观察者分别实现主题和观察者接口。

4.3.2 Java中观察者模式的实现细节

以下是一个简单的观察者模式实现：

// 主题接口
public interface Subject {
    void attach(Observer o);
    void detach(Observer o);
    void notifyObservers();
}

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

    @Override
    public void attach(Observer o) {
        observers.add(o);
    }

    @Override
    public void detach(Observer o) {
        observers.remove(o);
    }

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

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

// 观察者接口
public interface Observer {
    void update(int state);
}

// 具体观察者类
public class ConcreteObserver implements Observer {
    private int observerState;

    @Override
    public void update(int state) {
        observerState = state;
        // 自定义更新行为
    }
}

// 客户端代码
public class ObserverPatternDemo {
    public static void main(String[] args) {
        ConcreteSubject subject = new ConcreteSubject();

        Observer o1 = new ConcreteObserver();
        Observer o2 = new ConcreteObserver();

        subject.attach(o1);
        subject.attach(o2);

        subject.setState(0);
        subject.setState(1);
    }
}

在这个例子中， ConcreteSubject 是具体主题类，它维护了一个观察者列表并在状态改变时通知它们。 ConcreteObserver 是具体观察者类，实现了 update 方法来处理主题状态的变化。客户端代码通过 attach 方法将观察者注册到主题上，并通过修改主题状态来触发更新。

以上是行为型模式的原理与案例分析部分的内容，通过深入讨论策略模式、模板方法模式和观察者模式，我们不仅了解了每种模式的核心思想和实现方式，还通过具体的代码示例展示了这些模式在Java中的应用。这为我们提供了在软件开发中运用行为型模式以提高代码的灵活性和可维护性的重要见解。

5. 设计模式在Java中的应用与实践

5.1 开闭原则的重要性与实现

5.1.1 开闭原则的含义与作用

开闭原则是面向对象设计的基石之一，它要求软件实体应当对扩展开放，对修改关闭。这意味着在不修改现有代码的情况下，可以增加新的功能。它鼓励系统的设计应具备可扩展性和可维护性，从而在面对需求变化时，能够更快速、更低成本地适应变化。

开闭原则的实践，有助于我们减少维护成本，因为修改现有代码往往伴随着引入新的错误的风险。遵循开闭原则，能够使得系统更加稳定，易于维护和升级。

5.1.2 Java中的开闭原则实践技巧

在Java中实践开闭原则，关键在于使用接口和抽象类来定义系统的行为，并且通过依赖注入和多态来实现对具体实现的解耦。

// 定义一个接口，代表行为
public interface Behavior {
    void perform();
}

// 具体行为实现A
public class BehaviorA implements Behavior {
    @Override
    public void perform() {
        System.out.println("Behavior A is performed.");
    }
}

// 具体行为实现B
public class BehaviorB implements Behavior {
    @Override
    public void perform() {
        System.out.println("Behavior B is performed.");
    }
}

// 使用接口的类
public class Context {
    private Behavior behavior;

    public Context(Behavior behavior) {
        this.behavior = behavior;
    }

    public void setBehavior(Behavior behavior) {
        this.behavior = behavior;
    }

    public void executeBehavior() {
        behavior.perform();
    }
}

在上述代码中， Context 类不需要知道行为的实现细节，这样当需要引入新的行为时，只需添加新的行为实现类并注入到 Context 类中即可，无需修改现有的 Context 类代码。这种方式就是开闭原则的体现。

5.2 设计模式与Java API的结合

5.2.1 设计模式在Java标准库中的应用

Java标准库中广泛运用了设计模式来提供灵活、可重用的API。例如， Iterator 模式通过 Iterator 接口和 ArrayList 等集合类的实现，提供了遍历集合的统一方式，而无需关心集合内部结构。还有 Decorator 模式在 java.io 包中也得到了应用， InputStream 类层次结构的装饰者模式允许我们动态地添加额外的功能，如缓冲、过滤和日志记录，而无需修改原有类的代码。

5.2.2 Java API设计中体现的设计模式

在Java API的设计中，设计模式的运用无处不在，它们帮助构建了更加灵活和易用的API。例如， Factory Method 模式在 Collections 类中的使用，允许我们通过工厂方法模式创建不可变集合。这些集合在使用上提供了便利性，而在实现上保持了线程安全和不可变性。 Strategy 模式允许算法的独立变化，如 Comparator 接口的实现，让排序逻辑可以被替换而无需修改使用排序功能的代码。

5.3 设计模式在企业级开发中的运用

5.3.1 企业级应用的设计模式选择

在企业级应用开发中，设计模式的选择至关重要。例如， Singleton 模式常用于配置管理，保证配置单例对象在整个系统中唯一。 Factory 模式用于创建复杂的对象，如服务对象或复杂的业务对象，通过工厂模式可以在创建对象时加入额外的逻辑。 Command 模式可以用于日志系统，将操作封装成命令，便于执行、重做、撤销等操作。

5.3.2 设计模式在业务逻辑处理中的角色

在业务逻辑处理中，设计模式扮演着重要角色。例如，在处理订单业务时，可以使用 Strategy 模式来处理不同的支付策略；在处理用户验证时，可以采用 Decorator 模式来动态地添加验证规则。这样，每个模式都在其适用场景中解决特定的问题，使代码结构更清晰，逻辑更明确，便于维护和扩展。

以上内容只是一小部分，关于设计模式在Java中的应用与实践是需要深入学习和理解的。在下一章节，我们将进一步探讨Java源码分析与设计模式学习的方法。

6. Java源码分析与设计模式学习

6.1 从Java源码中学习设计模式

6.1.1 源码阅读的方法与技巧

源码阅读是一种深入了解Java语言、框架以及设计模式的高级学习手段。掌握正确的源码阅读方法和技巧，对于提升个人技术能力至关重要。在阅读源码时，以下几个建议能够帮助我们更高效地学习：

确定学习目标 ：在开始阅读源码之前，明确学习目标，比如理解特定设计模式的应用，或者是学习特定框架的工作原理。
分层次阅读 ：从高层次的设计理念开始，逐步深入到具体的实现细节。例如，首先阅读框架的文档和架构设计，然后才是类和方法的实现。
跟随调用链路 ：当阅读一个类或方法时，沿着方法调用链，逐步理解整个流程和各个组件之间的协作关系。
重构成分理解 ：尝试将复杂的部分重构为简单的模块，使自己能够更容易地理解各部分的功能和职责。
阅读其他人的分析 ：借助开源社区中其他人对源码的解读和分析，能够帮助我们更快地抓住重点。
动手实践 ：在阅读源码的过程中，尝试对关键部分进行修改、扩展或添加测试用例，以加深理解。

6.1.2 设计模式在Java框架中的应用分析

在Java框架中，设计模式被广泛地应用来解决各种问题，提高代码的可维护性和可扩展性。了解并分析这些设计模式如何在框架源码中发挥作用，对于深入理解框架和提升编程技巧是必不可少的。下面举几个例子进行说明：

模板方法模式在Java I/O中的应用

Java I/O类库中使用模板方法模式的一个例子是 InputStream 类。在这个类中， read() 方法是一个抽象方法，具体子类如 FileInputStream 需要实现这个方法。

public abstract class InputStream implements Closeable {
    // ...
    public abstract int read() throws IOException;
    // ...
}

而模板方法模式的核心——模板方法 read(byte[] b) 在 InputStream 中是一个具体方法，它调用了 read() 方法。这样的设计允许 InputStream 类规定一个算法的骨架，将一些步骤的实现延迟到子类，而子类又可以重写父类的方法来改变某些步骤的行为。

public int read(byte b[]) throws IOException {
    return read(b, 0, b.length);
}

通过分析这样的设计，我们可以理解模板方法模式如何在不改变算法框架的前提下，允许子类重新定义算法的某些步骤。

观察者模式在事件处理中的应用

在Java的Swing图形用户界面库中，观察者模式被广泛用于事件处理机制。当用户进行某种操作，比如点击按钮，会触发一个事件，这个事件会被传播到所有注册的监听器（观察者）。

public class Button extends Component {
    // ...
    public synchronized void addMouseListener(MouseListener listener) {
        // ...
    }
    // ...
}

当按钮被点击时， Button 类的 processMouseEvent 方法会被调用，进而调用注册监听器的 mouseClicked 方法。

protected void processMouseEvent(MouseEvent e) {
    super.processMouseEvent(e);
    // ...
    for (MouseListener listener : mouseListeners) {
        listener.mouseClicked(e);
    }
}

这个过程展示了观察者模式中的关键组件：事件源（Button），事件（MouseEvent），观察者（MouseListener）。理解这个机制有助于我们更好地编写和理解复杂的事件驱动程序。