diff --git a/docs/notes/Java 基础.md b/docs/notes/Java 基础.md
index 442f2cf2..0cc81daf 100644
--- a/docs/notes/Java 基础.md	
+++ b/docs/notes/Java 基础.md	
@@ -467,7 +467,6 @@ public class AccessExample {
 
 可以使用公有的 getter 和 setter 方法来替换公有字段，这样的话就可以控制对字段的修改行为。
 
-
 ```java
 public class AccessExample {
 
@@ -670,7 +669,11 @@ SuperExtendExample.func()
 
 存在于继承体系中，指子类实现了一个与父类在方法声明上完全相同的一个方法。
 
-为了满足里式替换原则，重写有有以下两个限制：
+为了满足里式替换原则，重写有以下三个限制：
+
+- 子类方法的访问权限必须大于等于父类方法；
+- 子类方法的返回类型必须是父类方法返回类型或为其子类型。
+- 子类方法抛出的异常类型必须是父类抛出异常类型或为其子类型。
 
 使用 @Override 注解，可以让编译器帮忙检查是否满足上面的三个限制条件。
 
@@ -696,70 +699,81 @@ class SubClass extends SuperClass {
 }
 ```
 
-**2. 重载（Overload）** 
+在调用一个方法时，先从本类中查找看是否有对应的方法，如果没有查找到再到父类中查看，看是否有继承来的方法。否则就要对参数进行转型，转成父类之后看是否有对应的方法。总的来说，方法调用的优先级为：
 
-存在于同一个类中，指一个方法与已经存在的方法名称上相同，但是参数类型、个数、顺序至少有一个不同。
+- this.func(this)
+- super.func(this)
+- this.func(super)
+- super.func(super)
 
-应该注意的是，返回值不同，其它都相同不算是重载。
-
-**3. 实例** 
 
 ```java
+/*
+    A
+    |
+    B
+    |
+    C
+    |
+    D
+ */
+
+
 class A {
-    public String show(D obj) {
-        return ("A and D");
+
+    public void show(A obj) {
+        System.out.println("A.show(A)");
     }
 
-    public String show(A obj) {
-        return ("A and A");
+    public void show(C obj) {
+        System.out.println("A.show(C)");
     }
 }
 
 class B extends A {
-    public String show(B obj) {
-        return ("B and B");
-    }
 
-    public String show(A obj) {
-        return ("B and A");
+    @Override
+    public void show(A obj) {
+        System.out.println("B.show(A)");
     }
 }
 
 class C extends B {
 }
 
-class D extends B {
+class D extends C {
 }
 ```
 
 ```java
-public class Test {
+public static void main(String[] args) {
 
-    public static void main(String[] args) {
-        A a1 = new A();
-        A a2 = new B();
-        B b = new B();
-        C c = new C();
-        D d = new D();
-        System.out.println(a1.show(b)); // A and A
-        System.out.println(a1.show(c)); // A and A
-        System.out.println(a1.show(d)); // A and D
-        System.out.println(a2.show(b)); // B and A
-        System.out.println(a2.show(c)); // B and A
-        System.out.println(a2.show(d)); // A and D
-        System.out.println(b.show(b));  // B and B
-        System.out.println(b.show(c));  // B and B
-        System.out.println(b.show(d));  // A and D
-    }
+    A a = new A();
+    B b = new B();
+    C c = new C();
+    D d = new D();
+
+    // 在 A 中存在 show(A obj)，直接调用
+    a.show(a); // A.show(A)
+    // 在 A 中不存在 show(B obj)，将 B 转型成其父类 A
+    a.show(b); // A.show(A)
+    // 在 B 中存在从 A 继承来的 show(C obj)，直接调用
+    b.show(c); // A.show(C)
+    // 在 B 中不存在 show(D obj)，但是存在从 A 继承来的 show(C obj)，将 D 转型成其父类 C
+    b.show(d); // A.show(C)
+
+    // 引用的还是 B 对象，所以 ba 和 b 的调用结果一样
+    A ba = new B();
+    ba.show(c); // A.show(C)
+    ba.show(d); // A.show(C)
 }
 ```
 
-涉及到重写时，方法调用的优先级为：
+**2. 重载（Overload）** 
 
-- this.show(O)
-- super.show(O)
-- this.show((super)O)
-- super.show((super)O)
+存在于同一个类中，指一个方法与已经存在的方法名称上相同，但是参数类型、个数、顺序至少有一个不同。
+
+应该注意的是，返回值不同，其它都相同不算是重载。
 
 # 五、Object 通用方法
 
diff --git a/notes/Java 基础.md b/notes/Java 基础.md
index d87be2bc..70df4fb0 100644
--- a/notes/Java 基础.md	
+++ b/notes/Java 基础.md	
@@ -467,7 +467,6 @@ public class AccessExample {
 
 可以使用公有的 getter 和 setter 方法来替换公有字段，这样的话就可以控制对字段的修改行为。
 
-
 ```java
 public class AccessExample {
 
@@ -670,7 +669,11 @@ SuperExtendExample.func()
 
 存在于继承体系中，指子类实现了一个与父类在方法声明上完全相同的一个方法。
 
-为了满足里式替换原则，重写有有以下两个限制：
+为了满足里式替换原则，重写有以下三个限制：
+
+- 子类方法的访问权限必须大于等于父类方法；
+- 子类方法的返回类型必须是父类方法返回类型或为其子类型。
+- 子类方法抛出的异常类型必须是父类抛出异常类型或为其子类型。
 
 使用 @Override 注解，可以让编译器帮忙检查是否满足上面的三个限制条件。
 
@@ -696,70 +699,81 @@ class SubClass extends SuperClass {
 }
 ```
 
-**2. 重载（Overload）** 
+在调用一个方法时，先从本类中查找看是否有对应的方法，如果没有查找到再到父类中查看，看是否有继承来的方法。否则就要对参数进行转型，转成父类之后看是否有对应的方法。总的来说，方法调用的优先级为：
 
-存在于同一个类中，指一个方法与已经存在的方法名称上相同，但是参数类型、个数、顺序至少有一个不同。
+- this.func(this)
+- super.func(this)
+- this.func(super)
+- super.func(super)
 
-应该注意的是，返回值不同，其它都相同不算是重载。
-
-**3. 实例** 
 
 ```java
+/*
+    A
+    |
+    B
+    |
+    C
+    |
+    D
+ */
+
+
 class A {
-    public String show(D obj) {
-        return ("A and D");
+
+    public void show(A obj) {
+        System.out.println("A.show(A)");
     }
 
-    public String show(A obj) {
-        return ("A and A");
+    public void show(C obj) {
+        System.out.println("A.show(C)");
     }
 }
 
 class B extends A {
-    public String show(B obj) {
-        return ("B and B");
-    }
 
-    public String show(A obj) {
-        return ("B and A");
+    @Override
+    public void show(A obj) {
+        System.out.println("B.show(A)");
     }
 }
 
 class C extends B {
 }
 
-class D extends B {
+class D extends C {
 }
 ```
 
 ```java
-public class Test {
+public static void main(String[] args) {
 
-    public static void main(String[] args) {
-        A a1 = new A();
-        A a2 = new B();
-        B b = new B();
-        C c = new C();
-        D d = new D();
-        System.out.println(a1.show(b)); // A and A
-        System.out.println(a1.show(c)); // A and A
-        System.out.println(a1.show(d)); // A and D
-        System.out.println(a2.show(b)); // B and A
-        System.out.println(a2.show(c)); // B and A
-        System.out.println(a2.show(d)); // A and D
-        System.out.println(b.show(b));  // B and B
-        System.out.println(b.show(c));  // B and B
-        System.out.println(b.show(d));  // A and D
-    }
+    A a = new A();
+    B b = new B();
+    C c = new C();
+    D d = new D();
+
+    // 在 A 中存在 show(A obj)，直接调用
+    a.show(a); // A.show(A)
+    // 在 A 中不存在 show(B obj)，将 B 转型成其父类 A
+    a.show(b); // A.show(A)
+    // 在 B 中存在从 A 继承来的 show(C obj)，直接调用
+    b.show(c); // A.show(C)
+    // 在 B 中不存在 show(D obj)，但是存在从 A 继承来的 show(C obj)，将 D 转型成其父类 C
+    b.show(d); // A.show(C)
+
+    // 引用的还是 B 对象，所以 ba 和 b 的调用结果一样
+    A ba = new B();
+    ba.show(c); // A.show(C)
+    ba.show(d); // A.show(C)
 }
 ```
 
-涉及到重写时，方法调用的优先级为：
+**2. 重载（Overload）** 
 
-- this.show(O)
-- super.show(O)
-- this.show((super)O)
-- super.show((super)O)
+存在于同一个类中，指一个方法与已经存在的方法名称上相同，但是参数类型、个数、顺序至少有一个不同。
+
+应该注意的是，返回值不同，其它都相同不算是重载。
 
 # 五、Object 通用方法