SCALA--泛型

泛型函数在定义函数的时候，把参数类型提取出来，变成一个参数，用[]包起来

//需求：定义一个函数，用来将Array中的中间位置的元素值返回！
//Array(1,2,3,4,5)  ===> 3 ===>  中间元素的下标是：长度/2 ===>5/2=2
//Array(1,2,3,4)  ===> 3 ===>                             4/2=2
//问题：参数的类型是变化的 ===> 泛型 ====> 类型参数化
object Test_泛型 {
//  //Array:表示一个数组
//  //[Int]:表示数组中的元素是整形
//  def getMiddleEle1(arr:Array[String]):String={arr(arr.length/2)}
//  def getMiddleEle2(arr:Array[Int]):Int={arr(arr.length/2)}
//  def getMiddleEle3(arr: Array[Double]): Double = {arr(arr.length / 2)}

  //泛型函数在定义函数的时候，把参数类型提取出来，变成一个参数，用[]包起来

  def getMiddleEle[T](arr: Array[T]): T = {arr(arr.length / 2)}

  def main(args: Array[String]): Unit = {
//    var a = ArrayBuffer[Int]()//我定义一个可变数组，每一个元素都是Intl类型
//    a += 100
//    a += "xxx"
//    a.foreach(println)

    var arr1 =Array(1,2,3,4,5)
    var arr2 =Array("A","B","C")
    var arr3 =Array(1.2,1.3,1.4)

    var rs1=getMiddleEle[Int](arr1)
    var rs2=getMiddleEle[String](arr2)
    var rs3=getMiddleEle[Double](arr3)

    println(arr1)
    println(arr2)
    println(arr3)
  }
}

泛型类

object Test_泛型类 {
  //格式
  //定义：类名[T]
  //使用：类名[类型]
  abstract class A[T](){
    val data:Array[T]
  }
class A1 extends A[Int]{
  override val data: Array[Int] = Array(1,2,3)
}
  class A2 extends A[String]{
  override val data = Array("a","b","c")
}
  def main(args: Array[String]): Unit = {
    val a = new A1()
    val rs =a.data(1)
    println(rs)
    val b =new A2()
    val rs1=b.data(1)
    println(rs1)
  }
}

object Test_泛型trait {
trait Logger[T]{
  val name:T
  def show(b:T):Unit ={
    println(b)
  }
}

  class A extends Logger[String]{
    override val name = "test"
  }
  def main(args: Array[String]): Unit = {
    val a1 =new  A()
    a1.show("hi~")
  }
}

泛型的限定

//任务：定义一个函数，用来求List中最大的元素
object Test_泛型的限定 {
  def getMaxEle(list: List[Int]):Int={
    list.reduce((a,b)=> if(a>b) a else b)
  }

  //Pet
  //狗 < 猫
  def main(args: Array[String]): Unit = {
    val li1=List(1,2,3,4,5,0)
    //它的最大元素是5
    val rs1 = getMaxEle(li1)//5
    println(rs1)

    val li2 =List(1,1,22.1,3.1,1,1.4,5.9,6)
    val rs2 = getMaxEle(li2)//5.9
    println(rs1)

  }



}

泛型的上界，下界。对类型更加具体的约束

如果给某个泛型设置了上界：这里的类型必须是上界，及其子类
如果给某个泛型设置了下界：这里的类型必须是下界，及其父类

ect Test_泛型的限定2 {
  //爷爷 > 叔叔 > 兄弟
  class Person
  class Policeman extends Person
  class Superman extends Policeman
  //上界
  // T <:类型A。  我们说T的上界是类型A
  def demo[T](n:T)={
    println("n",n)
  }

  def main(args: Array[String]): Unit = {
   demo(new Person())
   demo(new Policeman())
   demo(new Superman())
  }
}

结果报错