Spark基础-Scala类型参数编程

核心
1、scala类型参数编程

package com.xlucas

/**
  * Created by xlucas on 2017/8/24 0024.
  * 1、scala 的类和方法、函数都可以是泛型
  * 2、上边界表达了泛型的类型必须是某种类型或则某种类型的子类，语法为 <: , 对类型进行限定
  *     下边界表达了泛型的类型必须是某种类型或则某种类型的父类，语法为 >: , 对类型进行限定
  *  3、view bounds 可以进行转换，把你的类型可以在没有知觉的情况下转换成为目标类型，
  *      <%,例如 <% Writable方式的代码，这个代码所表达的是T必须是Writable类型的，但是T有没有直接继承自
  *      Writable接口，此时就需要通过 implicit的方式实现这个功能
  *  4、T:ClassTag ,这个其实是一种类型转换系统，只是在编译的时候类型信息不够，需要借助于JVM的runtime来通过运行时信息获取
  *     得到完整的类型信息，
  *  5、逆变和协变 -T和+T
  *  6、Context Bounds ，T:Ordering这种语法必须能够变成Ordering[T]这种方式
  */

class Animal[T](val species:T){
  def getAnimal(species:T):T=species
}
class Person(val name:String) {
  def talk(person: Person): Unit ={
    println(this.name+":"+person.name)
  }
}

class Worker(name:String) extends Person(name)
class Dog(val name:String)
class Club[T <:Person](p1:T,p2:T){
  def com=p1.talk(p2)
}
class Club1[T <%Person](p1:T,p2:T){
  def com=p1.talk(p2)
}

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

object TypeOop {
  def main(args: Array[String]): Unit = {
    implicit def dog2person(dog:Dog)=new Person(dog.name)
val p= new Person("scala")
val w= new Worker("spark")
val d=new Dog("dahuang")
new Club(p,w).com
new Club1[Person](w,d).com

val e=new Meeting[engineer]
    engjoinmeeting(e)
val ex=new Meeting[expert]
    engjoinmeeting(ex)
val e2=new Meeting2[engineer]
    exjoinmeeting(e2)
val ex2=new Meeting2[expert]
    exjoinmeeting(ex2)

    println(new maximum(3,5).bigger)
  }

  def engjoinmeeting(meeting: Meeting[expert]): Unit ={
      println("engineer join ")
  }
  def exjoinmeeting(meeting: Meeting2[engineer]): Unit ={
    println("expert join ")
  }
}

运行结果
scala:spark
spark:dahuang
engineer join
engineer join
expert join
expert join
5