泛型的意思是泛指某种具体的数据类型, 在Scala中, 泛型用[数据类型]表示. 在实际开发中, 泛型一般是结合数组或者集合来使用的, 除此之外, 泛型的常见用法还有以下三种:
泛型方法
泛型类
泛型特质
1.1 泛型方法
泛型方法指的是把泛型定义到方法声明上, 即:该方法的参数类型是由泛型来决定的. 在调用方法时, 明确具体的数据类型.
格式
def 方法名泛型名称 = { //...}需求
定义方法getMiddleElement(), 用来获取任意类型数组的中间元素.
思路一: 不考虑泛型直接实现（基于Array[Int]实现）
思路二: 加入泛型支持.
参考代码
//案例: 泛型方法演示.//细节: 泛型方法在调用方法的时候 明确具体的数据类型.object ClassDemo01 { //需求: 用一个方法来获取任意类型数组的中间的元素 //思路一:不考虑泛型直接实现（基于Array[Int]实现） //def getMiddleElement(arr: Array[Int]) = arr(arr.length / 2) //思路二: 加入泛型支持 def getMiddleElementT = arr(arr.length / 2) def main(args: Array[String]): Unit = { //调用方法 println(getMiddleElement(Array(1, 2, 3, 4, 5))) println(getMiddleElement(Array("a", "b", "c"))) }}1.2 泛型类
泛型类指的是把泛型定义到类的声明上, 即:该类中的成员的参数类型是由泛型来决定的. 在创建对象时, 明确具体的数据类型.
格式
class 类T
需求
定义一个Pair泛型类, 该类包含两个字段，且两个字段的类型不固定.
创建不同类型的Pair泛型类对象，并打印.
参考代码
//案例: 泛型-演示泛型类的使用.//泛型类: 在创建对象的时候, 明确具体的数据类型.object ClassDemo02 { //1. 实现一个Pair泛型类 //2. Pair类包含两个字段，而且两个字段的类型不固定 class PairT def main(args: Array[String]): Unit = { //3. 创建不同类型泛型类对象，并打印 var p1 = new PairInt println(p1.a, p1.b) var p2 = new PairString println(p2.a, p2.b) }}1.3 泛型特质
泛型特质指的是把泛型定义到特质的声明上, 即:该特质中的成员的参数类型是由泛型来决定的. 在定义泛型特质的子类或者子单例对象时, 明确具体的数据类型.
格式
trait 特质A[T] { //特质中的成员}class 类B extends 特质A[指定具体的数据类型] { //类中的成员}需求
定义泛型特质Logger, 该类有一个变量a和show()方法, 它们都是用Logger特质的泛型.
定义单例对象ConsoleLogger, 继承Logger特质.
打印单例对象ConsoleLogger中的成员.
参考代码
//案例: 演示泛型特质.object ClassDemo03 { //1. 定义泛型特质Logger, 该类有一个a变量和show()方法, 都是用Logger特质的泛型. trait Logger[T] { //定义变量 val a:T //定义方法. def show(b:T) = println(b) } //2. 定义单例对象ConsoleLogger, 继承Logger特质. object ConsoleLogger extends Logger[String]{ override val a: String = "张三" } //main方法, 作为程序的主入口. def main(args: Array[String]): Unit = { //3. 打印单例对象ConsoleLogger中的成员. println(ConsoleLogger.a) ConsoleLogger.show("10") }}2. 上下界
我们在使用泛型(方法, 类, 特质)时，如果要限定该泛型必须从哪个类继承、或者必须是哪个类的父类。此时，就需要使用到泛型的上下界。
2.1 上界
使用T <: 类型名表示给类型添加一个上界，表示泛型参数必须要从该类（或本身）继承.
格式
[T <: 类型]
例如: [T <: Person]的意思是, 泛型T的数据类型必须是Person类型或者Person的子类型
需求
定义一个Person类
定义一个Student类，继承Person类
定义一个泛型方法demo()，该方法接收一个Array参数.
限定demo方法的Array元素类型只能是Person或者Person的子类
测试调用demo()方法，传入不同元素类型的Array
参考代码
//案例: 演示泛型的上下界之 上界.object ClassDemo04 { //1. 定义一个Person类 class Person //2. 定义一个Student类，继承Person类 class Student extends Person //3. 定义一个demo泛型方法，该方法接收一个Array参数， //限定demo方法的Array元素类型只能是Person或者Person的子类 def demoT <: Person = println(arr) def main(args: Array[String]): Unit = { //4. 测试调用demo，传入不同元素类型的Array //demo(Array(1, 2, 3)) //这个会报错, 因为只能传入Person或者它的子类型. demo(Array(new Person())) demo(Array(new Student())) }}2.2 下界
使用T >: 数据类型表示给类型添加一个下界，表示泛型参数必须是从该类型本身或该类型的父类型.
格式
[T >: 类型]
注意:
例如: [T >: Person]的意思是, 泛型T的数据类型必须是Person类型或者Person的父类型
如果泛型既有上界、又有下界。下界写在前面，上界写在后面. 即: [T >: 类型1 <: 类型2]
需求
定义一个Person类
定义一个Policeman类，继承Person类
定义一个Superman类，继承Policeman类
定义一个demo泛型方法，该方法接收一个Array参数，
限定demo方法的Array元素类型只能是Person、Policeman
测试调用demo，传入不同元素类型的Array
参考代码
//案例: 演示泛型的上下界之 下界.//如果你在设定泛型的时候, 涉及到既有上界, 又有下界, 一定是: 下界在前, 上界在后.object ClassDemo05 { //1. 定义一个Person类 class Person //2. 定义一个Policeman类，继承Person类 class Policeman extends Person //3. 定义一个Superman类，继承Policeman类 class Superman extends Policeman //4. 定义一个demo泛型方法，该方法接收一个Array参数， //限定demo方法的Array元素类型只能是Person、Policeman // 下界 上界 def demoT >: Policeman <: Policeman = println(arr) def main(args: Array[String]): Unit = { //5. 测试调用demo，传入不同元素类型的Array //demo(Array(new Person)) demo(Array(new Policeman)) //demo(Array(new Superman)) //会报错, 因为只能传入: Policeman类获取它的父类型, 而Superman是Policeman的子类型, 所以不行. }}2.3 上下文限定
语法
def fA : B = println(a) //等同于 def fA(implicit arg:B[A])=println(a) 2）
说明
上下文限定是将泛型和隐式转换的结合产物，以下两者功能相同，使用上下文限定[A : Ordering]之后，方法内无法使用隐式参数名调用隐式参数，需要通过 implicitly[Ordering[A]] 获取隐式变量，如果此时无法查找到对应类型的隐式变量，会发生出错误。
implicit val x = 1val y = implicitly[Int] val z = implicitly[Double]
案例
def fA:Ordering =implicitly[Ordering[A]].compare(a,b) def fA(implicit ord: Ordering[A]) = ord.compare(a, b)
3. 协变、逆变、非变
非变: 类A和类B之间是父子类关系, 但是Pair[A]和Pair[B]之间没有任何关系.
协变: 类A和类B之间是父子类关系, Pair[A]和Pair[B]之间也有父子类关系.
逆变: 类A和类B之间是父子类关系, 但是Pair[A]和Pair[B]之间是子父类关系.
class MyList[+T]{ //协变}class MyList[-T]{ //逆变}class MyList[T] //非变默认是非变
案例
//非变//class MyList[T]{}//协变//class MyList[+T]{}//逆变//class MyList[-T]{}class Parent{}class Child extends Parent{} class SubChild extends Child{}object Scala_TestGeneric {def main(args: Array[String]): Unit = {//var s:MyList[Child] = new MyList[SubChild]}}