泛型

泛型类

// 创建一个通用类，技能操作Int类型，又能操作String类型
class GenericClass[T] {private var content:T = _ // 泛型def set(value:T) = {content = value}def get():T= {content}
}object GenericClass{def main(arg: Array[String]): Unit = {// Int类型var intGeneric = new GenericClass[Int]intGeneric.set(123)println(intGeneric.get()) // 123// String类型var stringGeneric = new GenericClass[String]stringGeneric.set("hello scala")println(stringGeneric.get()) // 'hello scala'}
}

泛型函数

• 在泛型函数中，T必须是ClassTag类型
• ClassTag表示执行Scala程序时的运行信息；在下例中，表示数据的类型

import scala.reflect.ClassTag
// 创建一个通用函数，既能创建Int类型数组，又能创建String类型数组
def mkArray[T:ClassTag](elems:T*) = Array[T](elems:_*)
mkArray(1,2,3)
mkArray('a','b','c')

上界、下界

• 规定泛型的取值范围
• 假设继承关系：（父）A —> B —> C —> D（子），则，D <: y泛型 <: B 表示，y的类型只能是B、C、D
• 定义：
  • 上界：S <: T，表示S的类型必须是T的子类
  • 下界：U >: T，表示U的类型必须是T的父类

// 上界举例
// 父类
class Vehicle{def drive() = {println("Driving")}
}// 子类一
class Car extends Vehicle{override def drive(): Unit = {println("Car Driving")}
}
// 子类二
class Bike extends Vehicle{override def drive(): Unit = {println("Bike Driving")}
}// 其他类
class Appleobject ScalaUpperBound{// 定义一个泛型函数def takeVehicle[T <: Vehicle(v:T)] = {v.drive()}def main(args: Array[String]): Unit = {var v1:Vehicle = new Vehiclevar v2:Car = new Carvar v3:Apple = new AppletakeVehicle(v1) // 正常takeVehicle(v2) // 正常takeVehicle(v3) // 异常}
}

视图界定

• 上下界的扩展，适用范围更广泛
• 以上界为例 <:
  • 除了接收所有的子类，还允许接受隐式转换过去的类型
  • 需要定义转化规则（隐式转换函数）

// 普通上下界
def addTwoString[T <: String](x:T, y:T) = {println(x + y)}addTwoString("hello", "world") 
addTwoString(100, 200) // 异常// 视图界定
implicit def int2String(n:Int):String = {n.toString}
def addTwoString[T <% String](x:T, y:T) = {println(x + y)}
// T表示的类型：
// (1) String和String的子类
// (2) 可以转换成String类型的类型addTwoString("hello", "world") 
addTwoString(100, 200) // 正常 100200

协变和逆变

• 可以看作是视图界定的一个扩展
• 缺点：降低了代码的可读性
• 协变：若一个泛型类接受的泛型参数可以是本身的类型或子类的类型
  • 在泛型前加+

// 协变// 动物
class Animal// 子类：鸟
class Bird extends Animal// 子类：麻雀
class Sparrow extends Bird// 类：吃
class EatSomething[+T](t:T){} // 在T之前加`+`后，下面的问题就没有了object Demo{def main(args: Array[String]): Unit = {// 鸟吃东西的对象var c1:EatSomething[Bird] = new EatSomething[Bird](new Bird)// 动物吃东西的对象// 方法一// var c2:EatSomething[Animal] = new EatSomething[Animal](new Animal)// 方法二：将c1付给c2// 问题：尽管Bird是Animal的子类，但EatSomething[Bird]不是EatSomething[Animal]的子类var c2:EatSomething[Animal] = c1var c3:EatSomething[Sparrow] = new EatSomething[Sparrow](new Sparrow)var c4:EatSomething[Animal] = c3}
}

• 逆变：若一个泛型类接受的泛型参数可以是本身的类型或父类的类型
  • 在泛型前加-

// 逆变// 动物
class Animal// 子类：鸟
class Bird extends Animal// 子类：麻雀
class Sparrow extends Bird// 类：吃
class EatSomething[-T](t:T){} // 在T之前加`-`后，下面的问题就没有了object Demo2{def main(args: Array[String]): Unit = {// 鸟吃东西的对象var c1:EatSomething[Bird] = new EatSomething[Bird](new Bird)// 麻雀吃东西的对象// 方法一// var c2:EatSomething[Sparrow] = new EatSomething[Sparrow](new Sparrow)// 方法二：将c1付给c2// 问题：尽管Bird是Sparrow的父类，但EatSomething[Bird]不是EatSomething[Sparrow]的父类var c2:EatSomething[Sparrow] = c1}
}

隐式转换函数

• 函数前加implicit

// 水果
class Fruit(name:String){def getFruitName():String = {name}
}// 猴子
class Monkey(f:Fruit){def say() = {println("Monkey like " + f.getFruitName())}
}object ImplicitDemo{// 定义隐式转换函数：Fruit对象 ==> Monkey对象implicit def fruit2Monkey(f:Fruit): Monkey = {new Monkey(f)}def main(args: Array[String]): Unit = {var f:Fruit = new Fruit("香蕉")// 将Fruit的对象转换成Monkey的对象f.say() // "Monkey like 香蕉"}
}

隐式参数

• 变量前加implicit

def testParam(implicit name:String) = {println("The value is " + name)}// 定义隐式参数
implicit val name:String = "这是一个隐式参数"
// 调用，且不传递参数
testParam // 程序在运行时会检查当前有没有类型为String的name，如果有则自动将该参数传入函数

隐式类

• class前加implicit
• 作用：对类的功能进行加强

object ImplicitDemo2{// 定义隐式类implicit class Calculate(x:Int){def add(y:Int) = x + y}def main(args: Array[String]): Unit = {// 进行两个数的相加 1.add(2)println(1.add(2)) // 3// 顺序：// 先调用隐式转换类，把 1 ==> Calculate对象// 再调用Calculate对象的add方法}
}