diff --git a/notes/Scala继承和特质.md b/notes/Scala继承和特质.md
index a435f87..d379663 100644
--- a/notes/Scala继承和特质.md
+++ b/notes/Scala继承和特质.md
@@ -2,11 +2,24 @@
 
 ## 一、继承
 
-### 1.1 extends & override
+### 1.1 Scala中的继承结构
 
-父类Person：
+scala中继承关系如下图：
+
++ Any是整个继承关系的根节点；
++ AnyRef包含Scala Classes和Java Classes，等价于Java中的java.lang.Object；
++ AnyVal是所有值类型的一个标记；
++ Null是所有引用类型的子类型，唯一实例是null，可以将null赋值给除了值类型外的所有类型的变量;
++ Nothing是所有类型的子类型。
+
+![scala继承层次](D:\BigData-Notes\pictures\scala继承层次.png)
+
+### 1.2 extends & override
+
+Scala的集成机制和Java有很多相似之处，比如都使用`extends `关键字表示继承，都使用`override`关键字表示重写父类的方法或成员变量。下面给出一个Scala继承的示例：
 
 ```scala
+//父类
 class Person {
 
 
@@ -67,16 +80,155 @@ object ScalaApp extends App {
 // 输出： Employee~heibaiying:20:2019-03-05:男
 ```
 
-### 1.2 调用父类构造器
+### 1.3 调用超类构造器
 
+在Scala的类中，每个辅助构造器都必须首先调用其他构造器或主构造器，这样就导致了子类的辅助构造器永远无法直接调用超类的构造器，只有主构造器才能调用超类的构造器。所以想要调用超类的构造器，代码示例如下：
 
+```scala
+class Employee(name:String,age:Int,salary:Double) extends Person(name:String,age:Int) {
+    .....
+}
+```
 
-### 1.3 构造顺序和提前定义
+### 1.4 类型检查和转换
 
+想要实现类检查可以使用`isInstanceOf`,判断一个实例是否来源于某个类或者其子类，如果是，则可以使用`asInstanceOf`进行强制类型转换。
 
+```scala
+object ScalaApp extends App {
 
-二、抽象类
+  val employee = new Employee
+  val person = new Person
 
+  // 1. 判断一个实例是否来源于某个类或者其子类 输出 true 
+  println(employee.isInstanceOf[Person])
+  println(person.isInstanceOf[Person])
 
+  // 2. 强制类型转换
+  var p: Person = employee.asInstanceOf[Person]
+
+  // 3. 判断一个实例是否来源于某个类(而不是其子类)
+  println(employee.getClass == classOf[Employee])
+
+}
+```
+
+### 1.5 构造顺序和提前定义
+
+#### 1. 构造顺序
+
+在Scala中还有一个需要注意的问题，如果你在子类中重写父类的val变量，并且超类的构造器中使用了该变量，那么可能会产生不可预期的错误。下面给出一个示例：
+
+```scala
+// 父类
+class Person {
+  println("父类的默认构造器")
+  val range: Int = 10
+  val array: Array[Int] = new Array[Int](range)
+}
+
+//子类
+class Employee extends Person {
+  println("子类的默认构造器")
+  override val range = 2
+}
+
+//测试
+object ScalaApp extends App {
+  val employee = new Employee
+  println(employee.array.mkString("(", ",", ")"))
+
+}
+```
+
+这里初始化array用到了变量range，这里你会发现实际上array既不会被初始化Array(10)，也不会被初始化为Array(2)，实际的输出应该如下：
+
+```properties
+父类的默认构造器
+子类的默认构造器
+()
+```
+
+实际上array被初始化为Array(0)，原因在于父类的构造器的执行先于子类的构造器，这里给出实际的执行步骤：
+
+1. 父类的构造器被调用，执行`new Array[Int](range)`语句;
+2. 这里想要得到range的值，会去调用子类range()方法，因为`override val `重写变量的同时也重写了其get方法；
+3. 调用子类的range()方法，自然也是返回子类的range值，但是由于子类的构造器还没有执行，这也就意味着对range赋值的`range = 2`语句还没有被执行，所以自然返回range的默认值，也就是0。
+
+这里可能比较疑惑的是为什么`val range = 2`没有被执行，却能使用range变量，这里因为在虚拟机层面，是先对成员变量先分配存储空间并赋给默认值，之后才赋予给定的值。想要证明这一点其实也比较简单，代码如下:
+
+```scala
+class Person {
+  // val range: Int = 10 正常代码 array为Array(10)
+  val array: Array[Int] = new Array[Int](range)
+  val range: Int = 10  //如果把变量的声明放在使用之后，此时数据array为array(0)
+}
+
+object Person {
+  def main(args: Array[String]): Unit = {
+    val person = new Person
+    println(person.array.mkString("(", ",", ")"))
+  }
+}
+```
+
+#### 2. 提前定义
+
+想要解决上面的问题，有以下几种方法：
+
+(1) . 将变量用final修饰，代表不允许被子类重写，即 `final val range: Int = 10 `；
+
+(2) . 将变量使用lazy修饰，代表懒加载，即只有当你实际使用到array时候，才去进行初始化；
+
+```scala
+lazy val array: Array[Int] = new Array[Int](range)
+```
+
+(3) . 采用提前定义，代码如下，代表range的定义优先于超类构造器。
+
+```scala
+class Employee extends {
+  override val range = 2
+} with Person
+```
+
+但是这种语法也有缺陷，就是你只能在代码块中重写已有的变量，而不能定义新的变量和方法，这时候你想要拓展新的方法就只能再继承Employee，这样你的继承链就过于繁杂。所以最好的办法就是合理设计父类以规避上面的问题。
+
+## 二、抽象类
+
+Scala中允许使用`abstract`定义抽象类，并且通过`extends`关键字继承它。
+
+定义抽象类：
+
+```scala
+abstract class Person {
+  // 1.定义字段
+  var name: String
+  val age: Int
+
+  // 2.定义抽象方法
+  def geDetail: String
+
+  // 3. scala的抽象类允许定义具体方法
+  def print(): Unit = {
+    println("抽象类中的默认方法")
+  }
+}
+```
+
+继承抽象类：
+
+```scala
+class Employee extends Person {
+  // 覆盖抽象类中变量
+  override var name: String = "employee"
+  override val age: Int = 12
+
+  // 覆盖抽象方法
+  def geDetail: String = name + ":" + age
+}
+
+```
+
+## 三、特质
 
-二、特质
\ No newline at end of file
diff --git a/pictures/scala继承层次.png b/pictures/scala继承层次.png
new file mode 100644
index 0000000..7fd9a24
Binary files /dev/null and b/pictures/scala继承层次.png differ