1. 程式人生 > >Scala Type Parameters 2

Scala Type Parameters 2

  • 型別關係

    Scala 支援在泛型類上使用型變註釋,用來表示複雜型別、組合型別的子型別關係間的相關性

    • 協變 +T,變化方向相同,通常用在生產

      假設 A extends T, 對於 Clazz[+T],則 Clazz[A] 也可看做 Clazz[T]

      // 官網示例
      abstract class Animal {
        def name: String
      }
      case class Cat(name: String) extends Animal
      case class Dog(name: String) extends Animal
      

      由於 Scala 標準庫中不可變 List 的定義為 List[+A]

      ,因此 List[Cat]List[Animal] 的子型別, List[Dog] 也是 List[Animal] 的子型別,所以可直接將他們當作 List[Animal] 使用。

      // 官網示例
      object CovarianceTest extends App {
        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
      }
      
    • 逆變 -T,變化方向相反,通常用在消費

      假設 A extends T, 對於 Clazz[-T],則 Clazz[T] 也可看做 Clazz[A]

      // 官網示例
      abstract class Printer[-A] {
        def print(value: A): Unit
      }
      
      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)
      }
      
      object ContravarianceTest extends App {
        val myCat: Cat = Cat("Boots")
      
        def printMyCat(printer: Printer[Cat]): Unit = {
          printer.print(myCat)
        }
      
        val catPrinter: Printer[Cat] = new CatPrinter
        val animalPrinter: Printer[Animal] = new AnimalPrinter
      
        printMyCat(catPrinter)
        printMyCat(animalPrinter) // 將 Printer[Animal] 當作 Printer[Cat] 使用
      }