feature: design patter

2026-05-25 04:17:17 +00:00 · 2023-10-31 15:17:07 +08:00
parent 4b8c957341
commit 32eda66409
29 changed files with 3809 additions and 16 deletions
--- a/Pattern/6.18.md
+++ b/Pattern/6.18.md
@@ -0,0 +1,172 @@
+# 组合模式
+
+## 定义
+在 GoF 的《设计模式》一书中，组合模式是这样定义的：
+> Compose objects into tree structure to represent part-whole hierarchies.Composite lets client treat individual objects and compositions of objects uniformly.
+翻译成中文就是：将一组对象组织（Compose）成树形结构，以表示一种“部分 - 整体”的层次结构。组合让客户端（在很多设计模式书籍中，“客户端”代指代码的使用者。）可以统一单个对象和组合对象的处理逻辑
+
+## 应用场景
+
+假设我们有这样一个需求：设计一个类来表示文件系统中的目录，能方便地实现下面这些功
+能：
+我们把文件和目录统一用 FileSystemNode 类来表示，并且通过 isFile 属性来区分。动态地添加、删除某个目录下的子目录或文件；统计指定目录下的文件个数；统计指定目录下的文件总大小。在下面的代码实现中，我们把文件和目录统一用 FileSystemNode 类来表示，并且通过 isFile 属性来区分
+
+```
+public class FileSystemNode {
+    private String path;
+    private boolean isFile;
+    private List<FileSystemNode> subNodes = new ArrayList<>();
+    public FileSystemNode(String path, boolean isFile) {
+        this.path = path;
+        this.isFile = isFile;
+    }
+    public int countNumOfFiles() {
+        if (isFile) {
+            return 1;
+        }
+        int numOfFiles = 0;
+        for (FileSystemNode fileOrDir : subNodes) {
+            numOfFiles += fileOrDir.countNumOfFiles();
+        }
+        return numOfFiles;
+    }
+    public long countSizeOfFiles() {
+        if (isFile) {
+            File file = new File(path);
+            if (!file.exists()) return 0;
+            return file.length();
+        }
+        long sizeofFiles = 0;
+        for (FileSystemNode fileOrDir : subNodes) {
+            sizeofFiles += fileOrDir.countSizeOfFiles();
+        }
+        return sizeofFiles; 
+    }
+    public String getPath() {
+        return path;
+    }
+    public void addSubNode(FileSystemNode fileOrDir) {
+        subNodes.add(fileOrDir);
+    }
+    public void removeSubNode(FileSystemNode fileOrDir) {
+        int size = subNodes.size();
+        int i = 0;
+        for (; i < size; ++i) {
+            if (subNodes.get(i).getPath().equalsIgnoreCase(fileOrDir.getPath())) {
+                break;
+            }
+        }
+        if (i < size) {
+            subNodes.remove(i);
+        }
+    }
+}
+```
+
+单纯从功能实现角度来说，上面的代码没有问题，已经实现了我们想要的功能。但是，如果我们开发的是一个大型系统，从扩展性（文件或目录可能会对应不同的操作）、业务建模（文件和目录从业务上是两个概念）、代码的可读性（文件和目录区分对待更加符合人们对业务的认知）的角度来说，我们最好对文件和目录进行区分设计，定义为 File 和 Directory 两个类。
+
+按照这个设计思路，我们对代码进行重构。重构之后的代码如下所示
+
+```
+public abstract class FileSystemNode {
+    protected String path;
+    public FileSystemNode(String path) {
+        this.path = path;
+    }
+    public abstract int countNumOfFiles();
+    public abstract long countSizeOfFiles();
+    public String getPath() {
+        return path;
+    }
+}
+public class File extends FileSystemNode {
+    public File(String path) {
+        super(path);
+    }
+    @Override
+    public int countNumOfFiles() {
+        return 1;
+    }
+    @Override
+    public long countSizeOfFiles() {
+        java.io.File file = new java.io.File(path);
+        if (!file.exists()) return 0;
+        return file.length();
+    }
+}
+
+public class Directory extends FileSystemNode {
+    private List<FileSystemNode> subNodes = new ArrayList<>();
+    public Directory(String path) {
+        super(path);
+    }
+    @Override
+    public int countNumOfFiles() {
+        int numOfFiles = 0;
+        for (FileSystemNode fileOrDir : subNodes) {
+            numOfFiles += fileOrDir.countNumOfFiles();
+        }
+        return numOfFiles;
+    }
+    @Override
+    public long countSizeOfFiles() {
+        long sizeofFiles = 0;
+        for (FileSystemNode fileOrDir : subNodes) {
+            sizeofFiles += fileOrDir.countSizeOfFiles();
+        }
+        return sizeofFiles;
+    }
+    public void addSubNode(FileSystemNode fileOrDir) {
+        subNodes.add(fileOrDir);
+    }
+    public void removeSubNode(FileSystemNode fileOrDir) {
+        int size = subNodes.size();
+        int i = 0;
+        for (; i < size; ++i) {
+            if (subNodes.get(i).getPath().equalsIgnoreCase(fileOrDir.getPath())) {
+                break;
+            }
+        }
+        if (i < size) {
+            subNodes.remove(i);
+        }
+    }
+}
+```
+文件和目录类都设计好了，我们来看，如何用它们来表示一个文件系统中的目录树结构。具体的代码示例如下所示
+```
+public class Demo {
+    public static void main(String[] args) {
+        Directory fileSystemTree = new Directory("/");
+        Directory node_my = new Directory("/meiying/");
+        Directory node_lbp = new Directory("/my/");
+        fileSystemTree.addSubNode(node_lbp);
+        fileSystemTree.addSubNode(node_lbp);
+        File node_lbp_a = new File("/meiying/a.txt");
+        File node_lbp_b = new File("/meiying/b.txt");
+        Directory node_lbp_movies = new Directory("/meiying/movies/");
+        node_lbp.addSubNode(node_lbp_a);
+        node_lbp.addSubNode(node_lbp_b);
+        node_lbp.addSubNode(node_lbp_movies);
+        File node_lbp_movies_c = new File("/meiying/movies/c.avi");
+        node_lbp_movies.addSubNode(node_lbp_movies_c);
+        Directory node_lbp_docs = new Directory("/xzg/docs/");
+        node_lbp.addSubNode(node_lbp_docs);
+        File node_lbp_docs_d = new File("/xzg/docs/d.txt");
+        node_lbp_docs.addSubNode(node_lbp_docs_d);
+        System.out.println("/ files num:" + fileSystemTree.countNumOfFiles());
+        System.out.println("/meiying/ files num:" + node_lbp.countNumOfFiles());
+    }
+}
+```
+对照例子，重新审视下组合模式：将一组对象（文件和目录）组织成树形结构，以表示一种“部分-整体”的层次结构（目录与子目录的嵌套结构）。组合模
+式让客户端可以统一单个对象（文件）和组合对象（目录）的处理逻辑（递归遍历）
+
+
+实际上，刚才讲的这种组合模式的设计思路，与其说是一种设计模式，倒不如说是对业务场景的一种数据结构和算法的抽象。其中，数据可以表示成树这种数据结构，业务需求可以通过在树上的递归遍历算法来实现。
+
+## 思考
+组合模式的设计思路，与其说是一种设计模式，倒不如说是对业务场景的一种数据结构和算法的抽象。其中，数据可以表示成树这种数据结构，业务需求可以通过在树上的递归遍历算法来实现。
+
+组合模式，将一组对象组织成树形结构，将单个对象和组合对象都看做树中的节点，以统一处理逻辑，并且它利用树形结构的特点，递归地处理每个子树，依次简化代码实现。使用组合模式的前提在于，你的业务场景必须能够表示成树形结构。所以，组合模式的应用场景也比较局限，它并不是一种很常用的设计模式。
+