泉州网站模板建站,3000部末年禁止无需下载,湖南省博物馆网站建设,网站建设初学原想简单笼统介绍一下scala#xff0c;后感觉这么做意思不大#xff0c;网友看了和没看一样#xff0c;还是应该稍微详细具体一点#xff0c;故而把系列编号由(上)(中)(下)#xff0c;改为(上)(2)(3)(4)(5)....,(上)就是(1)吧#xff0c;以下内容部分节选于我们即将出版的… 原想简单笼统介绍一下scala后感觉这么做意思不大网友看了和没看一样还是应该稍微详细具体一点故而把系列编号由(上)(中)(下)改为(上)(2)(3)(4)(5)....,(上)就是(1)吧以下内容部分节选于我们即将出版的书稿本次推文介绍scala里的类用法在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 Students1a2e563e    scala stu.name    res0: String None    scala stu.register(Bob)    scala stu.name    res2: String Bob    scala stu new Students    :13: error: reassignment to val           stu new StudentsScala的类成员默认都是公有的即可以通过“对象.成员”的方式来访问对象的成员而且没有“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 Students75063bd0    scala stu.register(Bob)    scala stu.name    :13: error: variable name in class Students cannot be accessed in Students           stu.name              ^     scala stu.display    Bob类的构造方法   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 Students5464eb28在这个例子中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 Students64105ca4在这个例子中定义了一个辅助构造方法该方法是无参的其行为也仅是给主构造方法传递一个字符串“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) //与私有的主构造方法匹配访问错误    :12: error: too many arguments (2) for constructor Students: (n: String)Students           val stu new Students(Bill, 90)    scala val stu new Students(Bill) //与辅助构造方法匹配    Bills score is 100    stu: Students Students7509b8e7方法重载如果在类里定义了多个同名的方法但是每个方法的参数(主要是参数类型)不一样那么就称这个方法有多个不同的版本即方法重载它是面向对象里多态属性的一种表现。这些方法虽然同名但是它们是不同的因为函数真正的特征标识是它的参数而不是函数名或返回类型。注意重载与前面的重写的区别重载是一个类里有多个不同版本的同名方法重写是子类覆盖已定义在超类(即父类)的某个方法。类参数从前面的例子可以发现多数时候类的列表参数仅仅是直接赋给某个字段。Scala为了进一步简化代码允许在类参数前加上val或var来修饰这样就会在类的内部生成一个与参数同名的公有字段(此字段也是类的成员)。构造对象时这些参数会直接复制给同名字段。除此之外还可以加上关键字private、protected或override来表明字段的权限(关于权限修饰见后续章节)。如果参数没有任何val或var关键字那它就仅仅是“参数”不是类的成员只能用来初始化字段或给方法使用,外部不能访问这样的参数内部也不能修改它,因为它不是类的成员。例如scala class ab(a:Int){ //a不是类的成员仅仅是个传递参数     | val ba1     | }defined class abscala val cnew ab(8)c: ab ab6e2d3f2scala c.bres0: Int 9scala c.a         ^       error: value a is not a member of ab以下在类参数定义时加上val则类参数同时变成了类成员:scala class ab(val a:Int){     | val ba1     | }defined class abscala val cnew ab(8)c: ab abccd000escala c.bres2: Int 9scala c.ares3: 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(Tim, 100)    stu: Students Tims score is 100.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  laozhangs 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           sum arg.toInt        }        println(sum sum)      } catch {        ......      }    }  将文件编译后使用方法同前关于class的知识做为硬件设计语言chisel3/spinalHDL,这些已经够用了。照例结合spinalHDL给个小提示以下视频简单演示伯克利分校的教学用riscv32处理器其使用基于scala宿主语言的chisel3硬件设计语言编写更多信息请长期关注微信公众号RiscV与IC设计