简介：《Headfirst设计模式》是面向对象设计模式的入门佳作，通过生动实例讲解了核心设计模式。该压缩包文件包含了书中提及的设计模式源代码，有助于读者直观理解模式实现。内容涵盖了单例、工厂、抽象工厂、建造者、原型、观察者、装饰者、代理、适配器、桥接、组合、享元、职责链、命令和访问者模式的Java源代码实现，以及这些模式如何在实践中提供可读性与可维护性。 
1. 设计模式的基本原理与概念
设计模式是软件工程中用于解决特定问题的一套已被验证过的通用设计模板。在软件开发过程中，设计模式使得代码更加可维护、可扩展，且易于理解和交流。本章将介绍设计模式的基本原理与概念，包括它们的分类、用途和重要性。
设计模式根据它们解决的问题类型可以分为三大类：创建型模式、结构型模式和行为型模式。创建型模式关注的是对象创建过程中的问题，如单例模式确保一个类只有一个实例。结构型模式涉及如何组合类和对象以获得更大的结构，例如适配器模式使不兼容的接口能够一起工作。行为型模式关注的是对象之间的通信，例如观察者模式定义了对象之间的一种一对多的依赖关系。
了解这些设计模式对于任何有意提升自身软件开发技能的专业人士来说都是至关重要的。熟练掌握并应用设计模式能够帮助开发者更加高效地编写高质量、易于测试和维护的代码。在后续章节中，我们将深入探讨各类模式的具体实践和案例。
2. 创建型模式的理论与实践
创建型模式主要涉及对象创建的机制，其目的是在不指定创建对象的具体类的情况下，创建对象并提供接口以返回该对象。这一类模式非常适合于那些对象创建逻辑比较复杂的情况，例如需要根据配置或环境条件来创建不同的对象。创建型模式通常包括单例模式、工厂模式、抽象工厂模式、建造者模式和原型模式等。
2.1 单例模式的深度解析
2.1.1 单例模式的理论基础
单例模式（Singleton Pattern）是设计模式中最为简单和最常用的一个模式。它用于确保一个类只有一个实例，并提供一个全局访问点来访问该实例。在软件工程中，单例模式是一种常用的模式，它提供了一种创建对象的最佳方式。
单例模式的核心是：确保只有一个实例，提供一个全局访问点。它属于创建型模式，又属于对象创建型模式。
单例模式有三个基本要点：
- 单一职责：确保一个类只有一个实例。
- 全局访问点：提供一个全局访问点，使其他部分可以获取这个实例。
- 延迟实例化：单例类通常在第一次被引用时才实例化。
单例模式适用于以下场景：
- 当类只能有一个实例而且客户可以从一个众所周知的访问点访问它时。
- 当这个唯一实例应该是通过子类化可扩展的，并且客户应该无需更改代码就能使用一个扩展的实例时。
2.1.2 单例模式在实际开发中的应用
在实际开发中，单例模式应用非常广泛。例如，当应用需要记录日志时，通常我们会使用单例模式创建一个日志类的实例，以确保整个应用程序在任何地方记录日志时都使用同一个日志对象。
单例模式的实现方式有很多种，常见的有懒汉式、饿汉式、双重检查锁定和内部类实现等。
下面是一个简单的Java实现饿汉式的单例模式：
public class SingletonExample {
// 类加载时就初始化
private static final SingletonExample INSTANCE = new SingletonExample();
// 私有构造函数，保证外部不能通过new创建实例
private SingletonExample() {}
// 提供一个全局访问点，外界获取该实例时直接返回
public static SingletonExample getInstance() {
return INSTANCE;
}
}
这段代码展示了饿汉式单例模式的核心思想：在类加载时就立即初始化，并且创建单例对象。这种方式的优点是实现简单，在类加载时完成初始化，依赖于类加载机制，保证了唯一性；缺点是在类加载时就完成了初始化，因此没有达到懒加载的效果。
单例模式虽然简单，但是它也有一些缺点。例如，它违反了单一职责原则，因为它除了提供单例之外，可能还会提供其他方法。此外，如果单例类负责创建自己的实例，那么在某些情况下（例如，构造函数需要参数）这种实现方式可能会导致困难。在多线程环境下，还必须小心处理并发问题。
2.2 工厂模式的核心机制
2.2.1 工厂模式的分类与适用场景
工厂模式（Factory Pattern）是一种创建型设计模式，它提供了一种创建对象的最佳方式。在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。
工厂模式主要分为以下三种：
- 简单工厂模式（Simple Factory）：由一个工厂对象决定创建出哪一种产品类的实例。
- 工厂方法模式（Factory Method）：定义一个创建对象的接口，让子类决定实例化哪一个类。
- 抽象工厂模式（Abstract Factory）：提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。
工厂模式的适用场景包括：
- 当一个类不知道它所需要的对象的类：在工厂方法模式中，客户端不需要知道具体产品类的类名，只需要知道所对应的工厂即可，具体的产品对象由具体工厂类创建；客户端需要知道创建具体产品的工厂类。
- 当一个类希望通过其子类指定创建哪个对象：工厂方法使子类可以指定创建的对象。
- 当系统中有多于一个的产品族，而每次只使用其中某一产品族：可通过工厂模式实现，为不同的产品族提供不同的工厂。
工厂模式主要优点是解耦了对象的创建和使用，使得结构清晰，同时工厂方法模式可以允许系统在不修改客户端代码的情况下引入新的产品。但是，它也增加了系统的抽象性和理解难度。
2.2.2 工厂模式的代码实现与案例分析
工厂模式的实现涉及以下几个主要的参与者：
- Product：产品接口或抽象类，定义产品的操作和属性。
- ConcreteProduct：具体的产品类，实现Product接口。
- Creator：创建产品的抽象类，声明工厂方法，其子类将覆盖并实现工厂方法，返回一个Product类型的对象。
- ConcreteCreator：具体的创建者，实现工厂方法，返回一个ConcreteProduct类型的对象。
下面是一个简单的工厂方法模式的实现示例，该例子中，我们将创建不同类型的具体产品，例如Windows和Mac的电脑产品。
// 产品接口
public interface Computer {
void manufacture();
}
// Windows电脑产品实现类
public class WindowsComputer implements Computer {
@Override
public void manufacture() {
System.out.println("Windows Computer manufactured.");
}
}
// Mac电脑产品实现类
public class MacComputer implements Computer {
@Override
public void manufacture() {
System.out.println("Mac Computer manufactured.");
}
}
// 电脑工厂接口
public interface ComputerFactory {
Computer manufactureComputer();
}
// Windows电脑工厂实现类
public class WindowsComputerFactory implements ComputerFactory {
@Override
public Computer manufactureComputer() {
return new WindowsComputer();
}
}
// Mac电脑工厂实现类
public class MacComputerFactory implements ComputerFactory {
@Override
public Computer manufactureComputer() {
return new MacComputer();
}
}
在这个例子中，我们定义了一个Computer接口和两个实现了这个接口的具体类：WindowsComputer和MacComputer。我们还定义了一个ComputerFactory接口和两个实现了这个接口的工厂类：WindowsComputerFactory和MacComputerFactory。客户端代码现在可以使用ComputerFactory接口来创建Computer对象，而无需知道具体的产品类型。
客户端使用示例：
public class Client {
public static void main(String[] args) {
ComputerFactory windowsFactory = new WindowsComputerFactory();
Computer windowsComputer = windowsFactory.manufactureComputer();
windowsComputer.manufacture();
ComputerFactory macFactory = new MacComputerFactory();
Computer macComputer = macFactory.manufactureComputer();
macComputer.manufacture();
}
}
以上代码展示了如何通过工厂方法模式来创建不同类型的电脑产品，客户端仅与抽象接口交互，具体的实现由具体的工厂类来完成。这样的设计使得系统易于扩展，并且可以适应不同的产品族。
3. 结构型模式的理论与实践
结构型模式关注如何将对象和类组合成较大的结构，同时保持结构的灵活和高效。本章主要探讨几种常见的结构型设计模式，包括建造者模式、适配器模式和装饰者模式。这些模式帮助开发者在维持代码清晰和灵活性的同时，解决特定的架构问题。
3.1 建造者模式的设计技巧
3.1.1 建造者模式的原理与特点
建造者模式是一种创建型设计模式，它提供了一种创建复杂对象的精细控制过程的方法。它允许一个类拥有多个不同的表示，而且这些表示之间可以独立变化。建造者模式的核心思想是使用一个指挥者（Director）和多个具体建造者（Builder）类。
- 建造者模式的主要特点 ：
- 封装性 ：客户端不需要知道产品的内部细节。
- 建造过程控制 ：Builder 类定义了产品构造过程的顺序。
- 灵活性和可扩展性 ：容易引入新的建造者，且不需要改变现有的客户端代码。
建造者模式特别适用于创建复杂的对象，例如对象的创建过程需要多个步骤，并且这些步骤在不同的场景下可能会有所不同。
3.1.2 建造者模式在代码构建中的应用
在软件开发中，建造者模式的一个典型应用是通过链式方法调用来构建对象。下面是一个简单的例子来展示建造者模式如何应用于对象创建。
public class Car {
private String engine;
private String seats;
private String wheels;
private Car(CarBuilder builder) {
this.engine = builder.engine;
this.seats = builder.seats;
this.wheels = builder.wheels;
}
// Getters and Setters
public static class CarBuilder {
private String engine;
private String seats;
private String wheels;
public CarBuilder buildEngine(String engine) {
this.engine = engine;
return this;
}
public CarBuilder buildSeats(String seats) {
this.seats = seats;
return this;
}
public CarBuilder buildWheels(String wheels) {
this.wheels = wheels;
return this;
}
public Car build() {
return new Car(this);
}
}
}
// Usage
Car car = new Car.CarBuilder()
.buildEngine("V8")
.buildSeats("Leather")
.buildWheels("Alloy")
.build();
在上面的例子中， Car 类通过其内部静态类 CarBuilder 来创建。这样做的好处是客户端代码只需要关心需要构建的具体部分，而不需要担心构建的顺序或者如何构建。每个 build 方法都返回 CarBuilder 类的实例，这样可以连续调用。
通过建造者模式，开发者可以更加灵活地构建复杂对象，同时避免了直接使用构造器带来的复杂性。这种方式尤其适合那些有大量可选配置的对象。
3.2 适配器模式的实践策略
3.2.1 适配器模式的基本结构
适配器模式是一种结构型设计模式，旨在解决两个已有接口之间不匹配的问题。适配器将一个类的接口转换成客户期望的另一个接口，使得原本由于接口不兼容而不能工作的类可以一起工作。
- 适配器模式的组成 ：
- 目标接口（Target） ：客户所期望的接口。
- 适配者（Adaptee） ：已经存在的、拥有不同接口的类。
- 适配器（Adapter） ：会将适配者接口转换成目标接口。
适配器模式的三种实现方式分别是对象适配器、类适配器和接口适配器。
3.2.2 适配器模式在不同编程环境的运用
适配器模式在多个编程环境中有广泛的应用。例如，在Java中实现数据库连接池，可能会用到 DataSource 接口，而不同的数据库厂商可能提供不同的实现。这时，适配器模式可以用来统一这些厂商的实现：
public interface VendorDataSource {
Connection getConnection() throws SQLException;
}
public class MySQLDataSource implements VendorDataSource {
// MySQL specific implementation of getConnection();
}
public class OracleDataSource implements VendorDataSource {
// Oracle specific implementation of getConnection();
}
public class DataSourceAdapter implements DataSource {
private VendorDataSource vendorDataSource;
public DataSourceAdapter(VendorDataSource vendorDataSource) {
this.vendorDataSource = vendorDataSource;
}
public Connection getConnection() {
return vendorDataSource.getConnection();
}
// Other DataSource methods...
}
// Usage
VendorDataSource mysqlDS = new MySQLDataSource();
DataSource dataSource = new DataSourceAdapter(mysqlDS);
在这个例子中， DataSourceAdapter 是适配器，它把不同厂商的 VendorDataSource 实现转换成了统一的 DataSource 接口。这样，无论背后的实现是哪种数据库，都可以用统一的方式进行访问。
适配器模式使我们的代码更具有可复用性和可扩展性，也使得第三方库或遗留代码能够更容易地与其他代码协同工作。
3.3 装饰者模式的灵活性应用
3.3.1 装饰者模式的实现原理
装饰者模式允许向一个现有的对象添加新的功能，同时又不改变其结构。这种模式创建了一个装饰类，用来包装原有的类，并在保持类方法签名完整性的前提下，提供了额外的功能。
- 装饰者模式的核心组件 ：
- 组件（Component） ：定义一个对象接口，可以给这些对象动态地添加职责。
- 具体组件（Concrete Component） ：定义一个将要被装饰的对象，也可以给这个对象添加附加的职责。
- 装饰者（Decorator） ：维持一个指向组件对象的引用，并定义一个与组件接口一致的接口。
- 具体装饰者（Concrete Decorator） ：具体的装饰对象，实现新的功能。
3.3.2 装饰者模式优化系统设计的案例
装饰者模式在实际项目中的一个典型应用是为图形用户界面（GUI）组件添加新功能，而不影响现有的组件类。
例如，一个简单的GUI组件可以是按钮。我们可以创建一个装饰者来增加额外的行为，比如添加一个边框或高亮显示按钮：
public interface Component {
void operation();
}
public class ConcreteComponent implements Component {
@Override
public void operation() {
System.out.println("ConcreteComponent operation");
}
}
public abstract class Decorator implements Component {
protected Component component;
public Decorator(Component component) {
***ponent = component;
}
public void operation() {
component.operation();
}
}
public class ConcreteDecoratorA extends Decorator {
public ConcreteDecoratorA(Component component) {
super(component);
}
public void addedBehavior() {
System.out.println("Added behavior in ConcreteDecoratorA");
}
@Override
public void operation() {
super.operation();
addedBehavior();
}
}
// Usage
Component component = new ConcreteComponent();
ConcreteDecoratorA decoratorA = new ConcreteDecoratorA(component);
decoratorA.operation();
装饰者模式允许我们在不修改已有组件的基础上，动态地为对象增加职责。这在组件库的设计中非常有用，可以避免组件的膨胀，并且可以按照客户的需要灵活地提供不同层次的组件。
总结来说，结构型设计模式中的建造者模式、适配器模式和装饰者模式都为解决实际开发中的问题提供了有效的策略。通过这些模式的实践应用，可以提高软件的灵活性和扩展性，同时保持代码的清晰和易于维护。
4. 行为型模式的理论与实践
4.1 观察者模式的机制与实现
观察者模式的原理与实践问题
观察者模式是一种行为型设计模式，允许对象之间一个对多的依赖关系，当一个对象改变状态时，它的所有依赖者都会收到通知并自动更新。这种模式特别适用于解耦观察者和被观察者，使得两者之间的耦合度更低。
在观察者模式中，主要有两种角色：观察者（Observer）和被观察者（Subject）。观察者负责订阅主题，并在主题状态变化时接收通知。被观察者则负责维护观察者列表，并在状态变化时通知所有的观察者。
在软件开发中，观察者模式的实践问题主要集中在几个方面：
- 性能问题 ：当大量观察者需要在被观察者状态变化时被通知时，可能会产生性能瓶颈。
- 内存泄漏 ：如果观察者对象不再使用，需要及时从被观察者的列表中移除，否则可能会导致内存泄漏。
- 同步问题 ：多线程环境下，对观察者列表的访问需要同步，避免并发问题。
观察者模式在事件驱动编程中的应用
在事件驱动编程中，观察者模式的应用十分广泛。事件可以看作是被观察者发出的通知，而监听器则是观察者的角色。当事件发生时，所有注册了该事件的监听器都会接收到通知并执行相应的处理逻辑。
下面是一个简单的观察者模式示例代码，用于说明在事件驱动编程中的应用：
import java.util.ArrayList;
import java.util.List;
interface Observer {
void update(String message);
}
interface Subject {
void attach(Observer observer);
void detach(Observer observer);
void notifyObservers();
}
class ConcreteSubject implements Subject {
private List<Observer> observers = new ArrayList<>();
private String message;
public void attach(Observer observer) {
observers.add(observer);
}
public void detach(Observer observer) {
observers.remove(observer);
}
public void notifyObservers() {
for (Observer observer : observers) {
observer.update(message);
}
}
public void setMessage(String message) {
this.message = message;
notifyObservers();
}
}
class ConcreteObserver implements Observer {
private String name;
public ConcreteObserver(String name) {
this.name = name;
}
@Override
public void update(String message) {
System.out.println(name + " received message: " + message);
}
}
// 使用观察者模式
public class ObserverPatternDemo {
public static void main(String[] args) {
ConcreteSubject subject = new ConcreteSubject();
Observer observer1 = new ConcreteObserver("Observer1");
Observer observer2 = new ConcreteObserver("Observer2");
subject.attach(observer1);
subject.attach(observer2);
subject.setMessage("Hello Observers!");
}
}
在上述代码中，我们定义了 Observer 和 Subject 两个接口，以及实现这些接口的具体类 ConcreteObserver 和 ConcreteSubject 。在 ConcreteSubject 的 setMessage 方法中，当消息更新时，会通知所有已注册的观察者。
运行上述代码，将会输出：
Observer1 received message: Hello Observers!
Observer2 received message: Hello Observers!
这表明观察者模式成功地将事件通知传递给了所有注册的观察者。
观察者模式在GUI编程、网络编程等领域都有广泛的应用。通过分离事件的发布者和订阅者，它可以极大地提高程序的灵活性和可维护性。
5. 设计模式在软件开发中的综合应用
5.1 组合模式与复合对象的管理
组合模式允许我们将对象组合成树形结构来表示部分以及整体层次。这样的设计允许客户端统一地处理单个对象和组合对象。组合模式的定义与优点主要体现在它能够使客户忽略不同对象与组合对象的差别，从而简化了客户端的代码。
5.1.1 组合模式的定义与优点
组合模式由两部分组成：Component 与 Composite。Component 是一个接口或抽象类，定义了个体和组合体共有的行为。Composite 则是一个具体的类，实现了 Component 接口，并且管理子对象。
classDiagram
class Component {
<<interface>>
+operation() void
}
class Composite {
+add(Component) void
+remove(Component) void
+operation() void
}
class Leaf {
+operation() void
}
Component <|.. Composite : implements
Component <|.. Leaf : implements
- 定义 ：组合模式定义了如何将单个对象与组合对象进行统一处理，使得它们都可被视为同样的类型。
- 优点 ：
- 统一接口：客户可以一致地处理单个对象和组合对象。
- 易于扩展：通过递归组合可以很容易地扩展新的复杂对象类型。
5.1.2 组合模式在文件系统中的运用
在文件系统中，文件（File）和目录（Directory）可以看作是组合模式的典型应用。目录可以包含多个文件和子目录，而文件则可以视为最基本的组件。
abstract class FileComponent {
protected String name;
public FileComponent(String name) {
this.name = name;
}
abstract void print(String structure);
}
class File extends FileComponent {
public File(String name) {
super(name);
}
@Override
void print(String structure) {
System.out.println(structure + name);
}
}
class Directory extends FileComponent {
private List<FileComponent> children = new ArrayList<>();
public Directory(String name) {
super(name);
}
public void add(FileComponent component) {
children.add(component);
}
public void remove(FileComponent component) {
children.remove(component);
}
@Override
void print(String structure) {
System.out.println(structure + name);
for (FileComponent component : children) {
component.print(structure + " ");
}
}
}
通过这种方式，我们可以创建一个文件系统的层次结构，并且以一种统一的方式打印出文件系统的结构，无论是文件还是目录。
5.2 享元模式优化资源使用
享元模式是结构型设计模式之一，它的核心思想是运用共享技术来支持大量细粒度的对象，以减少内存占用和提高性能。
5.2.1 享元模式的实现机制
享元模式主要由享元（Flyweight）、享元工厂（FlyweightFactory）和客户端（Client）三部分组成。
classDiagram
class Flyweight {
<<interface>>
+operation(String) void
}
class ConcreteFlyweight {
+operation(String)
}
class FlyweightFactory {
+getFlyweight(String) Flyweight
}
class Client {
+main()
}
Flyweight <|.. ConcreteFlyweight : implements
FlyweightFactory --> ConcreteFlyweight : uses
Client --> FlyweightFactory : uses
- 享元 ：定义享元对象的接口，可以为具体享元对象所共享的操作。
- 具体享元 ：实现享元接口，并为内部状态增加存储空间。
- 享元工厂 ：负责创建并管理享元对象。
- 客户端 ：通过享元工厂获取享元对象，并维护外部状态。
5.2.2 享元模式在内存管理中的应用
在内存管理中，尤其是游戏开发或图形界面的应用中，享元模式非常有用，因为它可以复用大量的细粒度对象，比如字体、按钮等。
class FlyweightFactory {
private static final Map<String, Flyweight> flyweights = new HashMap<>();
public static Flyweight getFlyweight(String intrinsicState) {
if (!flyweights.containsKey(intrinsicState)) {
flyweights.put(intrinsicState, new ConcreteFlyweight(intrinsicState));
}
return flyweights.get(intrinsicState);
}
}
class ConcreteFlyweight implements Flyweight {
private String intrinsicState;
public ConcreteFlyweight(String intrinsicState) {
this.intrinsicState = intrinsicState;
}
@Override
public void operation(String extrinsicState) {
// 操作只和内部状态有关
System.out.println("Flyweight with intrinsic state: " + intrinsicState +
" and extrinsic state: " + extrinsicState);
}
}
在这个例子中，享元模式通过维护一个享元池来实现共享，当客户请求一个享元对象时，享元工厂首先检查是否已经创建了这个对象，如果已经创建了，则直接返回已存在的享元对象。
5.3 访问者模式的场景扩展
访问者模式是一种将算法与对象结构分离的行为型设计模式，它允许在不改变对象结构的前提下，为对象结构中的对象添加新的操作。
5.3.1 访问者模式的灵活运用
访问者模式由访问者（Visitor）、具体访问者（ConcreteVisitor）、元素（Element）、具体元素（ConcreteElement）、对象结构（ObjectStructure）等几个主要部分组成。
classDiagram
class Visitor {
<<interface>>
+visit(ConcreteElement) void
}
class ConcreteVisitor {
+visit(ConcreteElement)
}
class Element {
<<interface>>
+accept(Visitor)
}
class ConcreteElement {
+accept(Visitor)
}
class ObjectStructure {
+attach(Element)
+detach(Element)
+accept(Visitor)
}
Visitor <|.. ConcreteVisitor : implements
Element <|.. ConcreteElement : implements
ObjectStructure --> Element : contains
- 访问者 ：定义访问操作。
- 具体访问者 ：实现每个访问操作。
- 元素 ：定义一个接受访问操作的方法。
- 具体元素 ：实现接受访问者的方法。
- 对象结构 ：管理元素集合，并提供一个接口来让访问者访问。
5.3.2 访问者模式在复杂系统的适用性
在复杂的系统中，特别是当对象结构稳定而算法经常变化时，访问者模式非常适用。例如，在一个图形编辑器中，我们可以使用访问者模式来为不同的图形元素实现不同的操作，如渲染、格式化、缩放等。
class ConcreteVisitor implements Visitor {
@Override
public void visit(ConcreteElement element) {
// 实现具体的访问操作
System.out.println("ConcreteVisitor is visiting " + element.getClass().getSimpleName());
}
}
class ElementA implements Element {
@Override
public void accept(Visitor visitor) {
visitor.visit(this);
}
public void operationA() {
System.out.println("ElementA operation");
}
}
class ElementB implements Element {
@Override
public void accept(Visitor visitor) {
visitor.visit(this);
}
public void operationB() {
System.out.println("ElementB operation");
}
}
class ObjectStructure {
private List<Element> elements = new ArrayList<>();
public void attach(Element element) {
elements.add(element);
}
public void detach(Element element) {
elements.remove(element);
}
public void accept(Visitor visitor) {
for (Element element : elements) {
element.accept(visitor);
}
}
}
在这个例子中，访问者模式允许我们通过增加新的访问者类来添加新的功能，而不需要修改元素类的代码，这极大地提高了系统的扩展性和灵活性。
通过上述几个章节的详细探讨，我们可以看到设计模式在软件开发中的应用非常广泛且深入，它们提供了一种解决问题的最佳实践，使系统更灵活、更易于扩展和维护。
简介：《Headfirst设计模式》是面向对象设计模式的入门佳作，通过生动实例讲解了核心设计模式。该压缩包文件包含了书中提及的设计模式源代码，有助于读者直观理解模式实现。内容涵盖了单例、工厂、抽象工厂、建造者、原型、观察者、装饰者、代理、适配器、桥接、组合、享元、职责链、命令和访问者模式的Java源代码实现，以及这些模式如何在实践中提供可读性与可维护性。
扫一扫
4818
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
