line 13 : 包装器 should be 装饰器 。
装饰器 is well known than 包装器  in China @xiaod-dev could you check this issue? > line 13 : 包装器 should be 装饰器 。
> 装饰器 is well known than 包装器 in China

Thank your feedback. the line 36 was corrected, and about the line13, the  original text is " Wrapper", not "decorator", so there is nothing go wrong with "包装器". 
careless grammer mistake in  zh/decorator/README.md
line 36:程序mple. First of all we have a simple troll implementing the troll interface
should be  程序example. First of all we have a simple troll implementing the troll interface
Thank you!
zh/decorator/README.md
zh/bridge/README.md zh/callback/README.md zh/command/README.md zh/decorator/README.md zh/dependency-injection/README.md zh/iterator/README.md zh/state/README.md zh/template-method/README.md
diff --git a/zh/bridge/README.md b/zh/bridge/README.md
new file mode 100644
index 000000000000..cd9f40ac496a
--- /dev/null
+++ b/zh/bridge/README.md
@@ -0,0 +1,205 @@
+---
+layout: pattern
+title: Bridge
+folder: bridge
+permalink: /patterns/bridge/
+categories: Structural
+tags:
+ - Gang of Four
+---
+
+## 又被称为
+
+手柄/身体模式
+
+## 目的
+
+将抽象与其实现分离，以便二者可以独立变化。
+
+## 解释
+
+真实世界例子
+
+> 考虑一下你拥有一种具有不同附魔的武器，并且应该允许将具有不同附魔的不同武器混合使用。 你会怎么做？ 为每个附魔创建每种武器的多个副本，还是只是创建单独的附魔并根据需要为武器设置它？ 桥接模式使您可以进行第二次操作。
+
+通俗的说
+
+> 桥接模式是一个更推荐组合而不是继承的模式。将实现细节从一个层次结构推送到具有单独层次结构的另一个对象。
+
+维基百科说
+
+> 桥接模式是软件工程中使用的一种设计模式，旨在“将抽象与其实现分离，从而使两者可以独立变化”
+
+**程序示例**
+
+翻译一下上面的武器示例。下面我们有武器的类层级：
+
+```java
+public interface Weapon {
+  void wield();
+  void swing();
+  void unwield();
+  Enchantment getEnchantment();
+}
+
+public class Sword implements Weapon {
+
+  private final Enchantment enchantment;
+
+  public Sword(Enchantment enchantment) {
+    this.enchantment = enchantment;
+  }
+
+  @Override
+  public void wield() {
+    LOGGER.info("The sword is wielded.");
+    enchantment.onActivate();
+  }
+
+  @Override
+  public void swing() {
+    LOGGER.info("The sword is swinged.");
+    enchantment.apply();
+  }
+
+  @Override
+  public void unwield() {
+    LOGGER.info("The sword is unwielded.");
+    enchantment.onDeactivate();
+  }
+
+  @Override
+  public Enchantment getEnchantment() {
+    return enchantment;
+  }
+}
+
+public class Hammer implements Weapon {
+
+  private final Enchantment enchantment;
+
+  public Hammer(Enchantment enchantment) {
+    this.enchantment = enchantment;
+  }
+
+  @Override
+  public void wield() {
+    LOGGER.info("The hammer is wielded.");
+    enchantment.onActivate();
+  }
+
+  @Override
+  public void swing() {
+    LOGGER.info("The hammer is swinged.");
+    enchantment.apply();
+  }
+
+  @Override
+  public void unwield() {
+    LOGGER.info("The hammer is unwielded.");
+    enchantment.onDeactivate();
+  }
+
+  @Override
+  public Enchantment getEnchantment() {
+    return enchantment;
+  }
+}
+```
+
+这里是单独的附魔类结构：
+
+```java
+public interface Enchantment {
+  void onActivate();
+  void apply();
+  void onDeactivate();
+}
+
+public class FlyingEnchantment implements Enchantment {
+
+  @Override
+  public void onActivate() {
+    LOGGER.info("The item begins to glow faintly.");
+  }
+
+  @Override
+  public void apply() {
+    LOGGER.info("The item flies and strikes the enemies finally returning to owner's hand.");
+  }
+
+  @Override
+  public void onDeactivate() {
+    LOGGER.info("The item's glow fades.");
+  }
+}
+
+public class SoulEatingEnchantment implements Enchantment {
+
+  @Override
+  public void onActivate() {
+    LOGGER.info("The item spreads bloodlust.");
+  }
+
+  @Override
+  public void apply() {
+    LOGGER.info("The item eats the soul of enemies.");
+  }
+
+  @Override
+  public void onDeactivate() {
+    LOGGER.info("Bloodlust slowly disappears.");
+  }
+}
+```
+
+这里是两种层次结构的实践：
+
+```java
+var enchantedSword = new Sword(new SoulEatingEnchantment());
+enchantedSword.wield();
+enchantedSword.swing();
+enchantedSword.unwield();
+// The sword is wielded.
+// The item spreads bloodlust.
+// The sword is swinged.
+// The item eats the soul of enemies.
+// The sword is unwielded.
+// Bloodlust slowly disappears.
+
+var hammer = new Hammer(new FlyingEnchantment());
+hammer.wield();
+hammer.swing();
+hammer.unwield();
+// The hammer is wielded.
+// The item begins to glow faintly.
+// The hammer is swinged.
+// The item flies and strikes the enemies finally returning to owner's hand.
+// The hammer is unwielded.
+// The item's glow fades.
+```
+
+
+
+## 类图
+
+![alt text](../../bridge/etc/bridge.urm.png "Bridge class diagram")
+
+## 适用性
+
+使用桥接模式当
+
+* 你想永久性的避免抽象和他的实现之间的绑定。有可能是这种情况，当实现需要被选择或者在运行时切换。
+* 抽象和他们的实现应该能通过写子类来扩展。这种情况下，桥接模式让你可以组合不同的抽象和实现并独立的扩展他们。
+* 对抽象的实现的改动应当不会对客户产生影响；也就是说，他们的代码不必重新编译。
+* 你有种类繁多的类。这样的类层次结构表明需要将一个对象分为两部分。Rumbaugh 使用术语“嵌套归纳”来指代这种类层次结构。
+* 你想在多个对象间分享一种实现（可能使用引用计数），这个事实应该对客户隐藏。一个简单的示例是Coplien的String类，其中多个对象可以共享同一字符串表示形式
+
+## 教程
+
+* [Bridge Pattern Tutorial](https://www.journaldev.com/1491/bridge-design-pattern-java)
+
+## 鸣谢
+
+* [Design Patterns: Elements of Reusable Object-Oriented Software](https://www.amazon.com/gp/product/0201633612/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0201633612&linkCode=as2&tag=javadesignpat-20&linkId=675d49790ce11db99d90bde47f1aeb59)
+* [Head First Design Patterns: A Brain-Friendly Guide](https://www.amazon.com/gp/product/0596007124/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596007124&linkCode=as2&tag=javadesignpat-20&linkId=6b8b6eea86021af6c8e3cd3fc382cb5b)
diff --git a/zh/callback/README.md b/zh/callback/README.md
new file mode 100644
index 000000000000..a70a6a7c2210
--- /dev/null
+++ b/zh/callback/README.md
@@ -0,0 +1,79 @@
+---
+layout: pattern
+title: Callback
+folder: callback
+permalink: /patterns/callback/
+categories: Idiom
+tags:
+ - Reactive
+---
+
+## 目的
+回调是一部分被当为参数来传递给其他代码的可执行代码，接收方的代码可以在一些方便的时候来调用它。
+
+## 解释
+
+真实世界例子
+
+> 我们需要被通知当执行的任务结束时。我们为调用者传递一个回调方法然后等它调用通知我们。
+
+通俗的讲
+
+
+> 回调是一个用来传递给调用者的方法，它将在定义的时刻被调用。 
+
+维基百科说
+
+> 在计算机编程中，回调又被称为“稍后调用”函数，可以是任何可执行的代码用来作为参数传递给其他代码；其它代码被期望在给定时间内调用回调方法。
+
+**编程示例**
+
+回调是一个只有一个方法的简单接口。
+
+```java
+public interface Callback {
+
+  void call();
+}
+```
+
+下面我们定义一个任务它将在任务执行完成后执行回调。
+
+```java
+public abstract class Task {
+
+  final void executeWith(Callback callback) {
+    execute();
+    Optional.ofNullable(callback).ifPresent(Callback::call);
+  }
+
+  public abstract void execute();
+}
+
+public final class SimpleTask extends Task {
+
+  private static final Logger LOGGER = getLogger(SimpleTask.class);
+
+  @Override
+  public void execute() {
+    LOGGER.info("Perform some important activity and after call the callback method.");
+  }
+}
+```
+
+最后这里是我们如何执行一个任务然后接收一个回调当它完成时。
+
+```java
+    var task = new SimpleTask();
+    task.executeWith(() -> LOGGER.info("I'm done now."));
+```
+## 类图
+![alt text](../../callback/etc/callback.png "Callback")
+
+## 适用性
+使用回调模式当
+* 当一些同步或异步架构动作必须在一些定义好的活动执行后执行时。
+
+## Java例子
+
+* [CyclicBarrier](http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/CyclicBarrier.html#CyclicBarrier%28int,%20java.lang.Runnable%29) 构造函数可以接受回调，该回调将在每次障碍被触发时触发。
diff --git a/zh/command/README.md b/zh/command/README.md
new file mode 100644
index 000000000000..2c4f03a25997
--- /dev/null
+++ b/zh/command/README.md
@@ -0,0 +1,253 @@
+---
+layout: pattern
+title: Command
+folder: command
+permalink: /patterns/command/
+categories: Behavioral
+tags:
+ - Gang of Four
+---
+
+## 或称
+行动, 事务模式
+
+## 目的
+将请求封装为对象，从而使你可以将具有不同请求的客户端参数化，队列或记录请求，并且支持可撤销操作。
+
+## 解释
+真实世界例子
+
+> 有一个巫师在地精上施放咒语。咒语在地精上一一执行。第一个咒语使地精缩小，第二个使他不可见。然后巫师将咒语一个个的反转。这里的每一个咒语都是一个可撤销的命令对象。
+
+用通俗的话说
+
+> 用命令对象的方式存储请求以在将来时可以执行它或撤销它。
+
+维基百科说
+
+> 在面向对象编程中，命令模式是一种行为型设计模式，它把在稍后执行的一个动作或触发的一个事件所需要的所有信息封装到一个对象中。
+
+**编程示例**
+
+这是巫师和地精的示例代码。让我们从巫师类开始。
+
+```java
+public class Wizard {
+
+  private static final Logger LOGGER = LoggerFactory.getLogger(Wizard.class);
+
+  private final Deque<Command> undoStack = new LinkedList<>();
+  private final Deque<Command> redoStack = new LinkedList<>();
+
+  public Wizard() {}
+
+  public void castSpell(Command command, Target target) {
+    LOGGER.info("{} casts {} at {}", this, command, target);
+    command.execute(target);
+    undoStack.offerLast(command);
+  }
+
+  public void undoLastSpell() {
+    if (!undoStack.isEmpty()) {
+      var previousSpell = undoStack.pollLast();
+      redoStack.offerLast(previousSpell);
+      LOGGER.info("{} undoes {}", this, previousSpell);
+      previousSpell.undo();
+    }
+  }
+
+  public void redoLastSpell() {
+    if (!redoStack.isEmpty()) {
+      var previousSpell = redoStack.pollLast();
+      undoStack.offerLast(previousSpell);
+      LOGGER.info("{} redoes {}", this, previousSpell);
+      previousSpell.redo();
+    }
+  }
+
+  @Override
+  public String toString() {
+    return "Wizard";
+  }
+}
+```
+
+接下来我们介绍咒语层级
+
+```java
+public interface Command {
+
+  void execute(Target target);
+
+  void undo();
+
+  void redo();
+
+  String toString();
+}
+
+public class InvisibilitySpell implements Command {
+
+  private Target target;
+
+  @Override
+  public void execute(Target target) {
+    target.setVisibility(Visibility.INVISIBLE);
+    this.target = target;
+  }
+
+  @Override
+  public void undo() {
+    if (target != null) {
+      target.setVisibility(Visibility.VISIBLE);
+    }
+  }
+
+  @Override
+  public void redo() {
+    if (target != null) {
+      target.setVisibility(Visibility.INVISIBLE);
+    }
+  }
+
+  @Override
+  public String toString() {
+    return "Invisibility spell";
+  }
+}
+
+public class ShrinkSpell implements Command {
+
+  private Size oldSize;
+  private Target target;
+
+  @Override
+  public void execute(Target target) {
+    oldSize = target.getSize();
+    target.setSize(Size.SMALL);
+    this.target = target;
+  }
+
+  @Override
+  public void undo() {
+    if (oldSize != null && target != null) {
+      var temp = target.getSize();
+      target.setSize(oldSize);
+      oldSize = temp;
+    }
+  }
+
+  @Override
+  public void redo() {
+    undo();
+  }
+
+  @Override
+  public String toString() {
+    return "Shrink spell";
+  }
+}
+```
+
+最后我们有咒语的目标地精。
+
+```java
+public abstract class Target {
+
+  private static final Logger LOGGER = LoggerFactory.getLogger(Target.class);
+
+  private Size size;
+
+  private Visibility visibility;
+
+  public Size getSize() {
+    return size;
+  }
+
+  public void setSize(Size size) {
+    this.size = size;
+  }
+
+  public Visibility getVisibility() {
+    return visibility;
+  }
+
+  public void setVisibility(Visibility visibility) {
+    this.visibility = visibility;
+  }
+
+  @Override
+  public abstract String toString();
+
+  public void printStatus() {
+    LOGGER.info("{}, [size={}] [visibility={}]", this, getSize(), getVisibility());
+  }
+}
+
+public class Goblin extends Target {
+
+  public Goblin() {
+    setSize(Size.NORMAL);
+    setVisibility(Visibility.VISIBLE);
+  }
+
+  @Override
+  public String toString() {
+    return "Goblin";
+  }
+
+}
+```
+
+最后是整个示例的实践。
+
+```java
+var wizard = new Wizard();
+var goblin = new Goblin();
+goblin.printStatus();
+// Goblin, [size=normal] [visibility=visible]
+wizard.castSpell(new ShrinkSpell(), goblin);
+// Wizard casts Shrink spell at Goblin
+goblin.printStatus();
+// Goblin, [size=small] [visibility=visible]
+wizard.castSpell(new InvisibilitySpell(), goblin);
+// Wizard casts Invisibility spell at Goblin
+goblin.printStatus();
+// Goblin, [size=small] [visibility=invisible]
+wizard.undoLastSpell();
+// Wizard undoes Invisibility spell
+goblin.printStatus();
+// Goblin, [size=small] [visibility=visible]
+```
+
+## 类图
+![alt text](../../command/etc/command.png "Command")
+
+## 适用性
+使用命令模式当你想
+
+* 通过操作将对象参数化。您可以使用回调函数（即，已在某处注册以便稍后调用的函数）以过程语言表示这种参数化。命令是回调的一种面向对象替代方案。
+* 在不同的时间指定，排队和执行请求。一个命令对象的生存期可以独立于原始请求。如果请求的接收方可以以地址空间无关的方式来表示，那么你可以将请求的命令对象传输到其他进程并在那里执行请求。
+* 支持撤销。命令的执行操作可以在命令本身中存储状态以反转其效果。命令接口必须有添加的反执行操作，该操作可以逆转上一次执行调用的效果。执行的命令存储在历史列表中。无限撤消和重做通过分别向后和向前遍历此列表来实现，分别调用unexecute和execute。
+* 支持日志记录更改，以便在系统崩溃时可以重新应用它们。通过使用加载和存储操作扩展命令接口，你可以保留更改的永久日志。从崩溃中恢复涉及从磁盘重新加载记录的命令，并通过执行操作重新执行它们。
+* 通过原始的操作来构建一个以高级操作围绕的系统。这种结构在支持事务的信息系统中很常见。事务封装了一组数据更改。命令模式提供了一种对事务进行建模的方法。命令具有公共接口，让你以相同的方式调用所有事务。该模式还可以通过新的事务来轻松扩展系统。
+
+## 典型用例
+
+* 保留请求历史
+* 实现回调功能
+* 实现撤销功能
+
+## Java世界例子
+
+* [java.lang.Runnable](http://docs.oracle.com/javase/8/docs/api/java/lang/Runnable.html)
+* [org.junit.runners.model.Statement](https://github.com/junit-team/junit4/blob/master/src/main/java/org/junit/runners/model/Statement.java)
+* [Netflix Hystrix](https://github.com/Netflix/Hystrix/wiki)
+* [javax.swing.Action](http://docs.oracle.com/javase/8/docs/api/javax/swing/Action.html)
+
+## 鸣谢
+
+* [Design Patterns: Elements of Reusable Object-Oriented Software](https://www.amazon.com/gp/product/0201633612/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0201633612&linkCode=as2&tag=javadesignpat-20&linkId=675d49790ce11db99d90bde47f1aeb59)
+* [Head First Design Patterns: A Brain-Friendly Guide](https://www.amazon.com/gp/product/0596007124/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596007124&linkCode=as2&tag=javadesignpat-20&linkId=6b8b6eea86021af6c8e3cd3fc382cb5b)
+* [Refactoring to Patterns](https://www.amazon.com/gp/product/0321213351/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0321213351&linkCode=as2&tag=javadesignpat-20&linkId=2a76fcb387234bc71b1c61150b3cc3a7)
+* [J2EE Design Patterns](https://www.amazon.com/gp/product/0596004273/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596004273&linkCode=as2&tag=javadesignpat-20&linkId=f27d2644fbe5026ea448791a8ad09c94)
diff --git a/zh/decorator/README.md b/zh/decorator/README.md
index ef23eda0b951..6163017afb0f 100644
--- a/zh/decorator/README.md
+++ b/zh/decorator/README.md
@@ -33,8 +33,6 @@ tags:
 
 以巨魔的为例。首先我有有一个简单的巨魔，实现了巨魔接口。
 
-程序mple. First of all we have a simple troll implementing the troll interface
-
 ```java
 public interface Troll {
   void attack();
diff --git a/zh/dependency-injection/README.md b/zh/dependency-injection/README.md
new file mode 100644
index 000000000000..061a55425836
--- /dev/null
+++ b/zh/dependency-injection/README.md
@@ -0,0 +1,101 @@
+---
+layout: pattern
+title: Dependency Injection
+folder: dependency-injection
+permalink: /patterns/dependency-injection/
+categories: Creational
+tags:
+ - Decoupling
+---
+
+## 目的
+
+依赖注入是一种软件设计模式，其中一个或多个依赖项（或服务）被注入或通过引用传递到一个依赖对象（或客户端）中，并成为客户端状态的一部分。该模式将客户的依赖关系的创建与其自身的行为分开，这使程序设计可以松散耦合，并遵循控制反转和单一职责原则。
+
+## 解释
+
+真实世界例子
+
+> 老巫师喜欢不时地装满烟斗抽烟。 但是，他不想只依赖一个烟草品牌，而是希望能够互换使用它们。 
+
+通俗的说
+
+> 依赖注入将客户端依赖的创建与其自身行为分开。
+
+维基百科说
+
+> 在软件工程中，依赖注入是一种对象接收其依赖的其他对象的技术。 这些其他对象称为依赖项。
+
+**程序示例**
+
+先介绍一下烟草接口和具体的品牌。
+
+```java
+public abstract class Tobacco {
+
+  private static final Logger LOGGER = LoggerFactory.getLogger(Tobacco.class);
+
+  public void smoke(Wizard wizard) {
+    LOGGER.info("{} smoking {}", wizard.getClass().getSimpleName(),
+        this.getClass().getSimpleName());
+  }
+}
+
+public class SecondBreakfastTobacco extends Tobacco {
+}
+
+public class RivendellTobacco extends Tobacco {
+}
+
+public class OldTobyTobacco extends Tobacco {
+}
+```
+
+下面是老巫师的类的层次结构。
+
+```java
+public interface Wizard {
+
+  void smoke();
+}
+
+public class AdvancedWizard implements Wizard {
+
+  private final Tobacco tobacco;
+
+  public AdvancedWizard(Tobacco tobacco) {
+    this.tobacco = tobacco;
+  }
+
+  @Override
+  public void smoke() {
+    tobacco.smoke(this);
+  }
+}
+```
+
+最后我们可以看到给老巫师任意品牌的烟草是多么的简单。
+
+```java
+    var advancedWizard = new AdvancedWizard(new SecondBreakfastTobacco());
+    advancedWizard.smoke();
+```
+
+## 类图
+
+![alt text](../../dependency-injection/etc/dependency-injection.png "Dependency Injection")
+
+## 适用性
+
+使用依赖注入当：
+
+- 当你需要从对象中移除掉具体的实现内容时
+
+* 使用模拟对象或存根隔离地启用类的单元测试
+
+## 鸣谢
+
+* [Dependency Injection Principles, Practices, and Patterns](https://www.amazon.com/gp/product/161729473X/ref=as_li_qf_asin_il_tl?ie=UTF8&tag=javadesignpat-20&creative=9325&linkCode=as2&creativeASIN=161729473X&linkId=57079257a5c7d33755493802f3b884bd)
+* [Clean Code: A Handbook of Agile Software Craftsmanship](https://www.amazon.com/gp/product/0132350882/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0132350882&linkCode=as2&tag=javadesignpat-20&linkId=2c390d89cc9e61c01b9e7005c7842871)
+* [Java 9 Dependency Injection: Write loosely coupled code with Spring 5 and Guice](https://www.amazon.com/gp/product/1788296257/ref=as_li_tl?ie=UTF8&tag=javadesignpat-20&camp=1789&creative=9325&linkCode=as2&creativeASIN=1788296257&linkId=4e9137a3bf722a8b5b156cce1eec0fc1)
+* [Google Guice Tutorial: Open source Java based dependency injection framework](https://www.amazon.com/gp/product/B083P7DZ8M/ref=as_li_tl?ie=UTF8&tag=javadesignpat-20&camp=1789&creative=9325&linkCode=as2&creativeASIN=B083P7DZ8M&linkId=04f0f902c877921e45215b624a124bfe)
diff --git a/zh/iterator/README.md b/zh/iterator/README.md
new file mode 100644
index 000000000000..0b9db9e43769
--- /dev/null
+++ b/zh/iterator/README.md
@@ -0,0 +1,134 @@
+---
+layout: pattern
+title: Iterator
+folder: iterator
+permalink: /patterns/iterator/
+categories: Behavioral
+tags:
+ - Gang of Four
+---
+
+## 又被称为
+游标
+
+## 目的
+提供一种在不暴露其基础表示的情况下顺序访问聚合对象的元素的方法。
+
+## 解释
+
+真实世界例子
+
+> 百宝箱包含一组魔法物品。有多种物品，例如戒指，药水和武器。可以使用藏宝箱提供的迭代器按类型浏览商品。
+
+通俗地说
+
+> 容器可以提供与表示形式无关的迭代器接口，以提供对元素的访问。
+
+维基百科说
+
+> 在面向对象的编程中，迭代器模式是一种设计模式，其中迭代器用于遍历容器并访问容器的元素。
+
+**程序示例**
+
+在我们的示例中包含物品的藏宝箱是主要类。
+
+```java
+public class TreasureChest {
+
+  private final List<Item> items;
+
+  public TreasureChest() {
+    items = List.of(
+        new Item(ItemType.POTION, "Potion of courage"),
+        new Item(ItemType.RING, "Ring of shadows"),
+        new Item(ItemType.POTION, "Potion of wisdom"),
+        new Item(ItemType.POTION, "Potion of blood"),
+        new Item(ItemType.WEAPON, "Sword of silver +1"),
+        new Item(ItemType.POTION, "Potion of rust"),
+        new Item(ItemType.POTION, "Potion of healing"),
+        new Item(ItemType.RING, "Ring of armor"),
+        new Item(ItemType.WEAPON, "Steel halberd"),
+        new Item(ItemType.WEAPON, "Dagger of poison"));
+  }
+
+  public Iterator<Item> iterator(ItemType itemType) {
+    return new TreasureChestItemIterator(this, itemType);
+  }
+
+  public List<Item> getItems() {
+    return new ArrayList<>(items);
+  }
+}
+
+public class Item {
+
+  private ItemType type;
+  private final String name;
+
+  public Item(ItemType type, String name) {
+    this.setType(type);
+    this.name = name;
+  }
+
+  @Override
+  public String toString() {
+    return name;
+  }
+
+  public ItemType getType() {
+    return type;
+  }
+
+  public final void setType(ItemType type) {
+    this.type = type;
+  }
+}
+
+public enum ItemType {
+
+  ANY, WEAPON, RING, POTION
+
+}
+```
+
+迭代器接口极度简单。
+
+```java
+public interface Iterator<T> {
+
+  boolean hasNext();
+
+  T next();
+}
+```
+
+在以下示例中，我们遍历在宝箱中找到的戒指类型物品。
+
+```java
+var itemIterator = TREASURE_CHEST.iterator(ItemType.RING);
+while (itemIterator.hasNext()) {
+  LOGGER.info(itemIterator.next().toString());
+}
+// Ring of shadows
+// Ring of armor
+```
+
+## 类图
+![alt text](../../iterator/etc/iterator_1.png "Iterator")
+
+## 适用性
+以下情况使用迭代器模式
+
+* 在不暴露其内部表示的情况下访问聚合对象的内容
+* 为了支持聚合对象的多种遍历方式
+* 提供一个遍历不同聚合结构的统一接口
+
+## Java世界例子
+
+* [java.util.Iterator](http://docs.oracle.com/javase/8/docs/api/java/util/Iterator.html)
+* [java.util.Enumeration](http://docs.oracle.com/javase/8/docs/api/java/util/Enumeration.html)
+
+## 鸣谢
+
+* [Design Patterns: Elements of Reusable Object-Oriented Software](https://www.amazon.com/gp/product/0201633612/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0201633612&linkCode=as2&tag=javadesignpat-20&linkId=675d49790ce11db99d90bde47f1aeb59)
+* [Head First Design Patterns: A Brain-Friendly Guide](https://www.amazon.com/gp/product/0596007124/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596007124&linkCode=as2&tag=javadesignpat-20&linkId=6b8b6eea86021af6c8e3cd3fc382cb5b)
diff --git a/zh/state/README.md b/zh/state/README.md
new file mode 100644
index 000000000000..6b46510e08bf
--- /dev/null
+++ b/zh/state/README.md
@@ -0,0 +1,155 @@
+---
+layout: pattern
+title: State
+folder: state
+permalink: /patterns/state/
+categories: Behavioral
+tags:
+ - Gang of Four
+---
+
+## 又被称为
+对象状态
+
+## 目的
+允许对象在内部状态改变时改变它的行为。对象看起来好像修改了它的类。
+
+## 解释
+真实世界例子
+
+> 当在长毛象的自然栖息地观察长毛象时，似乎它会根据情况来改变自己的行为。它开始可能很平静但是随着时间推移当它检测到威胁时它会对周围的环境感到愤怒和危险。
+
+通俗的说
+
+> 状态模式允许对象改变它的行为。
+
+维基百科说
+
+> 状态模式是一种允许对象在内部状态改变时改变它的行为的行为型设计模式。这种模式接近于有限状态机的概念。状态模式可以被理解为策略模式，它能够通过调用在模式接口中定义的方法来切换策略。
+
+**编程示例**
+
+这里是模式接口和它具体的实现。
+
+```java
+public interface State {
+
+  void onEnterState();
+
+  void observe();
+}
+
+public class PeacefulState implements State {
+
+  private static final Logger LOGGER = LoggerFactory.getLogger(PeacefulState.class);
+
+  private final Mammoth mammoth;
+
+  public PeacefulState(Mammoth mammoth) {
+    this.mammoth = mammoth;
+  }
+
+  @Override
+  public void observe() {
+    LOGGER.info("{} is calm and peaceful.", mammoth);
+  }
+
+  @Override
+  public void onEnterState() {
+    LOGGER.info("{} calms down.", mammoth);
+  }
+}
+
+public class AngryState implements State {
+
+  private static final Logger LOGGER = LoggerFactory.getLogger(AngryState.class);
+
+  private final Mammoth mammoth;
+
+  public AngryState(Mammoth mammoth) {
+    this.mammoth = mammoth;
+  }
+
+  @Override
+  public void observe() {
+    LOGGER.info("{} is furious!", mammoth);
+  }
+
+  @Override
+  public void onEnterState() {
+    LOGGER.info("{} gets angry!", mammoth);
+  }
+}
+```
+
+然后这里是包含状态的长毛象。
+
+```java
+public class Mammoth {
+
+  private State state;
+
+  public Mammoth() {
+    state = new PeacefulState(this);
+  }
+
+  public void timePasses() {
+    if (state.getClass().equals(PeacefulState.class)) {
+      changeStateTo(new AngryState(this));
+    } else {
+      changeStateTo(new PeacefulState(this));
+    }
+  }
+
+  private void changeStateTo(State newState) {
+    this.state = newState;
+    this.state.onEnterState();
+  }
+
+  @Override
+  public String toString() {
+    return "The mammoth";
+  }
+
+  public void observe() {
+    this.state.observe();
+  }
+}
+```
+
+然后这里是长毛象随着时间的推移后的整个行为示例。
+
+```java
+    var mammoth = new Mammoth();
+    mammoth.observe();
+    mammoth.timePasses();
+    mammoth.observe();
+    mammoth.timePasses();
+    mammoth.observe();
+    
+    // The mammoth gets angry!
+    // The mammoth is furious!
+    // The mammoth calms down.
+    // The mammoth is calm and peaceful.
+```
+
+## 类图
+![alt text](../../state/etc/state_1.png "State")
+
+## 适用性
+
+在以下两种情况下，请使用State模式
+
+* 对象的行为取决于它的状态，并且它必须在运行时根据状态更改其行为。
+* 根据对象状态的不同，操作有大量的条件语句。此状态通常由一个或多个枚举常量表示。通常，几个操作将包含此相同的条件结构。状态模式把条件语句的分支分别放入单独的类中。这样一来，你就可以将对象的状态视为独立的对象，该对象可以独立于其他对象而变化。
+
+## Java中例子
+
+* [javax.faces.lifecycle.Lifecycle#execute()](http://docs.oracle.com/javaee/7/api/javax/faces/lifecycle/Lifecycle.html#execute-javax.faces.context.FacesContext-) controlled by [FacesServlet](http://docs.oracle.com/javaee/7/api/javax/faces/webapp/FacesServlet.html), the behavior is dependent on current phase of lifecycle.
+* [JDiameter - Diameter State Machine](https://github.com/npathai/jdiameter/blob/master/core/jdiameter/api/src/main/java/org/jdiameter/api/app/State.java)
+
+## 鸣谢
+
+* [Design Patterns: Elements of Reusable Object-Oriented Software](https://www.amazon.com/gp/product/0201633612/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0201633612&linkCode=as2&tag=javadesignpat-20&linkId=675d49790ce11db99d90bde47f1aeb59)
+* [Head First Design Patterns: A Brain-Friendly Guide](https://www.amazon.com/gp/product/0596007124/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596007124&linkCode=as2&tag=javadesignpat-20&linkId=6b8b6eea86021af6c8e3cd3fc382cb5b)
+* [Refactoring to Patterns](https://www.amazon.com/gp/product/0321213351/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0321213351&linkCode=as2&tag=javadesignpat-20&linkId=2a76fcb387234bc71b1c61150b3cc3a7)
diff --git a/zh/template-method/README.md b/zh/template-method/README.md
new file mode 100644
index 000000000000..f848552c33c2
--- /dev/null
+++ b/zh/template-method/README.md
@@ -0,0 +1,145 @@
+---
+layout: pattern
+title: Template method
+folder: template-method
+permalink: /patterns/template-method/
+categories: Behavioral
+tags:
+ - Gang of Four
+---
+
+## 目的
+在一个操作中定义算法的骨架，将某些步骤推迟到子类。模板方法允许子类重新定义算法的某些步骤，而无需更改算法的结构。
+
+## 解释
+真实世界例子
+
+> 偷东西的一般步骤是相同的。 首先，选择目标，然后以某种方式使其迷惑，最后，你偷走了该物品。然而这些步骤有很多实现方式。
+
+通俗的说
+
+> 模板方法模式在父类中列出一般的步骤然后让具体的子类定义实现细节。
+
+维基百科说
+
+> 在面向对象的编程中，模板方法是Gamma等人确定的行为设计模式之一。在《设计模式》一书中。模板方法是父类中一个方法，通常是一个抽象父类，根据许多高级步骤定义了操作的骨架。这些步骤本身由与模板方法在同一类中的其他帮助程序方法实现。
+
+**编程示例**
+
+让我们首先介绍模板方法类及其具体实现。
+
+```java
+public abstract class StealingMethod {
+
+  private static final Logger LOGGER = LoggerFactory.getLogger(StealingMethod.class);
+
+  protected abstract String pickTarget();
+
+  protected abstract void confuseTarget(String target);
+
+  protected abstract void stealTheItem(String target);
+
+  public void steal() {
+    var target = pickTarget();
+    LOGGER.info("The target has been chosen as {}.", target);
+    confuseTarget(target);
+    stealTheItem(target);
+  }
+}
+
+public class SubtleMethod extends StealingMethod {
+
+  private static final Logger LOGGER = LoggerFactory.getLogger(SubtleMethod.class);
+
+  @Override
+  protected String pickTarget() {
+    return "shop keeper";
+  }
+
+  @Override
+  protected void confuseTarget(String target) {
+    LOGGER.info("Approach the {} with tears running and hug him!", target);
+  }
+
+  @Override
+  protected void stealTheItem(String target) {
+    LOGGER.info("While in close contact grab the {}'s wallet.", target);
+  }
+}
+
+public class HitAndRunMethod extends StealingMethod {
+
+  private static final Logger LOGGER = LoggerFactory.getLogger(HitAndRunMethod.class);
+
+  @Override
+  protected String pickTarget() {
+    return "old goblin woman";
+  }
+
+  @Override
+  protected void confuseTarget(String target) {
+    LOGGER.info("Approach the {} from behind.", target);
+  }
+
+  @Override
+  protected void stealTheItem(String target) {
+    LOGGER.info("Grab the handbag and run away fast!");
+  }
+}
+```
+
+这是包含模板方法的半身贼类。
+
+```java
+public class HalflingThief {
+
+  private StealingMethod method;
+
+  public HalflingThief(StealingMethod method) {
+    this.method = method;
+  }
+
+  public void steal() {
+    method.steal();
+  }
+
+  public void changeMethod(StealingMethod method) {
+    this.method = method;
+  }
+}
+```
+最后，我们展示半身人贼如何利用不同的偷窃方法。
+
+```java
+    var thief = new HalflingThief(new HitAndRunMethod());
+    thief.steal();
+    thief.changeMethod(new SubtleMethod());
+    thief.steal();
+```
+
+## 类图
+![alt text](../../template-method/etc/template-method_1.png "Template Method")
+
+## 适用性
+
+使用模板方法模式可以
+
+* 一次性实现一个算法中不变的部分并将其留给子类来实现可能变化的行为。
+* 子类之间的共同行为应分解并集中在一个共同类中，以避免代码重复。如Opdyke和Johnson所描述的，这是“重构概括”的一个很好的例子。你首先要确定现有代码中的差异，然后将差异拆分为新的操作。最后，将不同的代码替换为调用这些新操作之一的模板方法。
+* 控制子类扩展。您可以定义一个模板方法，该方法在特定点调用“ 钩子”操作，从而仅允许在这些点进行扩展
+
+## 教程
+
+* [Template-method Pattern Tutorial](https://www.journaldev.com/1763/template-method-design-pattern-in-java)
+
+## Java例子
+
+* [javax.servlet.GenericServlet.init](https://jakarta.ee/specifications/servlet/4.0/apidocs/javax/servlet/GenericServlet.html#init--): 
+Method `GenericServlet.init(ServletConfig config)` calls the parameterless method `GenericServlet.init()` which is intended to be overridden in subclasses.
+Method `GenericServlet.init(ServletConfig config)` is the template method in this example.
+
+## 鸣谢
+
+* [Design Patterns: Elements of Reusable Object-Oriented Software](https://www.amazon.com/gp/product/0201633612/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0201633612&linkCode=as2&tag=javadesignpat-20&linkId=675d49790ce11db99d90bde47f1aeb59)
+* [Head First Design Patterns: A Brain-Friendly Guide](https://www.amazon.com/gp/product/0596007124/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596007124&linkCode=as2&tag=javadesignpat-20&linkId=6b8b6eea86021af6c8e3cd3fc382cb5b)
+* [Refactoring to Patterns](https://www.amazon.com/gp/product/0321213351/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0321213351&linkCode=as2&tag=javadesignpat-20&linkId=2a76fcb387234bc71b1c61150b3cc3a7)
