diff --git a/README.md b/README.md
index d063550..43d1991 100644
--- a/README.md
+++ b/README.md
@@ -230,26 +230,26 @@ double 体重 = 999999999999.9; // 双精度浮点数: 2^-1074到(2-2^-52)*2^102
 
 上一讲的四则运算类中,已经尝试了4种运算符. 变量运算的结果可以赋给自己,或者另一个变量.
 
-举个例子,某投资方法,可以有8%的年回报率,那么1000元的初始投入资金,3年之后会变成多少.下面是一个很直白的计算方法:
+举个例子, 如2岁的时候认识一个字，每年增加两倍, 3年之后会变成多少.下面是一个很直白的计算方法:
 ```
-class 投资回报 {
+class 识字类 {
   public static void main (String[] 参数) {
-    float 账户余额 = 1000f;
-    float 回报率 = 0.08f;
+    int 识字量 = 1;
+    int 每年增倍数 = 2;
 
     // 第一年
-    账户余额 = (1 + 回报率) * 账户余额;
+    识字量 = (1 + 每年翻倍数) * 识字量;
 
     // 第二年
-    账户余额 = (1 + 回报率) * 账户余额;
+    识字量 = (1 + 每年翻倍数) * 识字量;
 
     // 第三年
-    账户余额 = (1 + 回报率) * 账户余额;
-    System.out.println("三年后变成" + 账户余额 + "元");
+    识字量 = (1 + 每年翻倍数) * 识字量;
+    System.out.println("三年后认识" + 识字量 + "个字咯");
   }
 }
 ```
-你的感觉没错, 它看起来就很累赘, 而且如果要算20年后呢?
+你的感觉没错, 它看起来就很累赘, 而且如果要算10年后呢?
 
 恭喜! 你已经有了判断代码优劣的直觉. 至于改进方法,留个悬念吧.
 
@@ -345,50 +345,50 @@ if ("辛苦".equals("不辛苦")) {
 扩展资料: &&, ||, switch, ?:, 字符串比较
 
 ## 八 直到...一直...
-记得算投资回报的程序么? 如果要算20年, 难道必须重复20行"账户余额 = (1 + 回报率) * 账户余额;"吗? 用脚趾想也不可能吧.
+记得算识字量的程序么? 如果要算10年, 难道必须重复10行`识字量 = (1 + 每年翻倍数) * 识字量;`吗? 用脚趾想也不可能吧.
 
-在写代码之前, 不妨先构思一下该怎么算. 这里多了一个输入值: 年限. 照原来的思路应该是: 每过一年增一次值, 直到过了20年. 这样就需要记着过了多少年. 之前提到, 一个变量用来"记"变化的值最合适:
+在写代码之前, 不妨先构思一下该怎么算. 这里多了一个输入值: 年限. 照原来的思路应该是: 每过一年增加一次识字量, 直到过了10年. 这样就需要记着过了多少年. 之前提到, 一个变量用来"记"变化的值最合适:
 ```
 for (int 年份 = 0; 年份 < 年限; 年份 = 年份 + 1) {
-  账户余额 = (1 + 回报率) * 账户余额;
+  识字量 = (1 + 每年翻倍数) * 识字量;
 }
 ```
 上面的代码反映了我们的思路: 
 - 1 变量"年份"初始值是0
-- 2 如果它小于20, 说明没到20年, 那么就运行{}的内容, 增一次值; 如果到了20年, 就结束循环
+- 2 如果它小于10, 说明没到10年, 那么就运行{}的内容, 增一次识字量; 如果到了10年, 就结束循环
 - 3 "年份"加一, 继续执行第2步
 
 同样的循环用while的格式来写是这样:
 ```
 int 年份 = 0;
 while (年份 < 年限) {
-  账户余额 = (1 + 回报率) * 账户余额;
+  识字量 = (1 + 每年翻倍数) * 识字量;
   年份 = 年份 + 1;
 }
 ```
 看起来for循环更紧凑, 也更不容易写错. while循环里,如果忘写了"年份 = 年份 + 1;",可就有趣了,因为年份没有增加, 循环中止条件一直不能满足(0永远小于年限), 代码运行停不下来,俗称"死循环". 而for循环里因为定了"(初始化; 循环条件; 累加或递减执行语句)"的格式, 少了一项会很扎眼.
 
-如果想要提前结束循环,可以用break. 想知道过几年能赚到2000的话:
+如果想要提前结束循环,可以用break. 想知道过几年能认识中文的常用三千字的话:
 ```
 int 年份 = 0;
 while (年份 < 年限) {
-  if (账户余额 > 2000) {
+  if (识字量 > 3000) {
     break;
   }
-  账户余额 = (1 + 回报率) * 账户余额;
+  识字量 = (1 + 每年翻倍数) * 识字量;
   年份 = 年份 + 1;
 }
-System.out.println(年份 + "年后变成" + 账户余额 + "元");
+System.out.println(年份 + "年后认识" + 识字量 + "个字");
 ```
 break执行后,它所在的循环就被打断,程序从循环之后开始执行.
 
-如果想要循环继续执行,但是跳过循环内的部分代码,可以用continue. 一个牵强的例子,如果从第三年才开始有回报:
+如果想要循环继续执行,但是跳过循环内的部分代码,可以用continue. 一个牵强的例子,如果从第三年才开始认识新字(比如在国外呆了三年):
 ```
 for (int 年份 = 0; 年份 < 年限; 年份 = 年份 + 1) {
   if (年份 < 3) {
     continue;
   }
-  账户余额 = (1 + 回报率) * 账户余额;
+  识字量 = (1 + 每年翻倍数) * 识字量;
 }
 ```
 注: 有更简短的实现方法, 这个例子只为了演示continue的用处.
diff --git "a/\350\257\206\345\255\227\345\276\252\347\216\257\347\261\273.java" "b/\350\257\206\345\255\227\345\276\252\347\216\257\347\261\273.java"
new file mode 100644
index 0000000..a07e6d1
--- /dev/null
+++ "b/\350\257\206\345\255\227\345\276\252\347\216\257\347\261\273.java"
@@ -0,0 +1,17 @@
+class 识字循环类 {
+  public static void main (String[] 参数) {
+    int 识字量 = 1;
+    int 每年翻倍数 = 2;
+    int 年限 = 10;
+    int 年份 = 0;
+
+    while (年份 < 年限) {
+      if (识字量 > 3000) {
+        break;
+      }
+      识字量 = (1 + 每年翻倍数) * 识字量;
+      年份 = 年份 + 1;
+    }
+    System.out.println(年份 + "年后认识" + 识字量 + "个字");
+  }
+}
diff --git "a/\350\257\206\345\255\227\347\261\273.java" "b/\350\257\206\345\255\227\347\261\273.java"
new file mode 100644
index 0000000..d4fccc2
--- /dev/null
+++ "b/\350\257\206\345\255\227\347\261\273.java"
@@ -0,0 +1,16 @@
+class 识字类 {
+  public static void main (String[] 参数) {
+    int 识字量 = 1;
+    int 每年翻倍数 = 2;
+
+    // 第一年
+    识字量 = (1 + 每年翻倍数) * 识字量;
+
+    // 第二年
+    识字量 = (1 + 每年翻倍数) * 识字量;
+
+    // 第三年
+    识字量 = (1 + 每年翻倍数) * 识字量;
+    System.out.println("三年后认识" + 识字量 + "个字咯");
+  }
+}
\ No newline at end of file