scala的泛型

泛型的概念

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

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

举例：

val arr = ArrayBufferString

arr.insert(0, "a")

val arr1 = ArrayBufferInt

arr1.insert(0, 1)

泛型是对数据的类型的约束！

我们的学习内容包括：泛型方法，泛型类，泛型特质。

泛型方法

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

泛型方法的格式

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

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

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

使用泛型方法来解决本课开头提出的问题。

引导分析：大家看看的代码，确实可以使用多个函数来解决类型不同的问题，但是，我们分析一下，是不是就是参数类型不同？

参数类型不同，我们是否可以封装一个针对类型的参数？

编写代码如下

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

val arr1 = Array(1,2,3,4,5)

val arr2 = Array("a","b","c","d","e")

def getMiddleEle[T](arr:Array[T]): T = {

  arr(arr.length/2)
}

val i:Int = getMiddleEle[Int](arr1)

val j:String = getMiddleEle[String](arr2)

println(i,j )

}

package fx

object fx1 {
//  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[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}")
    var m1=getMiddle[String](Array("aa","bb","cc"))
    println(s"数组的中间元素是：${m1}")
    var m2=getMiddle[Double](Array(1.1,2.2,3.3))
    println(s"数组的中间元素是：${m2}")
    var m3=getMiddle[Boolean](Array(true,false,true))
    println(s"数组的中间元素是：${m3}")
  }

}

泛型特质

泛型特质指的是：把泛型定义放在trait的声明上。即：该特质中的参数类型是由泛型来决定的。在定义特质的子类或者子单例对象时，明确具体的数据类型。

格式

trait 特质A[T] {} class B extends 特质A[指定的数据类型] {}

需求：

1、定义泛型特质Logger，该特质有一个变量a和show方法，他们都是用Logger特质的泛型。

2、定义单例对象ConsoleLogger，继承Logger特质

//泛型类
//类内部的数据类型不确定，所以用泛型
package fx

object fx3 {

  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[Double](1.1,2.2)
    println(p2.a)
    println(p2.b)
  }

}