泛型和隐式转换
泛型
泛型类 [T]
def main(args: Array[String]): Unit = {
// 通过传递的参数自动推断泛型类型 (参数中用到了所有的泛型)
val s1 = new Student("丽萨",1)
// 直接指定泛型类型
val s2 = new Student[String,Int]("明明",2)
// 指定参数类型的父类为泛型
val s3 = new Student[Any,Any]("小刚",3)
}
// 泛型类
class Student[T,S](info1: T, info2: S){
println(info1,info2)
}
泛型函数 [T]
def fun[T](field: T): Unit ={
println(field)
}
泛型边界 [T <: 父类] [T >: 子类]
- <: 指明上界，表达了泛型的类型必须是"某种类型"或某种类型的"子类"
- >: 指明下界，表达了泛型的类型必须是"某种类型"或某种类型的"父类"
def main(args: Array[String]): Unit = {
up[C2](new C2)
// 报错! 超出上边界
// up(new C1)
// 必须需要指定[class], new C3会自动转为匹配的的父类
down[C3](new C3)
}
// 指定泛型上限
def up[T <: C2](field: T): Unit = {
println("Up")
}
// 指定泛型下限
def down[T >: C2](field: T): Unit = {
println("Down")
}
class C1 {}
class C2 extends C1 {
println("C2 < C1")
}
class C3 extends C2 {
println("C3 < C2 < C1")
}
class C4 {
println("C4")
}
视图界定
// 视图界定,希望跨越类继承层次结构时，可以使用视图界定来实现的
def view[T <% Comparable[T]](first: T, second: T): Unit = {
println(first.compareTo(second))
}
// 泛型视图界定
// Int隐式转换成RichInt，RichInt是Comparable[Int]的子类
view[Int](4, 2)
协变和逆变
协变
class C1 {}
class C2 extends C1 {
println("C2 < C1")
}
// 协变, 子类可以赋值给父类型
val child = new C5[C2](new C2)
val parent: C5[C1] = child
// 协变泛型
class C5[+T](field: T) {}
逆变
class C1 {}
class C2 extends C1 {
println("C2 < C1")
}
// 逆变泛型
class C6[-T](field: T) {}
// 逆变, 父类可以赋值给子类
val parent1 = new C6[C1](new C1)
val child1: C6[C2] = parent1
隐式转换
// 定义Double类型 隐式转换为 Int类型
implicit def doubleToInt(d: Double) = d.toInt
val i: Int = 3.14
println(s"i = $i")
i = 3
说明: implicit def 方法名(变量名: 转换的类型) = 返回的转换结果
// 调入隐式转换
import spark.implicits._
隐式转换发生的时机
需要的参数的类型与实际类型不一致时
def fun(x: Int) = {}
fun(3.14)
调用对象不存在的方法时
class C1 {
def fun() = {}
}
val c = new C1()
c.read()
隐式参数
def main(args: Array[String]): Unit = {
// 定义隐式变量, 使用时会隐式返回 C1类的对象
implicit val c = new C1()
funC("log!")
}
def funC(info: String)(implicit c1: C1): Unit = {
c1.fun(info)
}
class C1 {
def fun(info: String) = {
println("fun info = " + info)
}
}
fun info = log!
