专栏原创出处：github-源笔记文件 (opens new window) ，github-源码 (opens new window)，欢迎 Star，转载请附上原文出处链接和本声明。

Scala 编程语言专栏系列笔记，系统性学习可访问个人复盘笔记-技术博客 Scala 编程语言 (opens new window)

• 什么是型变
• 定义协变
• 定义逆变
• 定义不变

什么是型变

型变就是复杂类型的数据其组件类型存在继承关系时，复杂类型数据是否也有相对应的关系。

• 泛型类的类型参数支持型变注释，允许它们是协变的，逆变的，在没有使用注释的情况下是不变的。

• 在类型系统中使用型变允许我们在复杂类型之间建立直观的连接，而缺乏型变则会限制类抽象的重用性。

定义协变

使用注释 +A，可以使一个泛型类的类型参数 A 成为协变。
对于某些类 class List[+A]，使 A 成为协变意味着对于两种类型 A 和 B，如果 A 是 B 的子类型，那么 List[A] 就是 List[B] 的子类型。

  abstract class Animal {
    def name: String
  }
  case class Cat(name: String) extends Animal
  case class Dog(name: String) extends Animal
  
  // Scala 标准库有一个通用的不可变的类 sealed abstract class List[+A]，其中类型参数 A 是协变的。
  // List 的参数是支持协变的，并且 Cat 和 Dog 都是 Animal 的子类
  // 所以，List[Cat] 和 List[Dog] 也是 List[Animal] 的子类型，可以作为参数传入 printAnimalNames 方法
  def printAnimalNames(animals: List[Animal]): Unit = {
      animals.foreach { animal =>
        println(animal.name)
      }
  }
  
  val cats: List[Cat] = List(Cat("Whiskers"), Cat("Tom"))
  val dogs: List[Dog] = List(Dog("Fido"), Dog("Rex"))
  printAnimalNames(cats)
  // Whiskers
  // Tom
  printAnimalNames(dogs)
  // Fido
  // Rex

定义逆变

通过使用注释 -A，可以使一个泛型类的类型参数 A 成为逆变。
对于某个类 class Writer[-A]，使 A 逆变意味着对于两种类型 A 和 B，如果 A 是 B 的子类型，那么 Writer[B] 是 Writer[A] 的子类型。

  abstract class Animal {
    def name: String
  }
  case class Cat(name: String) extends Animal
  case class Dog(name: String) extends Animal
  
  abstract class Printer[-A] {
    def print(value: A): Unit
  }
  // AnimalPrinter 继承了 Printer，Printer 泛型支持逆变
  // 由于 Cat 是 Animal 的子类型，所以 Printer[Animal] 是 Printer[Cat] 的子类型
  // 从逻辑上因为 Printer[Animal] 可以输出所有动物的名称，因此也可以输出 Cat，这是合理的。
  // 但是 Printer[Cat] 只能输出 Cat，并不可以输出其他的 Animal，所以 Printer[Animal] 可以替换 Printer[Cat]
  class AnimalPrinter extends Printer[Animal] {
    def print(animal: Animal): Unit =
      println("The animal's name is: " + animal.name)
  }
  
  class CatPrinter extends Printer[Cat] {
    def print(cat: Cat): Unit =
      println("The cat's name is: " + cat.name)
  }
  
  val myCat: Cat = Cat("Boots")
  // Printer 支持逆变，因此该方法可以接收 Printer[Animal] 类型的参数。
  def printMyCat(printer: Printer[Cat]): Unit = {
    printer.print(myCat)
  }
  
  val catPrinter: Printer[Cat] = new CatPrinter
  val animalPrinter: Printer[Animal] = new AnimalPrinter
  
  printMyCat(catPrinter) // The cat's name is: Boots
  printMyCat(animalPrinter) // The animal's name is: Boots

定义不变

默认不加任何修饰的情况下，Scala 中的泛型类是不变的。这意味着它们既不是协变的也不是逆变的。

  // Container 是不变的。 Container[Cat] 不是 Container[Animal] 的子类型
  class Container[A](value: A) {
    private var _value: A = value
    def getValue: A = _value
    def setValue(value: A): Unit = {
      _value = value
    }
  }
  // Container 不是协变的，是不变的，这点很重要，否则会将狗的值分配给猫
  val catContainer: Container[Cat] = new Container(Cat("Felix"))
  val animalContainer: Container[Animal] = catContainer // 编译报错
  animalContainer.setValue(Dog("Spot"))
  val cat: Cat = catContainer.getValue