Scala | 泛型 ## 一、泛型的概念 #### 泛型的定义为：**参数化类型**，即所有操作的数据类型被指定为一个

一、泛型的概念

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

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

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

object fx01 {

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

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

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

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

    var m = getMiddel_Int(Array(1, 2, 3, 4, 5))
    println(s"数组的中间元素是：${m}")

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

    var m2 = getMiddel_Double(Array(1.2, 2.2, 3.3))
    println(s"数组的中间元素是：${m2}")

  }

}

二、泛型方法

泛型方法指的是：把泛型定义放在方法声明上。

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

三、泛型方法的格式

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

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

object fx01 {

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

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

    var m = getMiddel[Int](Array(1, 2, 3, 4, 5))
    println(s"数组的中间元素是：${m}")

    var m1 = getMiddel[String](Array("aa","bb","cc"))
    println(s"数组的中间元素是：${m1}")

    var m2 = getMiddel[Double](Array(1.2, 2.2, 3.3))
    println(s"数组的中间元素是：${m2}")

  }

}

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

ArrayList 是数据类型，Student是泛型。

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

五、泛型类

泛型类指的是：把泛型定义放在类的声明上。

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

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

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(p1.a)
    println(p1.b)
  }

}

六、泛型特质

泛型特质指的是：把泛型定义放在trait的声明上。

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

格式：

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

需求：

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

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

Scala | 泛型