java设计模式--组合模式、适配器模式

组合模式

组合模式（Composite Pattern）允许你将对象组合成树形结构来表示“部分-整体”的层次结构。组合模式让客户端可以统一地处理单个对象和组合对象。在这个模式中，组合对象（Composite）和叶子对象（Leaf）会实现相同的接口。

下面是一个使用组合模式的简单案例，我们将构建一个文件系统的表示，其中可以包含文件夹（组合对象）和文件（叶子对象）。

首先，定义一个公共接口 IFileSystemEntry，该接口将由文件夹和文件实现：

java

interface IFileSystemEntry {  
    void list();  
}
然后，定义叶子对象 File，它实现了 IFileSystemEntry 接口：

java
class File implements IFileSystemEntry {  
    private String name;  
  
    public File(String name) {  
        this.name = name;  
    }  
  
    @Override  
    public void list() {  
        System.out.println("File: " + name);  
    }  
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

接着，定义组合对象 Folder，它也实现了 IFileSystemEntry 接口，并且可以包含多个 IFileSystemEntry 对象（即文件夹或文件）：

java

import java.util.ArrayList;  
import java.util.List;  
  
class Folder implements IFileSystemEntry {  
    private String name;  
    private List<IFileSystemEntry> children = new ArrayList<>();  
  
    public Folder(String name) {  
        this.name = name;  
    }  
  
    public void add(IFileSystemEntry entry) {  
        children.add(entry);  
    }  
  
    @Override  
    public void list() {  
        System.out.println("Folder: " + name);  
        for (IFileSystemEntry entry : children) {  
            entry.list();  
        }  
    }  
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

最后，我们可以构建一个包含文件夹和文件的文件系统，并演示如何使用 list() 方法来列出所有文件和文件夹：

java

public class CompositePatternDemo {  
    public static void main(String[] args) {  
        // 创建文件夹和文件  
        Folder root = new Folder("root");  
        Folder folder1 = new Folder("folder1");  
        Folder folder2 = new Folder("folder2");  
        File file1 = new File("file1.txt");  
        File file2 = new File("file2.txt");  
  
        // 组织结构  
        root.add(folder1);  
        root.add(folder2);  
        folder1.add(file1);  
        folder2.add(file2);  
  
        // 打印文件系统  
        root.list();  
    }  
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

输出结果：

Folder: root  
Folder: folder1  
File: file1.txt  
Folder: folder2  
File: file2.txt
1
2
3
4
5

这个示例展示了组合模式的基本应用，即如何通过递归调用 list() 方法来统一处理文件和文件夹的列表展示。

适配器模式

适配器模式（Adapter Pattern）是一种结构型设计模式，它允许一个接口（通常是新的或现有的）与另一个不兼容的接口一起工作。适配器模式主要用于解决接口不匹配的问题，让原本由于接口不兼容而不能一起工作的类可以一起工作。

下面，我将通过一个简单的例子来展示适配器模式的应用。假设我们有一个老式的电源插座（两孔插座），但我们想使用一个需要三孔插座的电器设备。为了解决这个问题，我们可以使用一个电源适配器来转换插座类型。

定义接口
首先，我们定义两个接口，分别代表两孔插座和三孔插座：

java

// 两孔插座接口  
public interface TwoPinSocket {  
    void powerSupply();  
}  
  
// 三孔插座接口  
public interface ThreePinSocket {  
    void powerSupply();  
}
1
2
3
4
5
6
7
8
9

实现接口
然后，我们实现这两个接口。假设我们有一个真实存在的两孔插座实现，但没有直接的三孔插座实现（因为我们要模拟的是通过适配器来适配的情况）：

java

// 两孔插座实现  
public class RealTwoPinSocket implements TwoPinSocket {  
    @Override  
    public void powerSupply() {  
        System.out.println("Providing power through two pins.");  
    }  
}  
1
2
3
4
5
6
7

// 假设没有直接的三孔插座实现，我们通过适配器来适配
适配器类
接下来，我们创建一个适配器类，这个类将两孔插座适配为三孔插座：
java

public class Adapter extends RealTwoPinSocket implements ThreePinSocket {  
    // 注意：这里我们继承自RealTwoPinSocket，但实现ThreePinSocket接口  
    // 适配器内部使用两孔插座的供电能力  
  
    @Override  
    public void powerSupply() {  
        // 调用两孔插座的供电方法  
        super.powerSupply();  
        // 可以在这里添加额外的逻辑来模拟三孔插座特有的功能，如果有的话  
        System.out.println("Adapting power for three pins.");  
    }  
}
1
2
3
4
5
6
7
8
9
10
11
12

客户端代码
最后，我们编写客户端代码来演示如何使用这个适配器：

java

public class Client {  
    public static void main(String[] args) {  
        // 创建一个两孔插座的实例  
        TwoPinSocket twoPinSocket = new RealTwoPinSocket();  
        // 但我们需要一个三孔插座，所以我们使用适配器  
        ThreePinSocket threePinSocket = new Adapter();  
  
        // 使用三孔插座供电  
        threePinSocket.powerSupply();  
        // 输出:  
        // Providing power through two pins.  
        // Adapting power for three pins.  
    }  
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

在这个例子中，Adapter 类将 RealTwoPinSocket 的功能适配成了 ThreePinSocket 接口所要求的形式，使得原本只能接受三孔插座的电器设备可以通过这个适配器使用两孔插座进行供电。这就是适配器模式的基本思想。