Scala类型系统

• Scala类型系统编程：
• 1. Scala的类和方法、函数都可以是泛型，在Spark源码中可以到处看到类和方法的泛型，在实际实例化的时候指定具体的类型，例如Spark最核心、最基础、最重要的抽象数据结构RDD里面关于RDD的类的定义示泛型的，RDD的几乎所有方法的定义也都是泛型的，之所以这么做，是因为RDD会派生很多子类，通过子类试配了各种不同的数据源以及业务逻辑操作；
• 2. 关于对类型边界的限定，分为上边界和下边界：
     上边界：表达了泛型的类型必须是某种类型或者某种类型的子类，语法为<:,这里的一个新的现象是对类型进行限定；
     下边界：表达了泛型的类型必须是某种类型或者某种类型的父类，语法为>:，

    class Person(val name: String) {
      def talk(person: Person): Unit = {
        println(this.name + " : " + person.name)
      }
    }

     class Worker(name:String) extends Person(name)

    class Club[T <: Person](p1 : T, p2 : T) {
      def comunicate = p1.talk(p2)
    }

    class Club2[T <% Person](p1 : T, p2 : T) {
      def comunicate = p1.talk(p2)
    }

    val p = new Person("Java")
    val w = new Worker("Scala")
    val club = new Club(p, w)
    club.comunicate

• 3. View Bounds，可以进行某种神秘的转换，把你的类型可以在没有知觉的情况下转换成为目标类型，其实你可以认为View Bounds是上边界和下边界的加强补充版本，例如在SparkContext这个Spark的核心类中有T <% Writable方式的代码，这个代码所表达的是T必须是Writable类型的，但是T没有直接继承自Writable接口，此时就需要通过“implicit”的方式来实现这个功能；

    class Dog(val name : String)


    implicit def dog2Person(dog : Dog) = new Person(dog.name)
    val dog = new Dog("dahuang")
    val club2 = new Club[Person](p, dog)
    club2.comunicate

• 4. T:ClassTag,例如Spark源码中的RDD class RDD[T:ClassTag]这个其实也是一种类型转换系统，只是在编译的时候类型信息不够，需要借助于JVM的runtime来通过运行时信息获得完整的类型信息，这在Spark中是非常重要的，因为Spark的程序的编写和运行是区分了Driver和Executor的，只有在运行的时候才知道完整的类型信息；
• 5. 逆变和协变：-T和+T

    class Engineer
    class Expert extends Engineer

    //逆变
    class Meeting[-T]
    //协变
    class Meeting2[+T]
    
    participateMeeting(new Meeting[Engineer])
    participateMeeting(new Meeting[Expert])

    participateMeeting2(new Meeting2[Expert])
    participateMeeting2(new Meeting2[Engineer])

• 6. Context Bounds， T:Ordering这种语法必须能够编程Ordering[T]这种方式；

    class Maximum[T: Ordering](val x : T, val y : T) {
      def bigger(implicit ord : Ordering[T]) = {
        if (ord.compare(x, y) > 0) x else y
      }
    }

    new Maximum(2, 5).bigger
    new Maximum("Scala", "Java").bigger

完整用例

    class Engineer
class Expert extends Engineer

//逆变
class Meeting[-T]
//协变
class Meeting2[+T]

class Maximum[T: Ordering](val x : T, val y : T) {
  def bigger(implicit ord : Ordering[T]) = {
    if (ord.compare(x, y) > 0) x else y
  }
}


class Animal[T](val species: T) {
  def getAnimal(specie: T) = println(species)
}

class Person(val name: String) {
  def talk(person: Person): Unit = {
    println(this.name + " : " + person.name)
  }
}

class Worker(name:String) extends Person(name)

class Club[T <: Person](p1 : T, p2 : T) {
  def comunicate = p1.talk(p2)
}

class Club2[T <% Person](p1 : T, p2 : T) {
  def comunicate = p1.talk(p2)
}

class Dog(val name : String)



object HelloScalaTypeSystem {
  def main(args: Array[String]): Unit = {

    val p = new Person("Java")
    val w = new Worker("Scala")
    val club = new Club(p, w)
    club.comunicate

    implicit def dog2Person(dog : Dog) = new Person(dog.name)
    val dog = new Dog("dahuang")
    val club2 = new Club[Person](p, dog)
    club2.comunicate

    participateMeeting(new Meeting[Engineer])
    participateMeeting(new Meeting[Expert])

    participateMeeting2(new Meeting2[Expert])
    participateMeeting2(new Meeting2[Engineer])

    new Maximum(2, 5).bigger
    new Maximum("Scala", "Java").bigger
  }

  def participateMeeting(meeting:Meeting[Expert]): Unit = {
    println("Welcome")
  }

  def participateMeeting2(meeting:Meeting2[Engineer]): Unit = {
    println("Welcome2")
  }

}