1、定義抽象類：abstract class 類名 {}   //通過abstract關鍵字標記抽象類

2、定義抽象屬性：一個屬性沒有初始化，就是抽象類

3、定義抽象方法：def  方法名() ：資料型別    //只宣告而沒有實現的方法，就是抽象方法

4、繼承、重寫：

（1）如果父類為抽象類，那麼子類需要將抽象的屬性和方法實現，否則子類也需宣告為抽象類。

（2）重寫非抽象方法需要用override修飾，重寫抽象方法則可以不加override。

（3）子類中呼叫父類的方法使用super關鍵字。

（4）子類對抽象屬性進行實現，父類抽象屬性可以用var修飾。

         子類對非抽象屬性重寫，父類抽象屬性只支援val型別，而不支援val。

          因為var修飾的為可變變數，子類繼承之後就可以直接使用，沒有必要重寫。

例子：

 1 object Test5_AbstractClass {
 2   def main(args: Array[String]): Unit = {
 3     val student = new student5()
 4     student.eat()
 5     student.sleep()
 6   }
 7 
 8 }
 9 //定義抽象類
10 abstract class Person5 {
11   //非抽象屬性
12   val name: String = "wl"
13
 
   //抽象屬性
14   var age: Int
15   //非抽象方法
16   def eat(): Unit = {
17     println("person eat")
18   }
19   //抽象方法
20   def sleep(): Unit
21 
22 }
23 
24 //定義具體的實現子類
25 class student5 extends Person5 {
26   //抽象屬性
27   var age: Int = 22
28   //抽象方法
29   def sleep(): Unit = {
30     println("student sleep")
31   }
 
32 
33   //重寫非抽象屬性和方法
34   override val name: String = "student"
35 
36   override def eat(): Unit = {
37     super.eat()
38     println("student eat")
39   }
40   
41 }

5、匿名子類都是通過抽象類和介面使用。

 1 object Test6_AnnoymousClass {
 2   def main(args: Array[String]): Unit = {
 3     val person6: Person6 = new Person6 {
 4       //必須要把抽象屬性和方法實現出來，相當於建立了一個匿名子類
 5       override var name: String = "wl"
 6       override def eat(): Unit = println("person eat")
 7     }
 8     println(person6.name)
 9     person6.eat()
10   }
11 
12 }
13 //定義抽象類
14 abstract class Person6 {
15   var name: String
16   def eat(): Unit
17 }