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

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

• 什么是泛型类
• 如何定义泛型类
• 如何使用泛型类
• 什么是类型上界
• 什么是类型下界

什么是泛型类

泛型类指可以接受类型参数的类，在 类名 后 + [类型参数 ],例如：class Stack[A]。
泛型类在集合类中被广泛使用，例如 Scala 集合的 List、Map、Seq 等等。

如何定义泛型类

泛型类使用方括号 [] 来接受类型参数。
一个惯例是使用字母 A 作为参数标识符，当然你可以使用任何参数名称。

  class Stack[A] {
    private var elements: List[A] = scala.collection.immutable.Nil // 只可以存放 A 类型的元素
    def push(x: A) { elements = x :: elements } // 将 A 类型元素添加到 elements 头部，生成新的集合
    def peek: A = elements.head
    def pop(): A = {
      val currentTop = peek
      elements = elements.tail
      currentTop
    }
  }

如何使用泛型类

要使用一个泛型类，将一个具体类型放到方括号中来代替 A。
如果类型参数有子类型，泛型类中的方法也可以接受类型参数子类型的数据。

  class Stack[A] {
    private var elements: List[A] = scala.collection.immutable.Nil // 只可以存放 A 类型的元素
    def push(x: A) { elements = x :: elements } // 将 A 类型元素添加到 elements 头部，生成新的集合
    def peek: A = elements.head
    def pop(): A = {
      val currentTop = peek
      elements = elements.tail
      currentTop
    }
  }

  // stack 可以接受 Int 类型数据
  val stack = new Stack[Int]
  stack.push(1)
  stack.push(2)
  println(stack.pop)  // prints 2
  println(stack.pop)  // prints 1
  
  // stack1 可以接受 Fruit 类型数据，Fruit 子类型数据同样也可以接受
  class Fruit
  class Apple extends Fruit
  class Banana extends Fruit
 
  val stack1 = new Stack[Fruit]()
  val apple = new Apple
  val banana = new Banana
  
  stack1.push(apple)
  stack1.push(banana)

什么是类型上界

类型上界是将类型声明为另一种类型的子类型。

• 声明类型上界：B <: A,表示类型参数 B 或抽象类型 B 是类型 A 的子类型。

abstract class Animal {
 def name: String
}
abstract class Pet extends Animal {}

class Cat extends Pet {
  override def name: String = "Cat"
}

class Dog extends Pet {
  override def name: String = "Dog"
}

class Lion extends Animal {
  override def name: String = "Lion"
}
// PetContainer 接收的参数 p 必须是 Pet 的子类型 P。
class PetContainer[P <: Pet](p: P) {
  def pet: P = p
}
// Cat 和 Dog 都是 Pet 的子类型，所以可以作为参数传入 PetContainer 中。
val dogContainer = new PetContainer[Dog](new Dog)
val catContainer = new PetContainer[Cat](new Cat)
// Lion 不是 Pet 的子类型，因此不可以传入 PetContainer
// 假如 PetContainer[P <: Animal] 这样定义，下面的初始化是可以的。
val lionContainer = new PetContainer[Lion](new Lion) // 编译报错

什么是类型下界

类型下界是将类型声明为另一种类型的超类型。

• 声明类型下界：B >: A,表示类型参数 B 或抽象类型 B 是类型 A 的超类型。

// 这个程序不能编译，因为方法 prepend 中的参数 elem 是协变的 B 类型。 
// 这会出错，因为函数的参数类型是逆变的，而返回类型是协变的。
trait Node[+B] {
  def prepend(elem: B): Node[B]
}

case class ListNode[+B](h: B, t: Node[B]) extends Node[B] {
  def prepend(elem: B): ListNode[B] = ListNode(elem, this)
  def head: B = h
  def tail: Node[B] = t
}

case class Nil[+B]() extends Node[B] {
  def prepend(elem: B): ListNode[B] = ListNode(elem, this)
}

// 我们需要将方法 prepend 的参数 elem 的型变翻转。 
// 我们通过引入一个新的类型参数 U 来实现这一点，该参数具有 B 作为类型下界
trait Node[+B] {
  def prepend[U >: B](elem: U): Node[U]
}

case class ListNode[+B](h: B, t: Node[B]) extends Node[B] {
  def prepend[U >: B](elem: U): ListNode[U] = ListNode(elem, this)
  def head: B = h
  def tail: Node[B] = t
}

case class Nil[+B]() extends Node[B] {
  def prepend[U >: B](elem: U): ListNode[U] = ListNode(elem, this)
}

trait Bird
case class AfricanSwallow() extends Bird
case class EuropeanSwallow() extends Bird

val africanSwallowList= ListNode[AfricanSwallow](AfricanSwallow(), Nil())
// 可以为 Node[Bird] 赋值 africanSwallowList，然后再加入一个 EuropeanSwallow。
val birdList: Node[Bird] = africanSwallowList
birdList.prepend(EuropeanSwallow())