scala面向對象程式設計之 trait

 -- 将trait 作為接口使用

// scala中的 trait是一種特殊的概念。
 //首先我們可以将Trait作為接口來使用，此時的Trait就與java中的接口非常相似
 //trait中可以定義抽象方法，就與抽象類中的抽象方法一樣，隻要不給出方法的具體實作即可
 // 類可以使用extends關鍵字繼承trait ，注意，這裡不是implement，而是extends ，在scala
    //中沒有implement的概念，無論繼承類還是trait，統一都是extends
  // 類繼承trait後，必須實作其中的抽象方法，實作時不需要使用override關鍵字
  //scala中不支援對類進行多繼承，但是支援多重繼承trait ，使用with關鍵字即可

  trait HelloTrait{
    def sayHello(name:String)
  }
  trait MakeFriendsTrait{
     def makeFriends(p:Person)
  }
  class Person(val name:String) extends HelloTrait with MakeFriendsTrait
    with Cloneable with Serializable {
      def sayHello(name:String)=println("Hello, "+ name)
      def makeFriends(p:Person) =println("Hello, my name is "+ name+",your name is " + p.name)
   }
           

使用如下：

-- 在trait中定義具體方法

//scala中的trait可以不是隻定義抽象方法，還可以定義具體方法 ，此時trait更像是包含了通用工具方法的東西
  //有一個專有的名詞來形容這種情況，就是說trait的功能混入了類
  //舉例說，trait中可以包含一些很多類通用的功能方法，比如列印日志等，spark中就使用了trait來定義通用的日志列印方法

  trait Logger{
    def log(message:String)=println(message)
  }
  class Person(val name:String) extends Logger{
     def makeFriends(p:Person){
       println("Hi ,I'm " +name+", I'm glad to nake friends with you ,"+p.name)
       log("makeFriends method is invoked with parameter Person[name="+p.name+"]")
   }
           

使用如下：

-- trait 中定義具體字段

// scala中的Trait可以定義具體field ，此時繼承Trait的類會自動獲得trait中定義的field
  //但是這種擷取field的方式與繼承class是不同的：如果是繼承class擷取的field實際上是定義在父類中的，
    // 而繼承trait擷取的field ，就直接被添加到了子類中。
    trait Person{
      val eyeNum:Int=2
	}
	class Student(val name:String) extends Person{
	 def sayHello=println("Hi ,I'm "+ name +", I have " +eyeNum +"eyes.")
	}
           

-- Trait中定義抽象字段

// scala中的trait可以定義抽象field ，而trait中的具體方法則可以基于抽象field來編寫
   //但是繼承trait的類，則必須覆寫抽象field，提供具體的值
   trait SayHello{
     val msg:String
     def sayHello(name:String )=println(msg+"," +name)
   }

   class Person(val name:String) extends SayHello{
     val msg:String="hello"
     def makeFriends(p:Person){
       sayHello(p.name)
       println("I'm "+name+", I want to make friends with you ")
      }
     }
           

請看下面的代碼：

-- 為執行個體混入trait

/有時我們可以在建立類的對象時，指定該對象混入某個trait ，這樣，就隻有這個對象混入該trait的方法，而類的其他對象則沒有
    
    trait Logged{
      def log(msg:String){}
    }
    trait MyLogger extends Logged{
      override def log(msg:String){println("log: "+msg)}
    }
    
    class Person(val name:String)extends Logged{
      def sayHello{println("Hi ,I'm " +name); log("sayHello is invoked")}
    }

    val p1=new Person("leo")
    p1.sayHello
    val p2=new Person("Jack") with MyLogger
    p2.sayHello
           

代碼展示如下：

-- trait 調用鍊

// scala中支援讓類繼承多個trait後，依次調用多個trait中的同一個方法，隻要讓多個trait的同一個方法或者能夠，在最後都執行super.方法即可
   // 類中調用多個trait中都有的這個方法時，首先會從最右邊的trait方法開始執行，然後依次往左執行，形成一個調用鍊。
   //這種特性非常強大，其實就相當于設計模式中的責任鍊的一種具體實作依賴。


   trait Handler{
     def handle(data:String){}
   }

   trait DataValidHandler extends Handler{
     override def handle(data:String){
        println("check data: "+ data)
        super.handle(data)
     }
   }

   trait SignatureValidHandler extends handler{
      override def handle(data:String){
        println("check signature :"+ data)
        super.handle(data)
      }
   }

  class Person(val name:String) extends SignatureValidHandler with DataValidHandler{
     def sayHello={println("Hello ," +name); handle(name)}
  }
           

使用如下：

-- -- 在trait 中覆寫抽象方法

// 在trait中 ，可以覆寫父trait的抽象方法的。但是覆寫時，如果使用了super方法的代碼，則無法通過編譯，因為super方法就
   //會去調用父trait的抽象方法，此時子trait  的該方法還是會被認為是抽象的。

   // 此事時要想通過編譯，就得給子trait的方法加上 abstract override修飾
   
   trait Logger{
     def log(msg:String)
   }
   trait MyLogger extends Logger{
     abstract override def log(msg:String ){super.log(msg)}
   }
           

-- 混合使用trait的具體方法和抽象方法

//在trait中，可以混合使用具體方法和抽象方法
  //可以讓具體方法依賴于抽象方法，而抽象方法則放到繼承trait的類中實作
  //這種trait氣勢就是設計模式中的模闆設計模式的實作。

  trait Valid{
   def getName :String 
   def valid :Boolean={
    getName== "leo"
   }
  }

  class Person(val name :String) extends Valid{
    println(valid)
    def getName=name 
  }
           

使用如下：

 -- trait的構造機制

//在scala中，trait也是有構造代碼的，也就是trait中的，不包含在任何方法中的代碼
 //而繼承了trait的類的構造機制如下： 1.父類的構造函數執行；2. trait的構造代碼執行，多個Trait從左到右依次執行；
  //3. 構造trait時會先構造父trait，如果多個trait繼承同一個父trait，則父trait隻會構造一次。
   //4. 所有父trait構造完畢之後，子類的構造函數執行。
  
  class Person{println("Person's constructor !")}
  trait Logger {println("Logger's construceor !")}
  trait MyLogger extends Logger{println("MyLogger's constructor!")}
  trait TimeLogger extends Logger {println("TimeLogger's constructor !")}

  class Student extends Person with MyLogger with TimeLogger{
     println("Student's constructor! ")
  }
           

請看執行結果：

-- trait field 的初始化

//在scala中，trait是沒有接受參數的構造函數的，這是trait與class的唯一差別，但是如果需求就是要trait能夠對field進行初始化，該怎麼辦呢？
    //隻能使用scala中非常特殊的一種進階特性 -- 提前定義。
  trait SayHello{
    val msg:String
	println(msg.toString)
  }
 
 class Person  // 提前定義
   val p={
     val msg:String ="init"
   }with Person with SayHello
   
   class Person extends {
     val msg:String ="init"
	 
   }with SayHello{}
 
 // 另一種方式就是使用lazy value
 trait SayHello{
   lazy val msg:String=null 
   println(msg.toString)
 }
 
 class Person extends SayHello{
   override lazy val msg:String ="init"
 }
 
           

-- trait 繼承class 

//在scala中，trait也可以繼承trait ，此時這個class就會成為所有繼承該trait的類的父類
   class MyUtil{
    def printMessage(msg:String)=println(msg)
   }

   trait Logger extends MyUtil{
    def log(msg:String)=printMessage("log: "+ msg)
   }

   class Person(val name:String ) extends Logger{
     def sayHello{
        log("Hi,I'm " + name)
        printMessage("Hi ,I'm " +name)
     }
   }