本篇文章仅简单介绍在spinalhdl编程中遇到的比较常见的2中类定义方式：class及case class。对于不太了解JAVA或Scala编码又开始学习SpinalHDL的人进行入门介绍。

在 SpinalHDL 中，case class 和 class 都是用来定义数据结构或对象的关键字，它们在某些方面相似，但也有一些显著的差异。

1.概念概述

1.1 相同点

• 都可以用来定义数据结构：case class 和 class 都可以用来创建自定义的数据类型。
• 都可以定义属性和函数：无论是 case class 还是 class 都可以包含属性和函数。

1.2 差异点

• 模式匹配：case class 通常用于模式匹配，它们自动为模式匹配生成unapply函数。而class则需要手动编写相应的匹配函数。
• 默认的equals和hashCode函数：case class 自动生成了 equals 和 hashCode 函数，这使得它们在比较对象时更方便。而对于 class，需要手动实现这些函数。
• 可变性：case class 中的属性默认是不可变的（immutable），而 class 中的属性可以是可变的（mutable）。
• 复制：case class 提供了 copy 函数，可以轻松地创建对象的副本并修改其中的属性，而 class 则需要手动编写相应的复制函数。
• 默认构造器参数：在 case class 中，构造函数的参数默认是 val，而在 class 中，默认是 var。

2.使用技巧

1. 选择合适的情境：根据需求选择合适的关键字。如果需要简单的数据传输对象或者模式匹配，可以使用 case class。如果需要更多的控制和灵活性，可以使用 class。
2. 利用模式匹配：在需要对对象进行模式匹配的场景下，选择使用 case class，这样可以更轻松地编写模式匹配代码。
3. 不可变性：在可能的情况下，推荐使用不可变的数据结构，因为它们更容易理解和维护，并且更安全。
4. 重载equals和hashCode函数：如果需要在 class 中实现自定义的对象比较逻辑，记得重载 equals 和 hashCode 函数。
5. 利用copy函数：如果需要在不修改原始对象的情况下创建对象的副本并进行修改，可以使用 case class 提供的 copy 函数。

3.case class独特函数

3.1 equals/hashCode函数

在 SpinalHDL 中，case class 自动生成的 equals 和 hashCode 函数遵循以下规则：

• equals 函数：自动生成的 equals 函数会比较两个对象的所有属性是否相等。
• hashCode 函数：自动生成的 hashCode 函数会基于对象的所有属性计算出一个哈希值。

这样设计的目的是为了确保当两个 case class 的对象具有相同的属性值时，它们的 equals 函数返回 true，并且它们的 hashCode 函数返回的哈希值也相同。

以下是一个详细的例子，假设我们有一个简单的 case class 表示一个二维点：

case class Point(x: Int, y: Int)

对于这个 Point 类，SpinalHDL 会自动生成 equals 和 hashCode 函数。下面是它们的实现：

override def equals(obj: Any): Boolean = obj match {
  case other: Point => this.x == other.x && this.y == other.y
  case _ => false
}

override def hashCode: Int = {
  val prime = 31
  var result = 1
  result = prime * result + x
  result = prime * result + y
  result
}

这里的 equals 函数比较了两个 Point 对象的 x 和 y 属性是否相等，而 hashCode 函数则基于 x 和 y 属性计算出一个哈希值。下面是一个示例演示如何使用这个 Point 类及其自动生成的 equals 和 hashCode 函数：

val point1 = Point(3, 4)
val point2 = Point(3, 4)
val point3 = Point(5, 6)

println(point1 == point2)  // 输出 true，因为 point1 和 point2 的属性值相等
println(point1 == point3)  // 输出 false，因为 point1 和 point3 的属性值不相等

val map = Map(point1 -> "A", point2 -> "B")
println(map(point1))  // 输出 "A"，因为 point1 和 point2 被视为相等的键
println(map(point2))  // 输出 "B"，因为 point1 和 point2 被视为相等的键
println(map(point3))  // 抛出 NoSuchElementException，因为 point3 不在 map 中

在这个示例中，我们创建了两个 Point 对象 point1 和 point2，它们的属性值相同，因此它们的 equals 函数返回 true。然后我们将这两个对象作为键存储在一个 Map 中，并成功地使用它们来检索相应的值。

3.2 copy 函数

在 SpinalHDL 中，case class 提供了一个 copy 函数，用于创建对象的副本并修改其中的属性。这个函数使得我们可以在不修改原始对象的情况下，方便地创建新的对象并修改其中的属性。
下面是 copy 函数的语法：

def copy(...): ThisType

其中，ThisType 是 case class 的类型。
以下是一个示例说明如何使用 case class 的 copy 函数：
假设我们有一个简单的 case class 表示一个二维点：

case class Point(x: Int, y: Int)

现在我们创建一个 Point 对象，然后我们使用 copy 函数创建一个新的 Point 对象，并修改其中的属性：

val originalPoint = Point(3, 4)
val modifiedPoint = originalPoint.copy(x = 5, y = 6)

在这个例子中，originalPoint.copy(x = 5, y = 6) 创建了一个新的 Point 对象，其 x 属性被修改为 5，y 属性被修改为 6。原始的 originalPoint 对象保持不变。
我们也可以只修改其中的部分属性，而不是全部属性。例如，我们可以只修改 x 属性，而保持 y 属性不变：

val modifiedX = originalPoint.copy(x = 10)

这个例子中，originalPoint.copy(x = 10) 创建了一个新的 Point 对象，其 x 属性被修改为 10，而 y 属性保持不变。
通过 copy 函数，我们可以方便地创建对象的副本并修改其中的属性，而不需要手动重复构造对象的其他部分。这使得代码更加简洁和易于维护。

4.使用场景

4.1  case class 场景

1.数据传输对象（DTO）：当需要表示简单的数据结构或数据传输对象时，通常使用 case class 更合适。例如，表示一个寄存器的配置参数或一个数据包的头部信息等。

case class RegisterConfig(address: Int, width: Int)

2.模式匹配：如果需要在模式匹配中使用对象，并且希望能够方便地提取对象的属性值，推荐使用 case class。因为它们自动生成了 unapply 函数，可以轻松地进行模式匹配。

val config = RegisterConfig(0x1000, 32)
config match {
  case RegisterConfig(addr, width) => println(s"Address: $addr, Width: $width")
  case _ => println("Unknown configuration")
}

3.不可变性：如果需要创建不可变的数据结构，即对象创建后不可修改其属性值，建议使用 case class。因为 case class 的属性默认是不可变的。

4.2  class 场景

1.需要可变性：如果需要创建可变的数据结构，即对象创建后可以修改其属性值，推荐使用 class。因为 class 的属性可以是可变的。

class Counter(var value: Int) {
  def increment(): Unit = value += 1
}

2.更多的控制和灵活性：如果需要更多的控制和灵活性，例如自定义 equals 和 hashCode 函数、手动实现复制函数等，建议使用 class。因为在 class 中这些行为需要手动实现，可以更灵活地控制。

class Person(name: String, age: Int) {
  // Custom equals method
  override def equals(obj: Any): Boolean = obj match {
    case other: Person => this.name == other.name && this.age == other.age
    case _ => false
  }
  // Custom hashCode method
  override def hashCode(): Int = {
    val prime = 31
    var result = 1
    result = prime * result + name.hashCode
    result = prime * result + age
    result
  }
  // Manual copy method
  def copy(name: String = this.name, age: Int = this.age): Person = new Person(name, age)
}

3.需要继承：如果需要创建可继承的类层次结构，即定义一个基类，并创建多个子类来扩展其功能，建议使用 class。因为 class 支持继承，可以更灵活地构建类的层次结构。

class Shape(var color: String) {
  def draw(): Unit = println(s"Drawing a $color shape")
}
class Circle(color: String, var radius: Double) extends Shape(color) {
  override def draw(): Unit = println(s"Drawing a $color circle with radius $radius")
}
val circle = new Circle("red", 5.0)

综上所述，根据具体的需求和场景选择合适的关键字是很重要的，这样可以使代码更加清晰、易于理解和维护。

5.类例化

5.1 case class 实例化

1.不需要使用 new 关键字：在实例化 case class 时，不需要使用 new 关键字。可以直接使用类名和参数列表来创建对象。

case class Point(x: Int, y: Int)
val point = Point(3, 4) // 实例化一个 Point 对象，无需使用 new 关键字

2.参数列表可以省略括号：如果 case class 的构造函数没有参数，可以省略括号。

case class EmptyClass()
val empty = EmptyClass  // 无需括号

3.自动生成的函数：case class 自动生成了一个伴生对象，并在其中定义了一个 apply及unapply函数，用于创建对象。这样使得可以直接使用类名和参数列表来创建对象，就像调用一个工厂函数一样。

5.2 class 实例化

1.需要使用 new 关键字：在实例化 class 时，需要使用 new 关键字。

class Point(var x: Int, var y: Int)
val point = new Point(3, 4)  // 使用 new 关键字实例化 Point 对象

2.参数列表不能省略括号：无论构造函数是否有参数，都需要使用括号来表示构造对象时传递的参数。

class EmptyClass()
val empty = new EmptyClass()  // 需要括号

3.没有自动生成的 apply 函数：class 没有自动生成的伴生对象和 apply 函数，因此无法像 case class 那样使用类名和参数列表来创建对象。
总的来说，case class 在实例化时更简洁和方便，而 class 则需要使用 new 关键字，并且不能像 case class 那样省略括号。

6. apply及unapply函数

6.1 unapply函数

unapply 函数是 case class 自动生成的一个伴生对象函数，用于在模式匹配中提取对象的属性值。它的主要作用是将对象的属性值提取出来，并将其作为元组返回。
例如，对于一个简单的 case class 定义：

case class Person(name: String, age: Int)

Person 类的伴生对象会自动生成一个 unapply 函数，其定义类似于：

object Person {
  def unapply(person: Person): Option[(String, Int)] = 
    Some(person.name, person.age)
}

在模式匹配中，可以使用 unapply 函数提取 Person 对象的属性值：

val person = Person("Alice", 30)
person match {
  case Person(name, age) => println(s"Name: $name, Age: $age")
  case _ => println("Unknown person")
}

在这个例子中，unapply 函数将 Person 对象的 name 和 age 属性值提取出来，并作为元组返回，然后在模式匹配中被成功地匹配。

6.2 apply函数

与 unapply 函数不同，apply 函数是用于创建对象的，而不是用于模式匹配。case class 会自动生成一个伴生对象，并在其中定义了一个 apply 函数，用于创建对象。

val person = Person.apply("Alice", 30) // 使用 apply 方法创建 Person 对象

因此，在 case class 中，apply 函数是用于创建对象的，而 unapply 函数是用于模式匹配的。