泛型

[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[A]是C[T]的子类

UpperBound

UpperBoundDemo.scala
package day04

/**
  * 上界 UpperBound
  */
class UpperBuoudDemo[T <: Comparable[T]] {
  def select(first: T,second: T): T = {
    if (first.compareTo(second) > 0 ) first else second
  }
}

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

    val u = new UpperBuoudDemo[MissRight]

    val m1 = new MissRight("biaozi",120)
    val m2 = new MissRight("erdiao",465)

    val res = u.select(m1,m2)

    println(res.name)
  }
}

class MissRight(val name: String,val faceValue: Int) extends Comparable[MissRight] {
  override def compareTo(o: MissRight): Int = {
    this.faceValue - o.faceValue
  }
}

ViewBound

ViewBoundDemo.scala
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("biaozi",26,120)
    val g2 = new Girl("erdiao",24,120)

    val res = viewBoundDemo.select(g1,g2)

    println(res.name)
  }
}
Girl.scala
package day04

class Girl(val name: String, val age: Int, val faceValue: Int) {

}

MyPredef.scala
package day04

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

contextbound

ContextBoundDemo.scala
package day04

/**
  * [B : A] ContextBound
  */
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("shabi",51,21)
    val g2 = new Girl("chunhuo",45,21)

    val res = contextBoundDemo.select(g1,g2)

    println(res.name)
  }
}
MyPredef.scala
package day04

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
      }
    }
  }
  implicit object OrderingGirl extends Ordering[Girl]{
    override def compare(x: Girl, y: Girl): Int = {
      if (x.faceValue == y.faceValue){
        y.age - x.age
      }else {
        x.faceValue - y.faceValue
      }
    }
  }
}

©著作权归作者所有,转载或内容合作请联系作者
【社区内容提示】社区部分内容疑似由AI辅助生成,浏览时请结合常识与多方信息审慎甄别。
平台声明:文章内容(如有图片或视频亦包括在内)由作者上传并发布,文章内容仅代表作者本人观点,简书系信息发布平台,仅提供信息存储服务。

相关阅读更多精彩内容

  • 本文大量参考Thinking in java(解析,填充)。 定义:多态算是一种泛化机制,解决了一部分可以应用于多...
    谷歌清洁工阅读 3,325评论 0 2
  • 作者: 一字马胡 转载标志 【2017-11-03】 更新日志 1、上界通配符 首先,需要知道的是,Java语言...
    一字马胡阅读 5,016评论 0 12
  • 简介 泛型的意思就是参数化类型,通过使用参数化类型创建的接口、类、方法,可以指定所操作的数据类型。比如:可以使用参...
    零度沸腾_yjz阅读 8,563评论 1 15
  • 开发人员在使用泛型的时候,很容易根据自己的直觉而犯一些错误。比如一个方法如果接收List作为形式参数,那么如果尝试...
    时待吾阅读 4,692评论 0 3
  • 上个月被疯狂刷朋友圈的,是一个90后美男子。说是失联了。 朋友圈很少有同一个消息刷屏,包括之前的笑笑小朋友和超级月...
    气微味甜阅读 2,118评论 0 1

友情链接更多精彩内容