diff --git a/Java.md b/Java.md
index 428fde5..4f7d034 100644
--- a/Java.md
+++ b/Java.md
@@ -136,6 +136,13 @@ Java 语言提供了八种基本类型。六种数字类型（四个整数型，
   int i2 = (int) l2;
   ```
 
+* 自动类型提升是指容量小的数据类型的变量与容量大的数据类型的变量做运算时，得到的结果自动提升为容量大的数据类型。
+
+  byte、char、short--> int--> long--> float--> double
+  特别的，当byte、char、short三种类型的变量互相做运算时，或者自己和自己本身做运算时，结果都为int型
+
+
+
 * 隐式类型转换：
 
   字面量 1 是 int 类型，它比 short 类型精度要高，因此不能隐式地将 int 类型向下转型为 short 类型
@@ -160,6 +167,8 @@ Java 语言提供了八种基本类型。六种数字类型（四个整数型，
 
 引用数据类型：类，接口，数组都是引用数据类型，又叫包装类
 
+包装类数据，如Integer, String, Double等将相应的基本数据类型包装起来的类。这些类数据全部存在于堆中，Java用new()语句来显示地告诉编译器，在运行时才根据需要动态创建，因此比较灵活，但缺点是要占用更多的时间。 
+
 包装类的作用：
 
 * 包装类作为类首先拥有了 Object 类的方法
@@ -324,6 +333,24 @@ new Integer(123) 与 Integer.valueOf(123) 的区别在于：
 
 valueOf() 方法的实现比较简单，就是先判断值是否在缓存池中，如果在的话就直接返回缓存池的内容。编译器会在自动装箱过程调用 valueOf() 方法，因此多个值相同且值在缓存池范围内的 Integer 实例使用自动装箱来创建，那么就会引用相同的对象。
 
+
+
+Integer 提供缓存机制，能够缓存-128，127之间的int类型，在装箱的时候避免多次创建对象，
+
+```java
+Integer z = Integer.valueOf(123);
+Integer k = Integer.valueOf(123);
+System.out.println(z == k);   // true
+// 123 < 127 < 150
+Integer z = Integer.valueOf(150);
+Integer k = Integer.valueOf(150);
+System.out.println(z == k);   // false
+```
+
+
+
+
+
 **基本类型对应的缓存池如下：**
 
 - Boolean values true and false
@@ -818,7 +845,16 @@ public class MethodDemo {
 除了同一个类中的方法，重载也可以作用于这个类所继承而来的方法。如果子类定义了与父类中**非私有方法**同名的方法，而且这两个方法的参数类型不同，那么在子类中，这两个方法同样构成了重载
 
 * 如果这两个方法都是静态的，那么子类中的方法隐藏了父类中的方法
-* 如果这两个方法都不是静态的，且都不是私有的，那么子类的方法重写了父类中的方法，也就是**多态**
+* 如果这两个方法都不是静态的，且都不是私有的，且参数相同，那么子类的方法重写了父类中的方法，也就是**多态**
+
+
+
+| 比较项目 | 重载                                             | 覆写/重写                                                |
+| -------- | ------------------------------------------------ | -------------------------------------------------------- |
+| 英文名   | Overload                                         | Override                                                 |
+| 函数签名 | 只要求函数的参数个数或类型不一致，对返回值没要求 | 函数的参数个数、类型、返回值都必须完全一样。             |
+| 发生地方 | 同一个类或者具有继承关系的两个类中               | 只能发生在继承关系的两个类中                             |
+| 访问权限 | 没有限制                                         | 子类覆写方法的访问权限必须大于或等于父类的方法的访问权限 |
 
 
 
@@ -1247,7 +1283,7 @@ Java 是通过成员变量是否有 static 修饰来区分是类的还是属于
 
 子类不能继承父类的东西：
 
-* 子类不能继承父类的构造器，子类有自己的构造器
+* 子类不能继承父类的构造器，子类有自己的构造器（父类一般要有一个无参数的构造方法是因为我们的子类如果没有显性的调用父类的[构造函数](https://links.jianshu.com/go?to=https%3A%2F%2Fwww.baidu.com%2Fs%3Fwd%3D%E6%9E%84%E9%80%A0%E5%87%BD%E6%95%B0%26tn%3DSE_PcZhidaonwhc_ngpagmjz%26rsv_dl%3Dgh_pc_zhidao)的话就会默认加入super();即调用父类的无参数构造函数，当父类没有无参数构造函数就会报错哦，这就是要加入一个无参数构造函数的原因。）
 * 子类是不能可以继承父类的私有成员的，可以反射暴力去访问继承自父类的私有成员
 * 子类是不能继承父类的静态成员的，子类只是可以访问父类的静态成员，父类静态成员只有一份可以被子类共享访问，**共享并非继承**
 
@@ -2167,6 +2203,41 @@ protected 用于修饰成员，表示在继承体系中成员对于子类可见
 
 
 
+同时子类对父类的方法覆写对权限有要求，子类方法的访问权限必须大于或等于父类方法的访问权限。也就是说如果父类方法的访问权限是default，那么子类必须是default或者public，如果父类方法是public访问权限，那么子类就只能是public访问权限了。然而，实际开发中，绝大多数的方法都是public访问权限，所以覆写方法也是public。
+
+关于访问权限，还有一点需要注意的是，父类方法如果是private，根据JAVA的封装性原则，private是不让其它任何类访问的。那么，此时子类能否对父类的private方法进行覆写呢？
+
+答案是否定的。
+
+```Java 
+class A{
+    public void test(){
+        fun();
+    }
+
+    private void fun(){
+        System.out.println("父类的private fun()");
+    }
+}
+
+class B extends A{
+    public void fun(){
+        System.out.println("子类的public fun()");
+    }
+}
+
+public class Hello{
+    public static void main(String[] args) throws Exception{
+        B b = new B();
+        b.test(); // 此时运行结果是调用的父类的private fun()方法。
+        b.fun();
+    }
+}
+// 输出
+// 父类的private fun()
+// 子类的public fun()
+```
+
 
 
 ***
diff --git a/README.md b/README.md
index 211ff15..859322e 100644
--- a/README.md
+++ b/README.md
@@ -18,3 +18,27 @@
 * 所有的知识不保证权威性，如果各位朋友发现错误，欢迎与我讨论。
 * 笔记的编写基于 Windows 平台，可能会因为平台的不同而造成空格、制表符的显示效果不同。
 
+
+SE： Java Standard Edition，Java 标准版
+JVM： Java Virtual Machine（*Java*虚拟机）
+ALG：  Algorithm简单算法
+SDP： 设计模式
+
+
+
+JUC：  java.util.concurrent (简称 *JUC* )包,在此包中增加了在并发编程中很常用 的实用工具类,
+NET： 网络编程
+
+
+
+MyBatis： 
+Spring
+MVC
+SSM
+Boot
+
+
+
+MySQL
+JDBC
+Redis