[Scala] 40. 泛型

隐式转换

package day04

class MyPredef {
//  implicit def fileToRichFile(file:String)=new RichFile(file)
}
object MyPredef {
  implicit def fileToRichFile(file:String)=new RichFile(file)

  implicit  val selectGirl=(g:Girl)=> new Ordered[Girl]{
    override def compare(that: Girl): Int = {
      if (g.faceValue == that.faceValue){
        that.age-g.age
      }else{
        g.faceValue-that.faceValue
      }
    }
  }
}

泛型

含义

定义参数类型时，不明确指出类型，在用时在确定参数类型，提高代码灵活性

分类

[B < : A] UpperBound 上界：B类型的上界是A类型，即B类型的父类是A类型
[B > : A] LowerBound 下界：B类型的下界是A类型，即B类型的子类是A类型
[B < % A] ViewBound 表示B类型要转换成A类型，需要一个隐式转换函数
[B : A] ContextBound 需要一个隐式转换的值

[-A , +B]
[-A] 逆变，作为参数类型，如果A是T的子类，那么C[T]是C[A]的子类
[+B] 协变，作为返回类型，如果B是T的子类，那么C[B]是C[T]的子类

上界 UpperBound

package day04

/**
 * 上界 UpperBound
 */

// 两个对象之间进行比较
class UpperBoundDemo[T <: Comparable[T]] {
  def select(first: T, second: T): T = {
    if (first.compareTo(second) > 0) first else second
  }
}

//实现Comparable中的比较方法
class MissRight(val name:String,val faceValue:Int) extends Comparable[MissRight]{
  override def compareTo(o: MissRight): Int = {
    this.faceValue-o.faceValue
  }
}


object UpperBoundDemo {
  def main(args: Array[String]): Unit = {
    val u=new UpperBoundDemo[MissRight]

    val m1=new MissRight("Li",120)
    val m2=new MissRight("Wang",100)

    val res=u.select(m1,m2)

    println(res.name)
    
  }
}

视界ViewBound

package day04

/**
 * [B <% A] ViewBound
 */

class ViewBoundDemo[T <% Ordered[T]] {
  def select(first: T, second: T): T = {
    if (first > second) first else second
  }
}

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

    import MyPredef.selectGirl

    val viewBoundDemo=new ViewBoundDemo[Girl]

    val g1=new Girl("Li",26,120)
    val g2=new Girl("Wang",22,120)

    val res=viewBoundDemo.select(g1,g2)

    println(res.name)
  }
}

ContextBound

package day04

/**
 * [B:A] ContextBound
 *
 * @param ordering$T$0
 * @tparam T
 */

class ContextBoundDemo[T: Ordering] {
  def select(first: T, second: T): T = {
    val ord: Ordering[T] = implicitly[Ordering[T]]
    if (ord.gt(first, second)) first else second
  }
}

object ContextBoundDemo {
  def main(args: Array[String]): Unit = {
    import MyPredef.OrderingGirl

    val contextBoundDemo = new ContextBoundDemo[Girl]

    val g1=new Girl("Li",20,100)
    val g2=new Girl("Wang",19,80)

    val res= contextBoundDemo.select(g1,g2)

    println(res.name)
  }
}