scala的泛型

泛型的概念

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

在Scala中，用[]表示

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

泛型方法

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

泛型方法的格式

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

def getMiddle[T](arr:Array[T]):T={
  // 长度/2
  arr(arr.length/2)

}

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

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}")// 2.2

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

基本代码：

package fx

object fx01 {
  /*
  * getMiddle(Array(1,2,3,4,5)) ===>3
  *
  * getMiddle(Array("1","2","3","4","5")) ===>3
  * */
//  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}")

    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}")// 2.2

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

  }

}

理解泛型：

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

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

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

3、在编译时有效，在运行时会失效。也就是说在代码被编译之后，在产生的代码中是看不到泛型相关的代码的。

基本代码：

package fx

object fx02 {

  /*
  * 泛型，参数化类型，函数中的参数是什么类型？这个类型是可以动态设置的！
  * 定义集合（set，list，map，array）时，通过泛型来传递可以装入的数据类型
  * */


  def main(args: Array[String]): Unit = {
   var li=scala.collection.mutable.ListBuffer[Int]()

    li+=1
    li+=2
    li.foreach(println)
  }

}

泛型 类

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

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

泛型类的步骤格式：先写一个普通的类 -> 把参数的类型（或者返回值的类型，或者内部属性成员的类型）改成泛型名 -> 在类名的后面添加[泛型]

基本代码：

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[Double](1.1,2.2)//省略double，他可以自己推测出来
    println(p2.a)
    println(p2.b)
  }

}

泛型 特质

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

格式：

trait 特质A[T] {}

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

需求：

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

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