1、這講內容對做大型專案十分重要，trait本身可以有方法的實現，這樣做大型工程的具體模組時，可以讓這個模組混入很多不同trait，以實現這個模組功能的不同方面。
2、 PianoTeacher的構造順序是由左往右構造的，但是已經構造了父類，後面子類的父類不會重複構造。例如TTeacher PianoPlayer繼承了Human，因為Human已經被構造，所以後面只構造TTeacher、PianoPlayer本身。

class Human{  
    println("Human")  
}  
trait TTeacher extends Human{  
    println("TTeacher"
 
)  
    def teach  //抽象方法
}  
trait PianoPlayer extends Human{  
    println("PianoPlayer")  
    def playPiano = println("I'm playing piano....")  
    //具體方法
}    
class PianoTeacher extends Human with TTeacher with PianoPlayer{  
    override def teach = println("I'm trianing student...")  
    // 這裡必須複寫，否則無法構造物件PianoTeacher  
 

}  



object UserTrait {  
    def main(args: Array[String]): Unit = {  
        //方法一  
        val t1 = new PianoTeacher   
        /**  
         * 構造時結構為:  
         * Human  
         *  TTeacher  
         *  PianoPlayer  
         */  
        t1.playPiano  //row result: I'm playing piano....  
        t1.teach      //row result: I'm trianing student...  
 

        println("------------------------------------------")  

        //方法二 匿名類 
        val t2 = new Human with TTeacher with PianoPlayer{  
            override def teach = println("I'm teaching student...")  
        }  
        /**  
         * 這種方式類似於Java中定義匿名實現介面的類的簡化方式  
         * new Interface({  
         *    @Override  
         *    public void fun(){  
         *      //to do something  
         *    }  
         * });  
         */  
        t2.playPiano    
        t2.teach     
        /**   
         *  結果為:  
         *  Human  
            TTeacher  
            PianoPlayer  
            I'm playing piano....  
            I'm teaching student...  
         */  

    }  
}  
  /**  
 * Scala中的實現AOP  
 */  
trait Action{  
    def doAction  
}  
trait TBeforeAfter extends Action{  
     /*注意 doAction雖然被複寫 但仍然是abstract方法 
     因為super.doAction並未實現 所以用abstract關鍵字標識*/  
     abstract override def doAction {  
        println("Initialization")  
        super.doAction  
        println("Destroyer")  
    }  
}  
class Work extends Action{  
    override def doAction = println("Working...")  
}  

object AOP {  
    def main(args: Array[String]): Unit = {  
        val w = new Work with TBeforeAfter 
        //這裡work實現了doAction，所以成功執行。
        w.doAction  
        /**  
         * result:  
         *   Initialization  
         *   Working...  
         *   Destroyer  
         */  
    }  
}