自学内容网 自学内容网

【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方法允许你将一个类的实例解构为它的各个组件

原文地址:https://blog.csdn.net/kissdragan/article/details/142300144

免责声明:本站文章内容转载自网络资源,如本站内容侵犯了原著者的合法权益,可联系本站删除。更多内容请关注自学内容网(zxcms.com)!