modify readme

Author: jarry

README.md

@@ -1,12 +1,99 @@
-# design-pattern说明
+# Design Pattern 设计模式
 
-    设计模式例子，结合实际场景，用不同语言来实现，包括Java/JS/Python/Go/C等
-      
-    the design pattern example, using Java/JS/Python/Go/C etc.
+包括23种经典设计模式的源码例子，结合实际场景，充分注释说明，每一行代码都经过检验，确保可靠。
+
+用不同语言来实现，包括Java/JS/Python/TypeScript/Go等。
+    
+Including 23 source code examples of classic design patterns, which are fully annotated in combination with actual scenarios. Every line of code has been verified to ensure reliability.
+
+Implemented in different languages, including Java/JS/Python/TypeScript/Go, etc.
 
 ## 设计模式结构图
 
 <img src="./docs/design-pattern.png">
 
-## 查看代码
-[演示例子](https://microwind.github.io/design-pattern/)
+## 源码例子
+
+### 创建型
+- 工厂模式（Factory Pattern），由工厂类提供统一的创建对象的方法。
+[Java](./factory-pattern/java) | [JavaScript](./factory-pattern/js) | [Python](./factory-pattern/python) | [TypeScript](./factory-pattern/ts)  | [Go](./factory-pattern/go)
+
+- 抽象工厂模式（Abstract Factory Pattern），是一个超级工厂，用来创建其他工厂方法。
+[Java](./abstract-factory/java) | [JavaScript](./abstract-factory/js) | [Python](./abstract-factory) | [TypeScript](./abstract-factory/ts)  | [Go](./abstract-factory/go)
+
+- 原型模式（Prototype Pattern），利用clone()复制已有对象的实例。
+[Java](./prototype-pattern/java) | [JavaScript](./prototype-pattern/js) | [Python](./prototype-pattern/python) | [TypeScript](./prototype-pattern/ts)  | [Go](./prototype-pattern/go)
+
+- 建造者模式（Builder Pattern），利用多个简单对象逐步构建一个复杂对象，类似建造房子。
+[Java](./builder-pattern/java) | [JavaScript](./builder-pattern/js) | [Python](./builder-pattern/python) | [TypeScript](./builder-pattern/ts)  | [Go](./builder-pattern/go)
+
+- 单例模式（Singleton Pattern），保证创建的类只有一个实例，并提供一个访问该实例的全局节点。
+[Java](./singleton-pattern/java) | [JavaScript](./singleton-pattern/js) | [Python](./singleton-pattern/python) | [TypeScript](./singleton-pattern/ts)  | [Go](./singleton-pattern/go)
+
+### 结构型
+- 适配器模式（Adapter Pattern），为两个不兼容的接口提供专门兼容方案。
+[Java](./adapter-pattern/java) | [JavaScript](./adapter-pattern/js) | [Python](./adapter-pattern/python) | [TypeScript](./adapter-pattern/ts)  | [Go](./adapter-pattern/go)
+
+- 桥接模式（Bridge Pattern），将类拆分为抽象和实现两个独立的层次结构进行解耦。
+[Java](./bridge-pattern/java) | [JavaScript](./bridge-pattern/js) | [Python](./bridge-pattern/python) | [TypeScript](./bridge-pattern/ts)  | [Go](./bridge-pattern/go)
+
+- 组合模式（Composite Pattern），依据树形结构来组合对象，用不同组件来构建某个部分或整体对象。
+[Java](./composite-pattern/java) | [JavaScript](./composite-pattern/js) | [Python](./composite-pattern/python) | [TypeScript](./composite-pattern/ts)  | [Go](./composite-pattern/go)
+
+- 装饰器模式（Decorator Pattern），将对象放入到一个特殊封装的对象中，赋予其新的能力。
+[Java](./decorator-pattern/java) | [JavaScript](./decorator-pattern/js) | [Python](./decorator-pattern/python) | [TypeScript](./decorator-pattern/ts)  | [Go](./decorator-pattern/go)
+
+- 外观模式（Facade Pattern），给现有的系统添加一个高层接口，隐藏子系统的复杂性。
+[Java](./facade-pattern/java) | [JavaScript](./facade-pattern/js) | [Python](./facade-pattern/python) | [TypeScript](./facade-pattern/ts)  | [Go](./facade-pattern/go)
+
+- 享元模式（Flyweight Pattern），通过共享多个对象的相同状态，让有限的内存容量载入更多对象。
+[Java](./flyweight-pattern/java) | [JavaScript](./flyweight-pattern/js) | [Python](./flyweight-pattern/python) | [TypeScript](./flyweight-pattern/ts)  | [Go](./flyweight-pattern/go)
+
+- 代理模式（Proxy Pattern），用一个类来代理另一个类或几个类的功能。
+[Java](./proxy-pattern/java) | [JavaScript](./proxy-pattern/js) | [Python](./proxy-pattern/python) | [TypeScript](./proxy-pattern/ts)  | [Go](./proxy-pattern/go)
+
+- 过滤器模式（Filter Pattern），使用不同的标准条件来过滤一组对象，并通过逻辑运算的方式把各条件连接起来。
+[Java](./filter-pattern/java) | [JavaScript](./filter-pattern/js) | [Python](./filter-pattern/python) | [TypeScript](./filter-pattern/ts)  | [Go](./filter-pattern/go)
+
+### 行为型
+- 策略模式（Strategy Pattern），将每一个算法策略封装到接口中，根据需要设定策略，使具体实现和策略解耦。
+[Java](./strategy-pattern/java) | [JavaScript](./strategy-pattern/js) | [Python](./strategy-pattern/python) | [TypeScript](./strategy-pattern/ts)  | [Go](./strategy-pattern/go)
+
+- 观察者模式（Observer Pattern），当主题对象的状态发生改变时，所有依赖对象都得到通知并被自动更新。
+[Java](./observer-pattern/java) | [JavaScript](./observer-pattern/js) | [Python](./observer-pattern/python) | [TypeScript](./observer-pattern/ts)  | [Go](./observer-pattern/go)
+
+- 迭代器模式（Iterator Pattern），给数据对象构建一套按顺序访问集合对象元素的方式。
+[Java](./iterator-pattern/java) | [JavaScript](./iterator-pattern/js) | [Python](./iterator-pattern/python) | [TypeScript](./iterator-pattern/ts)  | [Go](./iterator-pattern/go)
+
+- 模板方法模式（Template Method Pattern），定义了一个抽象公开类，包含基本的算法骨架，而将一些步骤延迟到子类中。
+[Java](./template-pattern/java) | [JavaScript](./template-pattern/js) | [Python](./template-pattern/python) | [TypeScript](./template-pattern/ts)  | [Go](./template-pattern/go)
+
+- 责任链模式（Chain of Responsibility Pattern），为请求创建了一个接收者对象的链，请求沿着处理者链进行发送和处理。
+[Java](./chain-responsibility/java) | [JavaScript](./chain-responsibility/js) | [Python](./chain-responsibility/python) | [TypeScript](./techain-responsibility/ts)  | [Go](./chain-responsibility/go)
+
+- 命令模式（Command Pattern），把请求以命令的形式包裹在对象中，并传给调用对象。
+[Java](./command-pattern/java) | [JavaScript](./command-pattern/js) | [Python](./command-pattern/python) | [TypeScript](./command-pattern/ts)  | [Go](./command-pattern/go)
+
+- 备忘录模式（Memento Pattern），将对象的状态捕捉住，并以备忘录的形式存储起来，以便合适的时候还原。
+[Java](./memento-pattern/java) | [JavaScript](./memento-pattern/js) | [Python](./memento-pattern/python) | [TypeScript](./memento-pattern/ts)  | [Go](./memento-pattern/go)
+
+- 状态模式（State Pattern），类的行为是基于它的状态改变的，不同的状态下有不同的行为。
+[Java](./state-pattern/java) | [JavaScript](./state-pattern/js) | [Python](./state-pattern/python) | [TypeScript](./state-pattern/ts)  | [Go](./state-pattern/go)
+
+- 访问者模式（Visitor Pattern），封装访问者类，把各元素类的操作集合起来，目的是将数据结构与数据操作分离。
+[Java](./visitor-pattern/java) | [JavaScript](./visitor-pattern/js) | [Python](./visitor-pattern/python) | [TypeScript](./visitor-pattern/ts)  | [Go](./visitor-pattern/go)
+
+- 中介者模式（Mediator Pattern），它用一个中介对象来封装一系列的动作，以让对象之间进行交流。
+[Java](./mediator-pattern/java) | [JavaScript](./mediator-pattern/js) | [Python](./mediator-pattern/python) | [TypeScript](./mediator-pattern/ts)  | [Go](./mediator-pattern/go)
+
+- 解释器模式（Interpreter Pattern），实现了一个表达式接口，并能解释特定的上下文里面的变量和语句。
+[Java](./interpreter-pattern/java) | [JavaScript](./interpreter-pattern/js) | [Python](./interpreter-pattern/python) | [TypeScript](./interpreter-pattern/ts)  | [Go](./interpreter-pattern/go)
+
+### 设计思想
+- MVC  [演示例子](./mvx/mvc)
+- MVP  [演示例子](./mvx/mvp)
+- MVVM [演示例子](./mvx/mvvm)
+- OOP [演示例子](./oop)
+
+
+### [查看全部源码](https://microwind.github.io/design-pattern/)

bridge-pattern/README.md

@@ -1,10 +1,10 @@
 # 简介
-桥接模式（Bridge Pattern）是一种结构型设计模式，它通过提供抽象化和实现化之间的桥接结构，来实现二者的解耦。
+桥接模式（Bridge Pattern）是一种结构型设计模式，它将一个大类或一系列紧密相关的类拆分为抽象和实现两个独立的层次结构，来实现二者的解耦。参与桥接的接口是稳定的，用户可以扩展和修改桥接中的类，但是不能改变接口。桥接模式通过接口继承实现或者类继承实现功能扩展。
 
 如果你希望在几个独立维度上扩展一个类，或者你想要拆分、重组一个具有多重功能的复杂类（例如能与多个数据库服务器进行交互的类），或者你想在运行时切换不同的实现方法，可以使用桥接模式。
 
 # 作用
-1. 在有多种可能会变化的情况下，用继承扩展起来不灵活.，桥接可以解决类似问题。
+1. 在有多种可能会变化的情况下，用继承扩展起来不灵活，桥接可以解决类似问题。
 2. 桥接模式提高了系统的可扩展性，在两个变化维度中任意扩展一个维度，都不需要修改原有系统。
 
 # 实现步骤

chain-responsibility/README.md

@@ -1,5 +1,5 @@
 # 简介
-责任链模式（Chain of Responsibility Pattern）是一种行为型设计模式，也叫职责链模式、命令链模式。这种模式为请求创建了一个接收者对象的链，允许你将请求沿着处理者链进行发送，每个处理者均可对请求进行处理， 或将其传递给链上的下个处理者。
+责任链模式（Chain of Responsibility Pattern）是一种行为型设计模式，也叫职责链模式、命令链模式。这种模式为请求创建了一个接收者对象的链，允许你将请求沿着处理者链进行发送，每个处理者均可对请求进行处理，或将其传递给链上的下个处理者。
 
 当程序需要使用不同方式来处理多种类请求，且请求类型和顺序不可知，或者当必须按顺序执行多个处理时，可以使用责任链模式。或者如果所需处理及其顺序必须在运行时进行改变，也可以使用该模式。
 

composite-pattern/README.md

@@ -1,5 +1,5 @@
 # 简介
-组合模式（Composite Pattern），又叫部分整体模式，是一种结构型设计模式。用于把一组类似的对象当作一个单一对象来看。组合模式依据树形结构来组合对象，用来构建某个部分或整体对象。
+组合模式（Composite Pattern），又叫部分整体模式，是一种结构型设计模式。用于把一组类似的对象当作一个单一的对象来看。组合模式依据树形结构来组合对象，用不同组件来构建某个部分或整体对象。
 
  如果你需要实现树状对象结构，可以使用组合模式。如果你希望客户端代码以相同方式处理简单和复杂元素，可以使用该模式。
 

facade-pattern/README.md

@@ -1,5 +1,5 @@
 # 简介
-外观模式（Facade Pattern），是一种结构型设计模式。它向现有的系统添加一个高层接口，隐藏子系统的复杂性，这个接口使得子系统更加容易使用。
+外观模式（Facade Pattern），也叫门面模式，是一种结构型设计模式。它向现有的系统添加一个高层接口，隐藏子系统的复杂性，这个接口使得子系统更加容易使用。
 
 如果你需要一个指向复杂子系统的直接接口，且该接口的功能有限，则可以使用外观模式。或者需要将子系统组织为多层结构，可以使用外观。
 

filter-pattern/README.md

@@ -1,5 +1,5 @@
 # 简介
-过滤器模式（Filter Pattern）或标准模式（Criteria Pattern），是一种结构型模式。这种模式允许开发人员使用不同的标准来过滤一组对象，通过逻辑运算以解耦的方式把它们连接起来，它结合多个标准来获得单一标准。
+过滤器模式（Filter Pattern）或标准模式（Criteria Pattern），是一种结构型模式。这种模式允许使用不同的标准条件来过滤一组对象，并通过逻辑运算的方式把各条件连接起来，它结合多个标准来获得单一标准。
 
 例子将创建一个 Person 对象、Criteria 接口和实现了该接口的实体类，来过滤 Person 对象的列表。Test 类使用 Criteria 对象，基于各种标准和它们的结合来过滤 Person 对象的列表。
 

iterator-pattern/README.md

@@ -1,5 +1,5 @@
 # 简介
-迭代器模式（Iterator Pattern），是一种结构型设计模式。这种模式用于顺序访问集合对象的元素，不需要知道集合对象的底层表示。
+迭代器模式（Iterator Pattern），是一种结构型设计模式。给数据对象构建一套按顺序访问集合对象元素的方式，而不需要知道数据对象的底层表示。
 
 迭代器模式是与集合共存的，我们只要实现一个集合，就需要同时提供这个集合的迭代器，就像Java中的Collection，List、Set、Map等，这些集合都有自己的迭代器。假如我们要实现一个这样的新的容器，就可以引入迭代器模式，给我们的容器实现一个迭代器。
 

mediator-pattern/README.md

@@ -1,5 +1,5 @@
 # 简介
-中介者模式（Mediator Pattern）是一种行为型模式。它限制对象之间的直接交互，而是通过一个中介者对象进行交流。
+中介者模式（Mediator Pattern）是一种行为型模式。它限制对象之间的直接交互，它用一个中介对象来封装一系列的动作，以让对象之间进行交流。中介者使各个对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。
 
 当一些对象和其他对象紧密耦合以致难以对其进行修改时，或当组件因过于依赖其他组件而无法在不同应用中复用时，可使用中介者模式。
 

proxy-pattern/README.md

@@ -1,5 +1,5 @@
 # 简介
-在代理模式（Proxy Pattern）是一种结构型设计模式，用一个类来代理另一个类或几个类的功能。
+代理模式（Proxy Pattern）是一种结构型设计模式，用一个类来代理另一个类或几个类的功能。
 
 在代理模式中，我们创建具有现有对象的对象，以便向外界提供功能接口。