scala的泛型

问题导入

定义一个的方法，用它来获取输入列表的中间位置上的元素（整型、字符串类型、浮点型）

object fx01 {

  def getMiddle_Int(arr:Array[Int]):Int = {
    arr(arr.length / 2)
  }

  def getMiddle_String(arr:Array[String]):String = {
    arr(arr.length / 2)
  }

  def getMiddle_Double(arr:Array[Double]):Double = {
    arr(arr.length / 2)
  }

  def main(args: Array[String]): Unit = {
  
    var m = getMiddle_Int(Array(1,2,3,4,5))
    println(s"数组的中间元素是:${m}")  // 数组的中间元素是:3

    var m1 = getMiddle_String(Array("aa","bb","cc"))
    println(s"数组的中间元素是:${m1}")  //数组的中间元素是:bb

    var m2 = getMiddle_Double(Array(1.1,2.2,3.3))
    println(s"数组的中间元素是:${m2}")  //数组的中间元素是:2.2
   
  }
}

类型是变化的！ 这里就可以使用泛型改进：使用泛型来定义。

泛型的概念

泛型的定义为：参数化类型，即所有操作的数据类型被指定为一个参数。

在Scala中，用[ ]表示（在java中使用<>）。

泛型方法

泛型方法指的是：把泛型定义放在方法声明上。即：该方法的参数类型是由泛型来决定的。在调用方法时，明确具体的数据类型。

定义方法： def 方法名泛型名称1，泛型名称2，. . . = {  }

调用方法： 方法名类型1，类型2，

如果在参数列表中可以推断出对应的类型，则可以省略方括号[类型1,类型2]

使用泛型方法来解决上面的问题

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

  def main(args: Array[String]): Unit = {
  
    var m = getMiddle(Array(1,2,3,4,5))
    println(s"数组的中间元素是:${m}")

    var m1 = getMiddle(Array("aa","bb","cc"))
    println(s"数组的中间元素是:${m1}")

    var m2 = getMiddle(Array(1.1,2.2,3.3))
    println(s"数组的中间元素是:${m2}")

    var m3 = getMiddle[Boolean](Array(true,false,true))
    println(s"数组的中间元素是:${m3}")  //数组的中间元素是:false

  }
}

泛型类

泛型类指的是：把泛型定义放在类的声明上。即：该类中的参数类型是由泛型来决定的。在创建对象的时候，再来明确具体的数据类型。

格式：class 类[T](val 变量：T)

定义集合（set,list,map,array）时，通过泛型来传递可以装入的数据类型

object fx02 {
  def main(args: Array[String]): Unit = {
    var li = scala.collection.mutable.ListBuffer[Int]()
    li += 1
    li += 2
    
    li.foreach(println)
  }
}

类内部的数据类型不确定

object fx03 {
  class Pair[T](var a:T,var b:T)

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

    val p1 = new Pair(1,2)
    println(p1.a) // 1
    println(p1.b) // 2

    val p2 = new Pair[Double](1.1,2.2) //可以省略[Double]，它可以自己推测出来
    println(p2.a) //1.1
    println(p2.b) //2.2
  }
}