【SpinalHDL】Scala编程之伴生对象

Scala中的伴生对象是指和在同一个文件中声明的，并且和类同名的对象。例如，下面的代码保存在名为Pizza的文件中。在Scala中，这个object Pizza 对象被认为是class Pizza 类的伴生对象:

class Pizza {
}
object Pizza {
}

这样设计的优势是伴生对象及其类可以访问彼此的私有成员(字段和方法)，这意味着这个类中的printFilename 方法可以工作，因为它可以访问它的伴生对象中的HiddenFilename字段:

class SomeClass {
    def printFilename() = {
        println(SomeClass.HiddenFilename)
    }
}
object SomeClass {
    private val HiddenFilename = "/tmp/foo.bar"
}

伴生对象提供的功能远不止这些，我们将在本课剩下的内容中演示它的几个最重要的功能。

不使用关键字new创建新实例

在一些Spinalhdl示例中创建某些类的新实例时不必在类名之前使用关键字new，如下面的例子所示:

val zenMasters = List(
    Person("Nansen"),
    Person("Joshu")
)

这个功能来自于伴生对象的使用。当伴生对象中定义一个方法时，它对Scala编译器有特殊的意义。Scala内置了一些语法糖，可以让你输入这样的代码: apply

val p = Person("Fred Flinstone")

在编译过程中，编译器将该代码转换为以下代码:

val p = Person.apply("Fred Flinstone")

伴生对象中的apply 方法就像一个工厂方法，Scala的语法糖允许你使用上面的语法，不用关键字就能创建新new的类实例:

启用功

为了演示这个功能是如何工作的，下面是一个Person类名和它的伴生对象中的apply方法:

class Person {
    var name = ""
}
object Person {
    def apply(name: String): Person = {
        var p = new Person
        p.name = name
        p
    }
}

为了测试这段代码，可以使用下面的技巧将类和对象同时粘贴到Scala REPL中:

从命令行启动Scala REPL(使用如下命令)
scala 输入paste 并按[Enter]键 :
REPL的响应应该是这样的:

// Entering paste mode (ctrl-D to finish)
现在将类和对象同时粘贴到REPL中
按Ctrl-D完成"paste"过程
当这个过程正常运行时，你应该在REPL中看到如下输出:

defined class Person
defined object Person

REPL要求使用这种技术同时输入一个类和它的伴生对象。

现在可以像这样创建一个类的新实例: Person

val p = Person.apply("Fred Flinstone")

该代码直接调用伴生对象。更重要的是还可以像这样创建一个新实例: apply

val p = Person("Fred Flinstone")

更加便利使用此功能如下

val zenMasters = List(
    Person("Nansen"),
    Person("Joshu")
)

需要说明的是，在这个过程中发生的是:

输入 val p = Person("Fred")
Scala编译器会发现 new Person之前没有关键字
编译器会在类的伴生对象中查找与输入的类型签名匹配的方法 apply Person
如果找到方法就使用它 apply，如果没有会得到一个编译错误

创建多个构造函数

可以在一个伴生对象中创建多个方法来提供多个构造函数。下面的代码展示了如何创建一个和两个参数的构造函数。

class Person {
    var name: Option[String] = None
    var age: Option[Int] = None
    override def toString = s"$name, $age"
}
object Person {
    // a one-arg constructor
    def apply(name: Option[String]): Person = {
        var p = new Person
        p.name = name
        p
    }
    // a two-arg constructor
    def apply(name: Option[String], age: Option[Int]): Person = {
        var p = new Person
        p.name = name
        p.age = age
        p
    }
}

如果像之前那样将代码粘贴到REPL中，你会看到可以像下面这样创建新实例: Person

val p1 = Person(Some("Fred"))
val p2 = Person(None)
val p3 = Person(Some("Wilma"), Some(33))
val p4 = Person(Some("Wilma"), None)

打印这些值，会得到如下结果:

val p1: Person = Some(Fred), None
val p2: Person = None, None
val p3: Person = Some(Wilma), Some(33)
val p4: Person = Some(Wilma), None

运行这样的测试时最好清除REPL的内存 :reset:paste

添加unapply方法

就像在伴生对象中添加apply方法可以构造新的对象实例一样，添加unapply方法可以反构造对象实例。我们将用一个例子来演示:

下面是一个Person类及其伴生对象的不同版本:

class Person(var name: String, var age: Int)
object Person {
    def unapply(p: Person): String = s"${p.name}, ${p.age}"
}

注意伴生对象定义了一个unapply方法。这个方法接受Person类型为的输入参数，并返回String。要手动测试该unapply方法首先创建一个新Person实例:

val p = new Person("Lori", 29)

然后像这样unapply测试:

val result = Person.unapply(p)

这是REPL中的unapply结果:

scala> val result = Person.unapply(p)
result: String = Lori, 29

如上所示对给定的实例进行解构。

在Scala中把一个unapply方法放在伴生对象中时，我们就说你创建了一个提取器方法，因为你已经创建了一种从Person对象中提取字段的unapply方法:

unapply 返回不同类型

在上面例子中unapply返回String a，但也可以让它返回任何东西。下面的示例返回元组中的两个字段:

class Person(var name: String, var age: Int)
object Person {
    def unapply(p: Person): Tuple2[String, Int] = (p.name, p.age)
}

这个方法在REPL中如下所示:

scala> val result = Person.unapply(p)
result: (String, Int) = (Lori,29)

因为这个unapply方法以元组的形式返回类字段，所以你也可以这样做:

scala> val (name, age) = Person.unapply(p)
name: String = Lori
age: Int = 29

unapply 提取器

创建提取器的一个好处是，如果你遵循正确的Scala约定，它们会在匹配表达式中启用一种方便的模式匹配形式

要点

伴生对象是与A在同一个文件中声明的，并且与类 objectclass同名
伴生对象及其类可以访问彼此的私有成员
伴生对象的apply方法让你无需使用关键字 new就能创建类的新实例
伴生对象的unapply方法允许你将一个类的实例解构为它的各个组件