一、泛型
1.1不变、协变、逆变
语法
class MyList[+T] //协变
class MyList[-T] //逆变
class MyList[T] //不变
说明
协变：Son 是 Father 的子类，则 MyList[Son] 也作为 MyList[Father] 的“子类”。
逆变：Son 是 Father 的子类，则 MyList[Son] 作为 MyList[Father] 的“父类”。
不变：Son 是 Father 的子类，则 MyList[Father] 与 MyList[Son] “无父子关系”。
举例
class A
class B extends A
class C[T]
class D[+T]
class E[-T]
object GenericDemo2 {
def main(args: Array[String]): Unit = {
// 不变，因为泛型的不变性，虽然Int可以自动转为Double 但是数组的泛型维持不变性
/*val a: Array[Int] = Array(1, 2, 3, 4)
val b: Array[Double] = a*/ // error
// 不变，因为泛型的不变性，虽然B类继承A类，但是泛型不变性，所以无法赋值
/*val a: C[B] = new C[B]
val b: C[A] = a*/ // error
// 协变[+T]: 能把子类对象的集合，赋值给父类的集合
val a1: D[B] = new D[B]
val b1: D[A] = a1
// List 内部实现协变 ————> type List[+A] = scala.collection.immutable.List[A]
val a2: List[B] = List(new B)
val b2: List[A] = a2
//逆变[-T]：能把父类对象的集合，赋值给子类的集合
val a3: E[A] = new E[A]
val b3: E[B] = a3
}
}
1.2 泛型上下限
泛型的上下限的作用是对传入的泛型进行限定。
abstract class Animal val name: String
abstract class Pet extends Animal {}
class Dog extends Pet override val name: String = "dog"
class Cat extends Pet override val name: String = "cat"
class Lion extends Animal override val name: String = "lion"
// 限制传入参数的类型，最大为宠物Pet
class PetContainer[P <: Pet](val pet: P) {}
object TestGeneric {
def printer(petContainer: PetContainer[Pet]) = {
println(petContainer.pet.name)
}
def main(args: Array[String]): Unit = {
val dog: Dog = new Dog()
val cat: Cat = new Cat()
val lion: Lion = new Lion()
val dogContainer: PetContainer[Dog] = new PetContainer[Dog](dog)
val catContainer: PetContainer[Cat] = new PetContainer[Cat](cat)
val lionContainer: PetContainer[Lion] = new PetContainer[Lion](lion) //Error
}
}
1.3 上下文界定
def f[A : B](a:A) = println(a) // 等同于
def f[A](a:A)(implicit arg:B[A]) = println(a)
上下文限定是将 泛型 和 隐式转换的结合产物，以下两者功能相同，使用上下文限定 [A : Ordering] 之后，方法内无法使用隐式参数名调用隐式参数，需要通过 implicitly[Ordering[A]] 获取隐式变量。
def f[A:Ordering](a:A,b:A) =implicitly[Ordering[A]].compare(a,b)
def f[A](a: A, b: A)(implicit ord: Ordering[A]) = ord.compare(a, b)
二、补充
2.1 Option
Option：用于处理空指针问题。Some 和 None 是 Option 的两个子类。
2.2 Either
Either：用于结果的封装其中包含Left和Right函数 Left：一般封装错误结果 Right: 一般封装正确结果
2.3 无法类型推断的场景
- 推的类型和预期不一致，不能推导
- 递归函数的返回值不能推导
- 函数属性如果使用 _ 作为默认值，不不能推导
- 当显式的使用 return，返回值类型不能推导
2.4 _ 使用总结
- 通配符导入包
- 匿名函数的省略
- 部分应用函数
- 访问元组的元素
- 模式匹配中的通配符
- 给属性赋默认值
- 传递函数而不是调用函数(将方法转换为函数)
val f = foo _ - 分解集合元素: rest:*
接收集合元素：rest@*
2.5 apply 和 update
apply:
1.在伴生对象中定义apply，其中进行new对象操作，可以实现在外部用伴生对象(参数)的方式（默认调用apply）来创建对象
2.在类中定义apply，该类的对象可以直接使用对象(参数)的形式调用apply方法，
3.用apply去调用方法
update:
在类中定义update，该类的对象可以直接使用对象(参数)=值的形式，对参数进行更新
