型变：协变与逆变
掌握协变和逆变，正确处理泛型类型中的子类型关系。
型变：协变与逆变 是 CoddyKit 上的免费 Scala for Backend Engineering & Functional Programming 课时。 这是第 2 节课，共 3 节。 你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。 这是 Scala for Backend Engineering & Functional Programming 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 Scala for Backend Engineering & Functional Programming 课程共包含 3 节课。
什么是类型型变？
在 Scala 中，当您拥有一个类型层次结构时（例如，Cat 是 Animal 的子类型），泛型类型会如何表现？
List[Cat] 是否被视为 List[Animal] 的子类型？默认情况下并不总是如此！
类型型变让我们能够定义泛型类型如何保留（或反转）子类型关系。这对于编写灵活且类型安全的代码至关重要。
协变：“生产者”类型（+T）
协变通过在类型参数前放置 + 表示（例如 trait Box[+T]）。
- 如果
A是B的子类型，那么Box[A]就会成为Box[B]的子类型。 - 可以将协变类型理解为
T的“生产者”。它们只能出现在输出位置（例如方法的返回类型）中。 - 这意味着，如果您需要的是
Box[Animal]，就可以提供Box[Cat]，因为它“生产”了更具体的内容（Cat是Animal）。
协变的实际应用
请尝试运行以下协变 Producer 特质的示例：
class Animal
class Cat extends Animal
trait Producer[+T] {
def produce: T // Output position
}
class CatProducer extends Producer[Cat] {
def produce: Cat = new Cat
}
object Main {
def main(args: Array[String]): Unit = {
val catProducer: Producer[Cat] = new CatProducer
// Because Producer is covariant, Producer[Cat] is a subtype of Producer[Animal]
val animalProducer: Producer[Animal] = catProducer
println("Assigned CatProducer to AnimalProducer.")
println(s"Produced: ${animalProducer.produce.getClass.getSimpleName}")
}
}何时使用协变
当泛型类型只“生产”T 类型的值，或从不接受 T 作为参数时，协变是安全的。
- 像
List[+T]这样的不可变集合就是典型示例。您可以将List[Cat]视为List[Animal]，因为您只会从中“读取”Animal或其子类型。 - 如果它被声明为
List[Animal]，您不能向List[Cat]添加任意的Animal，这保证了类型安全。
逆变：“消费者”类型（-T）
逆变通过在类型参数前放置 - 表示（例如 trait Consumer[-T]）。
- 如果
A是B的子类型，那么Consumer[B]就会成为Consumer[A]的子类型。 - 可以将逆变类型理解为
T的“消费者”。它们只能出现在输入位置（例如方法的参数类型）中。 - 这意味着，如果您需要的是
Consumer[Cat]，就可以提供Consumer[Animal]，因为它“消费”了更通用的内容（它能够处理任何Animal，包括Cat）。
逆变的实际应用
请尝试运行以下逆变 Consumer 特质的示例：
class Animal
class Cat extends Animal
trait Consumer[-T] {
def consume(item: T): Unit // Input position
}
class AnimalConsumer extends Consumer[Animal] {
def consume(item: Animal): Unit = {
println(s"Consumed an animal: ${item.getClass.getSimpleName}")
}
}
object Main {
def main(args: Array[String]): Unit = {
val animalConsumer: Consumer[Animal] = new AnimalConsumer
// Because Consumer is contravariant, Consumer[Animal] is a subtype of Consumer[Cat]
val catConsumer: Consumer[Cat] = animalConsumer
catConsumer.consume(new Cat)
println("Assigned AnimalConsumer to CatConsumer.")
}
}何时使用逆变
当泛型类型只“消费”T 类型的值，或从不返回 T 时，逆变是安全的。
- 一个常见示例是函数，尤其是输入参数类型。如果一个函数可以处理任何
Animal（Animal => Unit），那么它当然可以处理Cat。因此，(Animal => Unit)是(Cat => Unit)的子类型。 - 这让您在将函数作为参数传递时拥有更大的灵活性。
不变：默认行为
如果不指定 + 或 -，类型参数就是不变的。这是 Scala 中的默认行为。
- 只有当
A与B完全是同一类型时，Box[A]才是Box[B]的子类型。 - 对于可变集合来说，这通常是必要的（例如
Array[T]），因为您可能同时读写不同的子类型，而这会引发类型安全问题。
class Food
class Apple extends Food
// Invariant Box
class Box[T](val item: T) {
def getContent: T = item
}
object Main {
def main(args: Array[String]): Unit = {
val appleBox = new Box(new Apple)
// The following line would cause a compile error:
// val foodBox: Box[Food] = appleBox
println(s"An Apple Box contains: ${appleBox.getContent.getClass.getSimpleName}")
println("Box[Apple] is NOT a subtype of Box[Food] (invariant).")
println("The types must match exactly for invariant types.")
}
}函数：同时具备协变与逆变
Scala 的函数类型 Function1[-A, +B] 巧妙地结合了两种型变：
- 输入参数
A是逆变的（-A）。这意味着，接受更通用类型（例如Animal）的函数，可以在需要接受更具体类型（例如Cat）的函数的位置使用。 - 返回类型
B是协变的（+B）。这意味着，返回更具体类型（例如Cat）的函数，可以在需要返回更通用类型（例如Animal）的函数的位置使用。
class Vehicle
class Car extends Vehicle
object Main {
def main(args: Array[String]): Unit = {
// Contravariance for input: (Vehicle => Unit) is a subtype of (Car => Unit)
val printVehicle: Vehicle => Unit = (v: Vehicle) => println(s"Printing vehicle: ${v.getClass.getSimpleName}")
val printCar: Car => Unit = printVehicle // OK: A general printer can print a specific car
printCar(new Car)
// Covariance for output: (() => Car) is a subtype of (() => Vehicle)
val getCar: () => Car = () => new Car
val getVehicle: () => Vehicle = getCar // OK: A specific producer can fulfill a general request
println(s"Got vehicle: ${getVehicle().getClass.getSimpleName}")
}
}快速检查：型变规则
请考虑以下特质：
trait Handler[T] {
def handle(item: T): Unit
}若要允许在需要 Handler[Cat] 的位置使用 Handler[Animal]（其中 Cat extends Animal），T 应使用哪种型变注解？
回顾：掌握类型型变
您已经掌握了 Scala 中的类型型变！下面快速回顾一下：
- 协变（
+T）：允许Container[Subtype]成为Container[Supertype]的子类型。适用于只返回T的“生产者”类型。 - 逆变（
-T）：允许Container[Supertype]成为Container[Subtype]的子类型。适用于只接受T作为输入的“消费者”类型。 - 不变：默认行为。类型必须完全匹配。
理解型变有助于您在 Scala 中创建更灵活且类型安全的泛型代码！
常见问题解答
「型变：协变与逆变」课时是免费的吗？
是的 — 「型变：协变与逆变」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Scala for Backend Engineering & Functional Programming 课程的其余内容，请升级到 CoddyKit PRO。 Scala for Backend Engineering & Functional Programming 课程共包含 3 节课。
「型变：协变与逆变」这节课中我会学到什么？
掌握协变和逆变，正确处理泛型类型中的子类型关系。 你通过在浏览器中直接运行的动手代码来练习 Scala for Backend Engineering & Functional Programming，全天候 AI 导师会在你学习这节课的过程中回答你的问题。
学习 Scala for Backend Engineering & Functional Programming 需要有经验吗？
无需任何先前经验。CoddyKit 上的 Scala for Backend Engineering & Functional Programming 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。 这是第 2 节课，共 3 节。
「型变：协变与逆变」课时需要多长时间？
大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。
我能在这节 Scala for Backend Engineering & Functional Programming 课中编写并运行代码吗？
能。每节 Scala for Backend Engineering & Functional Programming 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。