auto commit

notes/HTTP.md

@@ -45,7 +45,7 @@
     * [二进制分帧层](#二进制分帧层)
     * [服务端推送](#服务端推送)
     * [首部压缩](#首部压缩)
-* [八、GET 和 POST 的区别](#八get-和-post-的区别)
+* [八、GET 和 POST 比较](#八get-和-post-比较)
     * [作用](#作用)
     * [参数](#参数)
     * [安全](#安全)
@@ -61,13 +61,13 @@
 
 ## URL
 
+URI 包含 URL 和 URN，目前 WEB 只有 URL 比较流行，所以见到的基本都是 URL。
+
 - URI（Uniform Resource Identifier，统一资源标识符）
 - URL（Uniform Resource Locator，统一资源定位符）
-- URN（Uniform Resource Name，统一资源名称），例如 urn:isbn:0-486-27557-4。
-
-URI 包含 URL 和 URN，目前 WEB 只有 URL 比较流行，所以见到的基本都是 URL。
+- URN（Uniform Resource Name，统一资源名称）
 
-<div align="center"> <img src="../pics//f716427a-94f2-4875-9c86-98793cf5dcc3.jpg" width="400"/> </div><br>
+<div align="center"> <img src="../pics//urlnuri.jpg" width="600"/> </div><br>
 
 ## 请求和响应报文
 
@@ -197,7 +197,7 @@ CONNECT www.example.com:443 HTTP/1.1
 
 -  **204 No Content** ：请求已经成功处理，但是返回的响应报文不包含实体的主体部分。一般在只需要从客户端往服务器发送信息，而不需要返回数据时使用。
 
--  **206 Partial Content** ：表示客户端进行了范围请求。响应报文包含由 Content-Range 指定范围的实体内容。
+-  **206 Partial Content** ：表示客户端进行了范围请求，响应报文包含由 Content-Range 指定范围的实体内容。
 
 ## 3XX 重定向
 
@@ -219,7 +219,7 @@ CONNECT www.example.com:443 HTTP/1.1
 
 -  **401 Unauthorized** ：该状态码表示发送的请求需要有认证信息（BASIC 认证、DIGEST 认证）。如果之前已进行过一次请求，则表示用户认证失败。
 
--  **403 Forbidden** ：请求被拒绝，服务器端没有必要给出拒绝的详细理由。
+-  **403 Forbidden** ：请求被拒绝。
 
 -  **404 Not Found** 
 
@@ -331,7 +331,7 @@ Set-Cookie: tasty_cookie=strawberry
 [page content]
 ```
 
-客户端之后对同一个服务器发送请求时，会从浏览器中读出 Cookie 信息通过 Cookie 请求首部字段发送给服务器。
+客户端之后对同一个服务器发送请求时，会从浏览器中取出 Cookie 信息并通过 Cookie 请求首部字段发送给服务器。
 
 ```html
 GET /sample_page.html HTTP/1.1
@@ -382,9 +382,9 @@ Path 标识指定了主机下的哪些路径可以接受 Cookie（该 URL 路径
 
 除了可以将用户信息通过 Cookie 存储在用户浏览器中，也可以利用 Session 存储在服务器端，存储在服务器端的信息更加安全。
 
-Session 可以存储在服务器上的文件、数据库或者内存中。也可以将 Session 存储在内存型数据库中，比如 Redis，效率会更高。
+Session 可以存储在服务器上的文件、数据库或者内存中。也可以将 Session 存储在 Redis 这种内存型数据库中，效率会更高。
 
-使用 Session 维护用户登录的过程如下：
+使用 Session 维护用户登录状态的过程如下：
 
 - 用户进行登录时，用户提交包含用户名和密码的表单，放入 HTTP 请求报文中；
 - 服务器验证该用户名和密码；
@@ -499,7 +499,7 @@ If-Modified-Since: Wed, 21 Oct 2015 07:28:00 GMT
 
 ### 1. 短连接与长连接
 
-当浏览器访问一个包含多张图片的 HTML 页面时，除了请求访问 HTML 页面资源，还会请求图片资源。如果每进行一次 HTTP 通信就要断开一次 TCP 连接，连接建立和断开的开销会很大。
+当浏览器访问一个包含多张图片的 HTML 页面时，除了请求访问 HTML 页面资源，还会请求图片资源。如果每进行一次 HTTP 通信就要新建一个 TCP 连接，那么开销会很大。
 
 长连接只需要建立一次 TCP 连接就能进行多次 HTTP 通信。
 
@@ -688,7 +688,7 @@ HTTPs 并不是新协议，而是让 HTTP 先和 SSL（Secure Sockets Layer）
 
 ### 3. HTTPs 采用的加密方式
 
-HTTPs 采用混合的加密机制，使用非对称密钥加密用于传输对称密钥来保证安全性，之后使用对称密钥加密进行通信来保证效率。（下图中的 Session Key 就是对称密钥）
+HTTPs 采用混合的加密机制，使用非对称密钥加密用于传输对称密钥来保证传输过程的安全性，之后使用对称密钥加密进行通信来保证通信过程的效率。（下图中的 Session Key 就是对称密钥）
 
 <div align="center"> <img src="../pics//How-HTTPS-Works.png" width="600"/> </div><br>
 
@@ -717,7 +717,7 @@ HTTPs 的报文摘要功能之所以安全，是因为它结合了加密和认
 ## HTTPs 的缺点
 
 - 因为需要进行加密解密等过程，因此速度会更慢；
-- 需要支付证书授权的高费用。
+- 需要支付证书授权的高额费用。
 
 ## 配置 HTTPs
 
@@ -727,7 +727,7 @@ HTTPs 的报文摘要功能之所以安全，是因为它结合了加密和认
 
 ## HTTP/1.x 缺陷
 
- HTTP/1.x 实现简单是以牺牲应用性能为代价的：
+ HTTP/1.x 实现简单是以牺牲性能为代价的：
 
 - 客户端需要使用多个连接才能实现并发和缩短延迟；
 - 不会压缩请求和响应首部，从而导致不必要的网络流量；
@@ -763,7 +763,7 @@ HTTP/2.0 要求客户端和服务器同时维护和更新一个包含之前见
 
 <div align="center"> <img src="../pics//_u4E0B_u8F7D.png" width="600"/> </div><br>
 
-# 八、GET 和 POST 的区别
+# 八、GET 和 POST 比较
 
 ## 作用
 
@@ -870,6 +870,7 @@ DELETE /idX/delete HTTP/1.1   -> Returns 404
 - [MDN : HTTP](https://developer.mozilla.org/en-US/docs/Web/HTTP)
 - [HTTP/2 简介](https://developers.google.com/web/fundamentals/performance/http2/?hl=zh-cn)
 - [htmlspecialchars](http://php.net/manual/zh/function.htmlspecialchars.php)
+- [Difference between file URI and URL in java](http://java2db.com/java-io/how-to-get-and-the-difference-between-file-uri-and-url-in-java)
 - [How to Fix SQL Injection Using Java PreparedStatement & CallableStatement](https://software-security.sans.org/developer-how-to/fix-sql-injection-in-java-using-prepared-callable-statement)
 - [浅谈 HTTP 中 Get 与 Post 的区别](https://www.cnblogs.com/hyddd/archive/2009/03/31/1426026.html)
 - [Are http:// and www really necessary?](https://www.webdancers.com/are-http-and-www-necesary/)

notes/Java 容器.md

@@ -25,7 +25,7 @@
 
 ## Collection
 
-<div align="center"> <img src="../pics//NP4z3i8m38Ntd28NQ4_0KCJ2q044Oez.png"/> </div><br>
+<div align="center"> <img src="../pics//VP4n3i8m34Ntd28NQ4_0KCJ2q044Oez.png"/> </div><br>
 
 ### 1. Set
 
@@ -129,12 +129,67 @@ private static final int DEFAULT_CAPACITY = 10;
 
 ArrayList 基于数组实现，并且具有动态扩容特性，因此保存元素的数组不一定都会被使用，那么就没必要全部进行序列化。
 
-保存元素的数组 elementData 使用 transient 修饰，该关键字声明数组默认不会被序列化。ArrayList 重写了 writeObject() 和 readObject() 来控制只序列化数组中有元素填充那部分内容。
+保存元素的数组 elementData 使用 transient 修饰，该关键字声明数组默认不会被序列化。
 
 ```java
 transient Object[] elementData; // non-private to simplify nested class access
 ```
 
+ArrayList 实现了 writeObject() 和 readObject() 来控制只序列化数组中有元素填充那部分内容。
+
+```java
+private void readObject(java.io.ObjectInputStream s)
+    throws java.io.IOException, ClassNotFoundException {
+    elementData = EMPTY_ELEMENTDATA;
+
+    // Read in size, and any hidden stuff
+    s.defaultReadObject();
+
+    // Read in capacity
+    s.readInt(); // ignored
+
+    if (size > 0) {
+        // be like clone(), allocate array based upon size not capacity
+        ensureCapacityInternal(size);
+
+        Object[] a = elementData;
+        // Read in all elements in the proper order.
+        for (int i=0; i<size; i++) {
+            a[i] = s.readObject();
+        }
+    }
+}
+```
+
+```java
+private void writeObject(java.io.ObjectOutputStream s)
+    throws java.io.IOException{
+    // Write out element count, and any hidden stuff
+    int expectedModCount = modCount;
+    s.defaultWriteObject();
+
+    // Write out size as capacity for behavioural compatibility with clone()
+    s.writeInt(size);
+
+    // Write out all elements in the proper order.
+    for (int i=0; i<size; i++) {
+        s.writeObject(elementData[i]);
+    }
+
+    if (modCount != expectedModCount) {
+        throw new ConcurrentModificationException();
+    }
+}
+```
+
+序列化时需要使用 ObjectOutputStream 的 writeObject() 将对象转换为字节流并输出。而 writeObject() 方法在传入的对象存在 writeObject() 的时候会去反射调用该对象的 writeObject() 来实现序列化。反序列化使用的是 ObjectInputStream 的 readObject() 方法，原理类似。
+
+```java
+ArrayList list = new ArrayList();
+ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file));
+oos.writeObject(list);
+```
+
 ### 3. 扩容
 
 添加元素时使用 ensureCapacityInternal() 方法来保证容量足够，如果不够时，需要使用 grow() 方法进行扩容，新容量的大小为 `oldCapacity + (oldCapacity >> 1)`，也就是旧容量的 1.5 倍。
@@ -1080,7 +1135,7 @@ Set <|.. LinkedHashSet
 SortSet <|.. TreeSet
 List <|.. ArrayList
 List <|.. Vector
-List <|.. LinkeList
+List <|.. LinkedList
 Queue <|.. LinkedList
 Queue <|.. PriorityQueue
 

notes/Leetcode-Database 题解.md

@@ -461,7 +461,7 @@ Employee 表：
 +----+-------+--------+-----------+
 ```
 
-查找所有员工，他们的薪资大于其经理薪资。
+查找薪资大于其经理薪资的员工信息。
 
 ## SQL Schema
 
@@ -924,27 +924,27 @@ VALUES
 ```sql
 SELECT
     s1.id - 1 AS id,
-    s1.student 
+    s1.student
 FROM
-    seat s1 
+    seat s1
 WHERE
     s1.id MOD 2 = 0 UNION
 SELECT
     s2.id + 1 AS id,
-    s2.student 
+    s2.student
 FROM
-    seat s2 
+    seat s2
 WHERE
-    s2.id MOD 2 = 1 
+    s2.id MOD 2 = 1
     AND s2.id != ( SELECT max( s3.id ) FROM seat s3 ) UNION
 SELECT
     s4.id AS id,
-    s4.student 
+    s4.student
 FROM
-    seat s4 
+    seat s4
 WHERE
-    s4.id MOD 2 = 1 
-    AND s4.id = ( SELECT max( s5.id ) FROM seat s5 ) 
+    s4.id MOD 2 = 1
+    AND s4.id = ( SELECT max( s5.id ) FROM seat s5 )
 ORDER BY
     id;
 ```

notes/攻击技术.md

@@ -29,7 +29,7 @@
 
 ## 危害
 
-- 窃取用户的 Cookie 值
+- 窃取用户的 Cookie
 - 伪造虚假的输入表单骗取个人信息
 - 显示伪造的文章或者图片
 
@@ -47,7 +47,7 @@
 
 富文本编辑器允许用户输入 HTML 代码，就不能简单地将 `<` 等字符进行过滤了，极大地提高了 XSS 攻击的可能性。
 
-富文本编辑器通常采用 XSS filter 来防范 XSS 攻击，可以定义一些标签白名单或者黑名单，从而不允许有攻击性的 HTML 代码的输入。
+富文本编辑器通常采用 XSS filter 来防范 XSS 攻击，通过定义一些标签白名单或者黑名单，从而不允许有攻击性的 HTML 代码的输入。
 
 以下例子中，form 和 script 等标签都被转义，而 h 和 p 等标签将会保留。
 
@@ -131,7 +131,7 @@ http://www.examplebank.com/withdraw?account=AccoutName&amount=1000&for=PayeeName
 <img src="http://www.examplebank.com/withdraw?account=Alice&amount=1000&for=Badman">。
 ```
 
-如果有账户名为 Alice 的用户访问了恶意站点，而她之前刚访问过银行不久，登录信息尚未过期，那么她就会损失 1000 资金。
+如果有账户名为 Alice 的用户访问了恶意站点，而她之前刚访问过银行不久，登录信息尚未过期，那么她就会损失 1000 美元。
 
 这种恶意的网址可以有很多种形式，藏身于网页中的许多地方。此外，攻击者也不需要控制放置恶意网址的网站。例如他可以将这种地址藏在论坛，博客等任何用户生成内容的网站中。这意味着如果服务器端没有合适的防御措施的话，用户即使访问熟悉的可信网站也有受攻击的危险。
 
@@ -153,8 +153,6 @@ Referer 首部字段位于 HTTP 报文中，用于标识请求来源的地址。
 
 因为 CSRF 攻击是在用户无意识的情况下发生的，所以要求用户输入验证码可以让用户知道自己正在做的操作。
 
-也可以要求用户输入验证码来进行校验。
-
 # 三、SQL 注入攻击
 
 ## 概念

notes/数据库系统原理.md

@@ -383,13 +383,13 @@ MVCC 不能解决幻读的问题，Next-Key Locks 就是为了解决这个问题
 
 ## Record Locks
 
-锁定的对象是记录的索引，而不是记录本身。
+锁定一个记录上的索引，而不是记录本身。
 
 如果表没有设置索引，InnoDB 会自动在主键上创建隐藏的聚集索引，因此 Record Locks 依然可以使用。
 
 ## Gap Locks
 
-锁定一个范围内的索引，例如当一个事务执行以下语句，其它事务就不能在 t.c 中插入 15。
+锁定索引之间的间隙，但是不包含索引本身。例如当一个事务执行以下语句，其它事务就不能在 t.c 中插入 15。
 
 ```sql
 SELECT c FROM t WHERE c BETWEEN 10 and 20 FOR UPDATE;
@@ -397,28 +397,14 @@ SELECT c FROM t WHERE c BETWEEN 10 and 20 FOR UPDATE;
 
 ## Next-Key Locks
 
-它是 Record Locks 和 Gap Locks 的结合，不仅锁定一个记录，也锁定范围内的索引。在 user 中有以下记录：
+它是 Record Locks 和 Gap Locks 的结合，不仅锁定一个记录上的索引，也锁定范围内的索引。例如一个索引包含以下值：10, 11, 13, and 20，那么就需要锁定以下区间：
 
 ```sql
-|   id | last_name   | first_name   |   age |
-|------|-------------|--------------|-------|
-|    4 | stark       | tony         |    21 |
-|    1 | tom         | hiddleston   |    30 |
-|    3 | morgan      | freeman      |    40 |
-|    5 | jeff        | dean         |    50 |
-|    2 | donald      | trump        |    80 |
-+------|-------------|--------------|-------+
-```
-
-那么就需要锁定以下范围：
-
-```sql
-(-∞, 21]
-(21, 30]
-(30, 40]
-(40, 50]
-(50, 80]
-(80, ∞)
+(negative infinity, 10]
+(10, 11]
+(11, 13]
+(13, 20]
+(20, positive infinity)
 ```
 
 # 七、关系数据库设计理论

notes/算法.md

@@ -1623,10 +1623,10 @@ private List<Key> keys(Node x, Key l, Key h) {
 
 ## 2-3 查找树
 
-<div align="center"> <img src="../pics//ff396233-1bb1-4e74-8bc2-d7c90146f5dd.png" width="250"/> </div><br>
-
 2-3 查找树引入了 2- 节点和 3- 节点，目的是为了让树平衡。一颗完美平衡的 2-3 查找树的所有空链接到根节点的距离应该是相同的。
 
+<div align="center"> <img src="../pics//ff396233-1bb1-4e74-8bc2-d7c90146f5dd.png" width="250"/> </div><br>
+
 ### 1. 插入操作
 
 插入操作和 BST 的插入操作有很大区别，BST 的插入操作是先进行一次未命中的查找，然后再将节点插入到对应的空链接上。但是 2-3 查找树如果也这么做的话，那么就会破坏了平衡性。它是将新节点插入到叶子节点上。
@@ -2042,24 +2042,26 @@ public class SparseVector {
 
 ## 汉诺塔
 
-这是一个经典的递归问题，分为三步求解：
-
-1. 将 n-1 个圆盘从 from -> buffer
-2. 将 1 个圆盘从 from -> to
-3. 将 n-1 个圆盘从 buffer -> to
-
-如果只有一个圆盘，那么只需要进行一次移动操作。
+<div align="center"> <img src="../pics//54f1e052-0596-4b5e-833c-e80d75bf3f9b.png" width="300"/> </div><br>
 
-从上面的讨论可以知道，a<sub>n</sub> = 2 * a<sub>n-1</sub> + 1，显然 a<sub>n</sub> = 2<sup>n</sup> - 1，n 个圆盘需要移动 2<sup>n</sup> - 1 次。
+这是一个经典的递归问题，分为三步求解：
 
-<div align="center"> <img src="../pics//54f1e052-0596-4b5e-833c-e80d75bf3f9b.png" width="300"/> </div><br>
+- 将 n-1 个圆盘从 from -> buffer
 
 <div align="center"> <img src="../pics//8587132a-021d-4f1f-a8ec-5a9daa7157a7.png" width="300"/> </div><br>
 
+- 将 1 个圆盘从 from -> to
+
 <div align="center"> <img src="../pics//2861e923-4862-4526-881c-15529279d49c.png" width="300"/> </div><br>
 
+- 将 n-1 个圆盘从 buffer -> to
+
 <div align="center"> <img src="../pics//1c4e8185-8153-46b6-bd5a-288b15feeae6.png" width="300"/> </div><br>
 
+如果只有一个圆盘，那么只需要进行一次移动操作。
+
+从上面的讨论可以知道，a<sub>n</sub> = 2 * a<sub>n-1</sub> + 1，显然 a<sub>n</sub> = 2<sup>n</sup> - 1，n 个圆盘需要移动 2<sup>n</sup> - 1 次。
+
 ```java
 public class Hanoi {
     public static void move(int n, String from, String buffer, String to) {
@@ -2105,7 +2107,7 @@ from H1 to H3
 
 生成编码时，从根节点出发，向左遍历则添加二进制位 0，向右则添加二进制位 1，直到遍历到根节点，根节点代表的字符的编码就是这个路径编码。
 
-<div align="center"> <img src="../pics//3ff4f00a-2321-48fd-95f4-ce6001332151.png"/> </div><br>
+<div align="center"> <img src="../pics//3ff4f00a-2321-48fd-95f4-ce6001332151.png" width="400"/> </div><br>
 
 ```java
 public class Huffman {

notes/系统设计基础.md

@@ -79,7 +79,7 @@
 实现可扩展主要有两种方式：
 
 - 使用消息队列进行解耦，应用之间通过消息传递的方式进行通信；
-- 使用分布式服务将业务和可复用的服务分离开来，业务使用分布式服务框架调用可复用的服务。新增的产品可以用过调用可复用的服务来实现业务逻辑，对其它产品没有影响。
+- 使用分布式服务将业务和可复用的服务分离开来，业务使用分布式服务框架调用可复用的服务。新增的产品可以通过调用可复用的服务来实现业务逻辑，对其它产品没有影响。
 
 # 四、可用性
 

notes/设计模式.md

@@ -98,7 +98,9 @@ public static synchronized Singleton getUniqueInstance() {
 
 （三）饿汉式-线程安全
 
-线程不安全问题主要是由于 uniqueInstance 被实例化了多次，如果 uniqueInstance 采用直接实例化的话，就不会被实例化多次，也就不会产生线程不安全问题。但是直接实例化的方式也丢失了延迟实例化带来的节约资源的优势。
+线程不安全问题主要是由于 uniqueInstance 被实例化了多次，如果 uniqueInstance 采用直接实例化的话，就不会被实例化多次，也就不会产生线程不安全问题。
+
+但是直接实例化的方式也丢失了延迟实例化带来的节约资源的好处。
 
 ```java
 private static Singleton uniqueInstance = new Singleton();
@@ -106,7 +108,7 @@ private static Singleton uniqueInstance = new Singleton();
 
 （四）双重校验锁-线程安全
 
-uniqueInstance 只需要被实例化一次，之后就可以直接使用了。加锁操作只需要对实例化那部分的代码进行。也就是说，只有当 uniqueInstance 没有被实例化时，才需要进行加锁。
+uniqueInstance 只需要被实例化一次，之后就可以直接使用了。加锁操作只需要对实例化那部分的代码进行，只有当 uniqueInstance 没有被实例化时，才需要进行加锁。
 
 双重校验锁先判断 uniqueInstance 是否已经被实例化，如果没有被实例化，那么才对实例化语句进行加锁。
 
@@ -131,7 +133,7 @@ public class Singleton {
 }
 ```
 
-考虑下面的实现，也就是只使用了一个 if 语句。在 uniqueInstance == null 的情况下，如果两个线程同时执行 if 语句，那么两个线程就会同时进入 if 语句块内。虽然在 if 语句块内有加锁操作，但是两个线程都会执行 `uniqueInstance = new Singleton();` 这条语句，只是先后的问题，也就是说会进行两次实例化，从而产生了两个实例。因此必须使用双重校验锁，也就是需要使用两个 if 语句。
+考虑下面的实现，也就是只使用了一个 if 语句。在 uniqueInstance == null 的情况下，如果两个线程同时执行 if 语句，那么两个线程就会同时进入 if 语句块内。虽然在 if 语句块内有加锁操作，但是两个线程都会执行 `uniqueInstance = new Singleton();` 这条语句，只是先后的问题，那么就会进行两次实例化，从而产生了两个实例。因此必须使用双重校验锁，也就是需要使用两个 if 语句。
 
 ```java
 if (uniqueInstance == null) {
@@ -157,7 +159,7 @@ uniqueInstance 采用 volatile 关键字修饰也是很有必要的。`uniqueIns
 
 这种方式不仅具有延迟初始化的好处，而且由虚拟机提供了对线程安全的支持。
 
-```source-java
+```java
 public class Singleton {
 
     private Singleton() {
@@ -299,7 +301,7 @@ public class Client {
 
 ### 意图
 
-定义了一个创建对象的接口，但由子类决定要实例化哪个类。工厂方法把实例化推迟到子类。
+定义了一个创建对象的接口，但由子类决定要实例化哪个类。工厂方法把实例化操作推迟到子类。
 
 ### 类图
 
@@ -1851,11 +1853,7 @@ No gumball dispensed
 
 ### 与状态模式的比较
 
-状态模式的类图和策略模式类似，并且都是能够动态改变对象的行为。
-
-但是状态模式是通过状态转移来改变 Context 所组合的 State 对象，而策略模式是通过 Context 本身的决策来改变组合的 Strategy 对象。
-
-所谓的状态转移，是指 Context 在运行过程中由于一些条件发生改变而使得 State 对象发生改变，注意必须要是在运行过程中。
+状态模式的类图和策略模式类似，并且都是能够动态改变对象的行为。但是状态模式是通过状态转移来改变 Context 所组合的 State 对象，而策略模式是通过 Context 本身的决策来改变组合的 Strategy 对象。所谓的状态转移，是指 Context 在运行过程中由于一些条件发生改变而使得 State 对象发生改变，注意必须要是在运行过程中。
 
 状态模式主要是用来解决状态转移的问题，当状态发生转移了，那么 Context 对象就会改变它的行为；而策略模式主要是用来封装一组可以互相替代的算法族，并且可以根据需要动态地去替换 Context 使用的算法。
 
@@ -1969,7 +1967,7 @@ public abstract class CaffeineBeverage {
 ```
 
 ```java
-public class Coffee extends CaffeineBeverage{
+public class Coffee extends CaffeineBeverage {
     @Override
     void brew() {
         System.out.println("Coffee.brew");
@@ -1983,7 +1981,7 @@ public class Coffee extends CaffeineBeverage{
 ```
 
 ```java
-public class Tea extends CaffeineBeverage{
+public class Tea extends CaffeineBeverage {
     @Override
     void brew() {
         System.out.println("Tea.brew");
@@ -2238,7 +2236,7 @@ Number of items:     6
 
 ### 意图
 
-使用什么都不做的空对象来替代 NULL。
+使用什么都不做的空对象来代替 NULL。
 
 一个方法返回 NULL，意味着方法的调用端需要去检查返回值是否是 NULL，这么做会导致非常多的冗余的检查代码。并且如果某一个调用端忘记了做这个检查返回值，而直接使用返回的对象，那么就有可能抛出空指针异常。
 
@@ -2393,7 +2391,7 @@ public abstract class TV {
 ```
 
 ```java
-public class Sony extends TV{
+public class Sony extends TV {
     @Override
     public void on() {
         System.out.println("Sony.on()");
@@ -2412,7 +2410,7 @@ public class Sony extends TV{
 ```
 
 ```java
-public class RCA extends TV{
+public class RCA extends TV {
     @Override
     public void on() {
         System.out.println("RCA.on()");
@@ -2551,9 +2549,6 @@ public abstract class Component {
 ```
 
 ```java
-import java.util.ArrayList;
-import java.util.List;
-
 public class Composite extends Component {
 
     private List<Component> child;
@@ -2659,7 +2654,7 @@ Composite:root
 
 ### 类图
 
-装饰者（Decorator）和具体组件（ConcreteComponent）都继承自组件（Component），具体组件的方法实现不需要依赖于其它对象，而装饰者组合了一个组件，这样它可以装饰其它装饰者或者具体组件。所谓装饰，就是把这个装饰者套在被装饰上，从而动态扩展被装饰者的功能。装饰者的方法有一部分是自己的，这属于它的功能，然后调用被装饰者的方法实现，从而也保留了被装饰者的功能。可以看到，具体组件应当是装饰层次的最低层，因为只有具体组件的方法实现不需要依赖于其它对象。
+装饰者（Decorator）和具体组件（ConcreteComponent）都继承自组件（Component），具体组件的方法实现不需要依赖于其它对象，而装饰者组合了一个组件，这样它可以装饰其它装饰者或者具体组件。所谓装饰，就是把这个装饰者套在被装饰者之上，从而动态扩展被装饰者的功能。装饰者的方法有一部分是自己的，这属于它的功能，然后调用被装饰者的方法实现，从而也保留了被装饰者的功能。可以看到，具体组件应当是装饰层次的最低层，因为只有具体组件的方法实现不需要依赖于其它对象。
 
 <div align="center"> <img src="../pics//137c593d-0a9e-47b8-a9e6-b71f540b82dd.png"/> </div><br>
 
@@ -2770,7 +2765,7 @@ public class Client {
 
 ### 实现
 
-观看电影需要操作很多电器，使用外观模式可以实现一键看电影功能。
+观看电影需要操作很多电器，使用外观模式实现一键看电影功能。
 
 ```java
 public class SubSystem {
@@ -2811,7 +2806,7 @@ public class Client {
 
 ### 设计原则
 
-最少知识原则：只和你的密友谈话。也就是客户对象所需要交互的对象应当尽可能少。
+最少知识原则：只和你的密友谈话。也就是说客户对象所需要交互的对象应当尽可能少。
 
 ## 6. 享元（Flyweight）
 
@@ -2822,8 +2817,8 @@ public class Client {
 ### 类图
 
 - Flyweight：享元对象
-- IntrinsicState：内部状态，相同的项元对象共享
-- ExtrinsicState：外部状态
+- IntrinsicState：内部状态，享元对象共享内部状态
+- ExtrinsicState：外部状态，每个享元对象的外部状态不同
 
 <div align="center"> <img src="../pics//d52270b4-9097-4667-9f18-f405fc661c99.png"/> </div><br>
 
@@ -2854,8 +2849,6 @@ public class ConcreteFlyweight implements Flyweight {
 ```
 
 ```java
-import java.util.HashMap;
-
 public class FlyweightFactory {
 
     private HashMap<String, Flyweight> flyweights = new HashMap<>();