数字硬件系统设计之一:Scala快速入门(2)

在Scala里,类是用关键字“class”来定义,一旦定义完成,就可以通过“new 类名”的方式来构造一个对象。而这个对象的类型,就是这个类。换句话说,一个类就是一个类型,不同的类就是不同的类型。在后续会讲到类的继承关系,以及超类、子类和子类型多态的概念。

在类里可以定义val或var类型的变量,它们被称为“字段”;还可以定义“def”函数,它们被称为“方法”;字段和方法统称“成员”。字段通常用于保存对象的状态或数据,而方法则用于承担对象的计算任务。字段也叫“实例变量”,因为每个被构造出来的对象都有其自己的字段。在运行时,操作系统会为每个对象分配一定的内存空间,用于保存对象的字段。方法则不同,对所有对象来说,方法都是一样的程序段,因此不需要为某个对象单独保存其方法。而且,方法的代码只有在被调用时才会被执行,如果一个对象在生命周期内都没有调用某些方法,那么完全没必要浪费内存为某个对象去保存这些无用的代码。

外部想要访问对象的成员时,可以使用句点符号“ . ”,通过“对象.成员”的形式来访问。此外,用new构造出来的对象可以赋给变量,让变量名成为该对象的一个指代名称。需要注意的是,val类型的变量只能与初始化时的对象绑定,不能再被赋予新的对象。一旦对象与变量绑定了,便可以通过“变量名.成员”的方式来多次访问对象的成员。例如:
scala> class Students {
| var name = “None”
| def register(n: String) = name = n
| }
defined class Students
scala> val stu = new Students
stu: Students = Students@1a2e563e

scala> stu.name
res0: String = None

scala> stu.register("test")
scala> stu.name
res2: String = test

 scala> stu = new Students
<console>:13: error: reassignment to val
       stu = new Students

Scala的类成员默认都是公有的,即可以通过“对象.成员”的方式来访问对象的成员,而且没有“public”这个关键字。如果不想某个成员被外部访问,则可以在前面加上关键字“private”来修饰,这样该成员只能被类内部的其他成员或上篇提到的伴生对象来访问,外部只能通过其他公有成员来间接访问。例如:
scala> class Students {
| private var name = “None”
| def register(n: String) = name = n
| def display() = println(name)
| }

defined class Students

scala> val stu = new Students
stu: Students = Students@75063bd0
scala> stu.register("test") 

scala> stu.name
<console>:13: error: variable name in class Students cannot be accessed in Students
       stu.name
          ^
 scala> stu.display
test

类的构造方法

1、主构造方法
在C++、Java、Python等面向对象语言里,类通常需要定义一个额外的构造方法(构造函数)。这样,要构造一个类的对象,除了需要关键字new,还需要调用构造方法。事实上,这个过程中有一些代码是完全重复的。Scala则不需要显式定义构造方法 ,而是把类内部的非字段、非方法的代码都当作“主构造方法”。而且,类名后面可以定义若干个参数列表,用于接收参数,这些参数将在构造对象时用于初始化字段并传递给主构造方法使用。Scala的这种独特语法减少了一些代码量。例如:
scala> class Students(n: String) {
| val name = n
| println(“A student named " + n + " has been registered.”)
| }

defined class Students

scala> val stu = new Students("Tom")
A student named Tom has been registered.
stu: Students = Students@5464eb28

在这个例子中,Students类接收一个String参数n,并用n来初始化字段name。这样做,就无需像之前那样把name定义成var类型,而是使用函数式风格的val类型,而且不再需要一个register方法在构造对象时来更新name的数据。

函数println既不是字段,也不是方法定义,"= n"也不是字段,也不是方法定义,所以都被当成是主构造函数的一部分。在构造对象时,主构造函数被执行,因此在解释器里会打印了相关信息。

2、辅助构造方法
除了主构造方法,scala还可以定义若干个辅助构造方法。辅助构造方法都是以“def this(…)”来开头的,而且第一步行为必须是调用该类的另一个构造方法,即第一条语句必须是“this(…)”——要么是主构造方法,要么是之前的另一个辅助构造方法。这种规则的结果就是任何构造方法最终都会调用该类的主构造方法(而主构造方法其实就是类定义本身),使得主构造方法成为类的单一入口。例如:

scala> class Students(n: String) {
    |val name = n
    |def this() = this("None") //辅助构造方法是无参数的,其内部调用主构造方法
    |println("A student named " + n + " has been registered.")
    |  }

defined class Students

scala> val stu = new Students
A student named None has been registered.
stu: Students = Students@64105ca4

在这个例子中,定义了一个辅助构造方法,该方法是无参的,其行为也仅是给主构造方法传递一个字符串“None”。

定义此辅助构造方法的作用:当创建该类的实例对象时,如果缺省了参数,这样与主构造方法的参数列表是不匹配的,但是与辅助构造方法匹配,则系统会使用stu的辅助构造方法构造该实例对象。

Scala只允许主构造方法调用超类的构造方法,不允许辅助构造函数调用超类的构造方法(后续具体讲解)。这种限制源于Scala为了代码简洁性与简单性做出的折衷处理。

3、无析构函数
因为Scala没有指针,同时使用了Java的垃圾回收器,所以不需要像C++那样定义析构函数。

4、私有主构造方法
如果在类名与类的参数列表之间加上关键字“private”,那么主构造方法就是私有的,只能被内部定义的辅助构造函数访问,外部代码实列化对象时就不能通过主构造方法进行,而必须使用其他公有的辅助构造方法或工厂方法(专门用于构造对象的方法)。例如:
scala> class Students private (n: String, m: Int) {
| val name = n
| val score = m
| def this(n: String) = this(n, 100)
| println(n + "'s score is " + m)
| }

defined class Students
scala> val stu = new Students("Bill", 90) //与私有的主构造方法匹配,访问错误
<console>:12: error: too many arguments (2) for constructor Students: (n: String)Students
       val stu = new Students("Bill", 90)

scala> val stu = new Students("Bill") //与辅助构造方法匹配
Bill's score is 100
stu: Students = Students@7509b8e7

方法重载
如果在类里定义了多个同名的方法,但是每个方法的参数(主要是参数类型)不一样,那么就称这个方法有多个不同的版本,即方法重载,它是面向对象里多态属性的一种表现。这些方法虽然同名,但是它们是不同的,因为函数真正的特征标识是它的参数,而不是函数名或返回类型。注意重载与前面的重写的区别,重载是一个类里有多个不同版本的同名方法,重写是子类覆盖已定义在超类(即父类)的某个方法。

类参数
从前面的例子可以发现,多数时候类的列表参数仅仅是直接赋给某个字段。Scala为了进一步简化代码,允许在类参数前加上val或var来修饰,这样就会在类的内部生成一个与参数同名的公有字段(此字段也是类的成员)。构造对象时,这些参数会直接复制给同名字段。除此之外,还可以加上关键字private、protected或override来表明字段的权限(关于权限修饰见后续章节)。如果参数没有任何val或var关键字,那它就仅仅是“参数”,不是类的成员,只能用来初始化字段或给方法使用,外部不能访问这样的参数,内部也不能修改它,因为它不是类的成员。例如:
scala> class ab(a:Int){ //a不是类的成员,仅仅是个传递参数
| val b=a+1
| }

defined class ab

scala> val c=new ab(8)
c: ab = ab@6e2d3f2

scala> c.b
res0: Int = 9

scala> c.a
^
error: value a is not a member of ab

以下在类参数定义时,加上val,则类参数同时变成了类成员:
scala> class ab(val a:Int){
| val b=a+1
| }
defined class ab

scala> val c=new ab(8)
c: ab = ab@ccd000e

scala> c.b
res2: Int = 9

scala> c.a
res3: Int = 8

单例对象与伴生对象

在Scala里,除了用new可以构造一个对象,也可以用“object”开头定义一个对象。它类似于类的定义,只不过不能像类那样有参数,也没有构造方法。因此,不能用new来实例化一个object的定义,因为它已经是一个对象了,对比class用new可以实例化无数个对象,而object只能定义一个对象,因此也把object定义的对象叫单列对象,如果对于单列对象object A 存在伴生类class A,则又把object A叫Class A的伴生对象,它们可以相互访问私有成员。概念虽多但是意思很明确

工厂对象与工厂方法

如果定义一个方法专门用来构造某一个类的对象,那么这种方法就称为“工厂方法”。包含这些工厂方法集合的单例对象,也就叫“工厂对象” 。通常,工厂方法会定义在伴生对象里。尤其是当一系列类存在继承关系时,可以在基类的伴生对象里定义一系列对应的工厂方法。使用工厂方法的好处是可以不用直接使用new来实例化对象,改用方法调用,而且方法名可以是任意的,这样对外隐藏了类的实现细节。例如:

class Students(val name: String, var score: Int) {
  def exam(s: Int) = score = s
  override def toString = name + "'s score is " + score + "."
  // 重写超类方法toString,注意关键字override 
}

object Students {

def registerStu(name: String, score: Int) = new Students(name, score)
}

将文件students.scala编译后,并在解释器里用“import Students.”导入单例对象后,就能这样使用:
scala> import Students.

import Students._
scala> val stu = registerStu(“Bill”, 60)
stu: Students = Bill’s score is 60.

apply方法

类和伴生对象有一个特殊的方法名:apply,如果定义了这个方法,那么既可以显式调用:“对象.apply(参数)” ,也可以隐式调用:“对象(参数)”。隐式调用时,编译器会自动插入缺失的“.apply”。如果apply是无参方法,应该写出空括号(这和普通方法不同),否则无法隐式调用。无论是类还是单例对象,都能定义这样的apply方法。

通常,在伴生对象里定义名为apply的工厂方法,就能通过“伴生对象名(参数)”来构造一个对象。也常常在类里定义一个与类相关的、具有特定行为的apply方法,让使用者可以隐式调用,进而隐藏相应的实现细节。例如:
class Students(val name: String, var score: Int) {
def apply(s: Int) = score = s
def display() = println("Current score is " + score + “.”)
override def toString = name + "'s score is " + score + “.”
}

object Students {
  def apply(name: String, score: Int) = new Students(name, score)
}

scala> val stu = Students("laozhang", 59) 
stu: Students = laozhang's score is 59.

//注意没有使用new Students(“laozhang”, 59),这是传统构造方法

scala> stu(60)
scala> stu.display
Current score is 60.

其中“Students(“laozhang”, 59)”被翻译成“Students.apply(“laozhang”, 59)”,也就是调用了伴生对象里的工厂方法,所以构造了一个Students的对象并赋给变量stu。“stu(60)”被翻译成“stu.apply(60)” ,也就是更新了字段score的数据。

主函数

主函数是Scala程序唯一的入口,即程序是从主函数开始运行的。要提供这样的入口,则必须在某个单例对象里定义一个名为“main”的函数,而且该函数只有一个参数,类型为字符串数组Array[String],函数的返回类型是Unit(即空类型,注意不是UInt类型哈)。任何符合条件的单例对象都能成为程序的入口。例如:
//在students.scala文件中定义
class Students(val name: String, var score: Int) {
def apply(s: Int) = score = s
def display() = println("Current score is " + score + “.”)
override def toString = name + "'s score is " + score + “.”
}

object Students {
  def apply(name: String, score: Int) = new Students(name, score)
}   

//在 main.scala文件中定义
object Start {
def main(args: Array[String]) = {
try {
val score = args(1).toInt
val s = Students(args(0), score)
println(s.toString)
} catch {

} } }

使用命令“scalac students.scala main.scala”将两个文件编译后,就能用命令“scala Start 参数1 参数2”来运行程序。命令里的“Start”就是包含主函数main的单例对象的名字,后面可以输入若干个用空格间隔的参数。这些参数被打包成字符串数组供主函数使用,也就是代码里的args(0)、args(1)。

主函数的另外一种写法是让单例对象继承“App”特质(特质的概念引入是因为scala不支持多重超类的继承,为实现多重超类继承的某些特性而引入了特质概念),这样就只需在单例对象里编写主函数的函数体,无需显式定义main方法。例如:
object Start extends App {
try {
var sum = 0
for(arg <- args) {
sum += arg.toInt
}
println("sum = " + sum)
} catch {

}
}

将文件编译后使用方法同前

关于class的知识,做为硬件设计语言chisel3/spinalHDL,这些已经够用了。

关注微信公众号: RiscV与IC设计
在这里插入图片描述

  • 0
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值