scala面向对象编程之 trait

左手的ㄟ右手 2022-05-22 04:06 304阅读 0赞

-- 将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)
       }

使用如下：

![20180614191842346][]

\-- 在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+"]")
       }

使用如下：

![20180614192335127][]

\-- 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 ")
          }
         }

请看下面的代码：

![20180614192126595][]

\-- 为实例混入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

代码展示如下：

![20180614212626844][]

\-- 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)}
      }

使用如下：

![70][]

\-- -- 在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 
      }

使用如下：

![70 1][]

-- 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! ")
      }

请看执行结果：

![70 2][]

\-- 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)
         }
       }

[20180614191842346]: /images/20220522/ad3142b9563d4c90b60b23f5a32f86c6.png
[20180614192335127]: /images/20220522/daa639343e5148e9a8969180ad0f0d9f.png
[20180614192126595]: /images/20220522/eb4b6e3571b944d89ea1f80eb4f35b19.png
[20180614212626844]: /images/20220522/530be52b73784b948f87075a2b78a949.png
[70]: /images/20220522/8575e96608e84655a2e6be558ad75d3e.png
[70 1]: /images/20220522/f9147ac5f9f24ec4bec266644b2052bd.png
[70 2]: /images/20220522/e60ecf22692540258f91c68a898629ca.png