scala的泛型

泛型的定义

参数化类型，即所有操作的数据类型被指定为一个参数。 在Scala中，用[]表示（在java中使用<>）。

泛型函数

泛型方法

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

泛型方法的格式

定义方法

def 方法名 [泛型名称1，泛型名称2，. . .] (参数列表 ) = {  }

调用方法

方法名 [类型1，类型2，] (参数列表)

泛型函数的基本代码

package fx

/*
* getMiddle(Array(1,2,3,4,5)) ======>
*
* getMiddle(Array("1","2","3","4","5"))  ======>
 */

object fx01 {
//  def getMiddle_Int(arr:Array[Int]):Int={
//    // 长度/2
//    arr(arr.length/2)
//  }
//  def getMiddle_String(arr:Array[String]):String={
//    // 长度/2
//    arr(arr.length/2)
//  }
//
//  def getMiddle_Double(arr: Array[Double]): Double = {
//    // 长度/2
//    arr(arr.length / 2)
//  }

  def getMiddle[T](arr: Array[T]): T = {
    // 长度/2
    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

    var m3 = getMiddle[Boolean](Array(true,false,true))

    println(s"数组的中间元素是:${m3}")  //false
  }
}

理解泛型

泛型和数据类型有什么区别

case class Student()
val s1 = Student()
val list = ArrayList[Student]()
list += s1

ArrayList 是数据类型，Student是泛型。 他们不是一个层次的概念。 类型内部的数据使用泛型来约束。

泛型也称之为类型参数

泛型的声明方式是从外部把类型传入到类的内部，好比是传入参数一样。所以，泛型也称之为类型参数。如果参数没有传递，就说明不需要类型的约束，它也不会发生错误。而是采用通用类型。

在编译时有效，在运行时会失效

也就是说在代码被编译之后，在产生的代码中是看不到泛型相关的代码的。

泛型类

泛型类的定义

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

泛型类的格式

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

泛型类的需求

定义一个Pair泛型类，该类包含两个字段，且两个字段的类型不固定。创建不同类型的Pair泛型类对象，并打印

泛型类的基本代码

package fx

object fx03 {

  //泛型类
  //类内部的数据类型不确定，所以用泛型
  class Pair[T](var a:T,var b:T)

  def main(args: Array[String]): Unit = {
    val p1 = new Pair[Int](1,2)
    println(p1.a)
    println(p1.b)

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