Scala 泛型与补充知识

一、泛型

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 无法类型推断的场景

1. 推的类型和预期不一致，不能推导
2. 递归函数的返回值不能推导
3. 函数属性如果使用 _ 作为默认值，不不能推导
4. 当显式的使用 return，返回值类型不能推导

2.4 _ 使用总结

1. 通配符导入包
2. 匿名函数的省略
3. 部分应用函数
4. 访问元组的元素
5. 模式匹配中的通配符
6. 给属性赋默认值
7. 传递函数而不是调用函数(将方法转换为函数)
   val f = foo _
8. 分解集合元素: rest:*
   接收集合元素：rest@*

2.5 apply 和 update

apply:
1.在伴生对象中定义apply，其中进行new对象操作，可以实现在外部用伴生对象(参数)的方式（默认调用apply）来创建对象
2.在类中定义apply，该类的对象可以直接使用对象(参数)的形式调用apply方法，
3.用apply去调用方法
update:
在类中定义update，该类的对象可以直接使用对象(参数)=值的形式，对参数进行更新