泛型

1. 概述

泛型（Generics）是编程语言中的一种强大特性，允许你编写可以处理多种数据类型的代码，而不需要为每种数据类型编写单独的实现。在Scala中，泛型被广泛用于集合、函数和类的设计中，使得代码更加灵活和可重用。

2. 为什么需要泛型？

在编程中，我们经常需要处理不同类型的数据。例如，你可能需要编写一个函数来处理整数、字符串或其他类型的数据。如果没有泛型，你可能需要为每种数据类型编写单独的函数或类，这会导致代码冗余和维护困难。

泛型允许你编写一个通用的函数或类，它可以处理多种数据类型，从而减少代码重复并提高代码的可重用性。

3. 泛型的基本语法

在Scala中，泛型通过在类、函数或方法的定义中使用类型参数来实现。类型参数通常用大写字母表示，例如T、U等。

3.1 泛型类

你可以定义一个泛型类，使其能够处理多种类型的数据。例如，定义一个简单的Box类，它可以存储任何类型的值：

class Box[T](var value: T) {
  def getValue: T = value
  def setValue(newValue: T): Unit = {
    value = newValue
  }
}

在这个例子中，Box类有一个类型参数T，表示它可以存储任何类型的值。你可以创建不同类型的Box实例：

val intBox = new Box[Int](10)
val stringBox = new Box[String]("Hello")

println(intBox.getValue) // 输出: 10
println(stringBox.getValue) // 输出: Hello

3.2 泛型函数

你也可以定义泛型函数，使其能够处理多种类型的参数。例如，定义一个函数来交换两个变量的值：

def swap[T](a: T, b: T): (T, T) = (b, a)

val swapped = swap(10, 20)
println(swapped) // 输出: (20, 10)

val swappedStrings = swap("Hello", "World")
println(swappedStrings) // 输出: (World, Hello)

在这个例子中，swap函数有一个类型参数T，表示它可以交换任何类型的值。

4. 类型约束

有时，你可能希望对泛型类型参数进行约束，使其只能接受某些特定的类型。Scala提供了几种类型约束的方式。

4.1 上界约束

你可以使用上界约束（Upper Bound）来限制类型参数必须是某个类的子类。例如，定义一个函数来比较两个对象：

def compare[T <: Comparable[T]](a: T, b: T): Int = {
  a.compareTo(b)
}

val result = compare("Hello", "World")
println(result) // 输出: -15

在这个例子中，T <: Comparable[T]表示T必须是Comparable的子类，因此你可以调用compareTo方法。

4.2 下界约束

下界约束（Lower Bound）允许你指定类型参数必须是某个类的父类。这在处理协变（Covariance）时非常有用。例如：

class Animal
class Dog extends Animal

def printAnimal[T >: Dog](animal: T): Unit = {
  println(animal)
}

printAnimal(new Dog) // 输出: Dog@<hashcode>
printAnimal(new Animal) // 输出: Animal@<hashcode>

在这个例子中，T >: Dog表示T必须是Dog的父类。

5. 协变和逆变

在Scala中，泛型类型可以是协变（Covariant）、逆变（Contravariant）或不变（Invariant）的。

5.1 协变

协变允许子类型替换父类型。你可以通过在类型参数前加上+符号来表示协变。例如：

class Box[+T](val value: T)

val animalBox: Box[Animal] = new Box[Dog](new Dog)

在这个例子中，Box[Dog]是Box[Animal]的子类型，因此可以赋值给Box[Animal]。

5.2 逆变

逆变允许父类型替换子类型。你可以通过在类型参数前加上-符号来表示逆变。例如：

class Box[-T]

val dogBox: Box[Dog] = new Box[Animal]

在这个例子中，Box[Animal]是Box[Dog]的子类型，因此可以赋值给Box[Dog]。

6. 实践练习

练习1：泛型栈

实现一个泛型栈（Stack）类，支持push、pop和isEmpty操作。

class Stack[T] {
  private var elements: List[T] = Nil

  def push(elem: T): Unit = {
    elements = elem :: elements
  }

  def pop(): Option[T] = elements match {
    case Nil => None
    case head :: tail =>
      elements = tail
      Some(head)
  }

  def isEmpty: Boolean = elements.isEmpty
}

val stack = new Stack[Int]
stack.push(10)
stack.push(20)
println(stack.pop()) // 输出: Some(20)
println(stack.pop()) // 输出: Some(10)
println(stack.isEmpty) // 输出: true

练习2：泛型排序

实现一个泛型函数sort，对一个列表进行排序。你可以使用scala.math.Ordering来实现。

import scala.math.Ordering

def sort[T](list: List[T])(implicit ord: Ordering[T]): List[T] = {
  list.sorted(ord)
}

val sortedInts = sort(List(3, 1, 2))
println(sortedInts) // 输出: List(1, 2, 3)

val sortedStrings = sort(List("banana", "apple", "cherry"))
println(sortedStrings) // 输出: List("apple", "banana", "cherry")

7. 总结

泛型是Scala中一个非常强大的特性，它允许你编写灵活且可重用的代码。通过使用泛型，你可以减少代码重复，提高代码的可维护性。理解泛型的基本语法、类型约束、协变和逆变是掌握Scala编程的关键。

在接下来的课程中，我们将继续探讨Scala中的其他高级特性，如高阶函数、闭包、Akka Actor模型等。希望你能通过这些练习和示例，更好地掌握泛型的使用。