IT评测·应用市场-qidao123.com

标题: [2]SpinalHDL教程——Scala简单入门 [打印本页]
作者: 徐锦洪    时间: 2023-4-20 01:24
标题: [2]SpinalHDL教程——Scala简单入门
第一个 Scala 程序

shell里面输入
  1. $ scala
复制代码
  1. scala> 1 + 1
  2. res0: Int = 2
  4. scala> println("Hello World!")
  5. Hello World!
复制代码
文件形式
  1. object HelloWorld {
  2.    /* 这是我的第一个 Scala 程序
  3.     * 以下程序将输出'Hello World!'
  4.     */
  5.    def main(args: Array[String]) = {
  6.       println("Hello, world!") // 输出 Hello World
  7.    }
  8. }
复制代码
接下来我们使用 scalac 命令编译它：
  1. $ scalac HelloWorld.scala
  2. $ ls
  3. HelloWorld$.class    HelloWorld.scala
  4. HelloWorld.class   
复制代码
编译后我们可以看到目录下生成了 HelloWorld.class 文件，该文件可以在Java Virtual Machine (JVM)上运行。
编译后，我们可以使用以下命令来执行程序：
  1. $ scala HelloWorld
  2. Hello, world!
复制代码
基本语法

Scala是运行在jvm上面的一款语言，在语法和概念上难免和java会有相似之处，而java的语法和C语法一脉相承，所以有C基础的话基本语法还是比较好上手的。
Scala有两个设计理念：面向对象（OOP）和函数式编程（FP）
面向对象就导致Scala中万物皆对象；函数式这个概念比较陌生，后续会单独介绍。
1.变量

使用关键词 "var" 声明变量，使用关键词 "val" 声明常量。
声明变量实例如下：
  1. var myVar : String = "Foo"
  2. var myVar : String = "Too"
复制代码
Scala是一个静态类型语言，但编译器能自动推断类型
所以上面能这么写，效果一样：
  1. var myVar = "Foo"
  2. var myVar = "Too"
复制代码
2.数据类型

然而，我们说scala是一款万物皆对象的语言，这些变量都是对象
这就类似于java中的封装类（Scala的底层实现确实也是用的java的封装类）
Scala 与 Java有着相同的数据类型，下表列出了 Scala 支持的数据类型：
数据类型描述Byte8位有符号补码整数。数值区间为 -128 到 127Short16位有符号补码整数。数值区间为 -32768 到 32767Int32位有符号补码整数。数值区间为 -2147483648 到 2147483647Long64位有符号补码整数。数值区间为 -9223372036854775808 到 9223372036854775807Float32 位, IEEE 754 标准的单精度浮点数Double64 位 IEEE 754 标准的双精度浮点数Char16位无符号Unicode字符, 区间值为 U+0000 到 U+FFFFString字符序列Booleantrue或falseUnit表示无值，和其他语言中void等同。用作不返回任何结果的方法的结果类型。Unit只有一个实例值，写成()。Nullnull 或空引用NothingNothing类型在Scala的类层级的最底端；它是任何其他类型的子类型。AnyAny是所有其他类的超类AnyRefAnyRef类是Scala里所有引用类(reference class)的基类上表中列出的数据类型都是对象，也就是说scala没有java中的原生类型。在scala是可以对数字等基础类型调用方法的。
（1）整数字面量、浮点字面量

略
（2）字符串字面量
  1. scala> '1'
  2. res0: Char = 1
  4. scala> "1"
  5. res1: String = 1
  7. scala> "\t"
  8. res2: String = "        "
  10. scala> """\t"""
  11. res3: String = \t
复制代码
字符串插值，会对每个表达式求值，并且调用toString方法
  1. scala> val a=2.1
  2. a: Double = 2.1
  4. scala> val s=s"Hi,${a+9}!"
  5. s: String = Hi,11.1!
复制代码
函数

方法定义

方法定义由一个 def 关键字开始，紧接着是可选的参数列表，一个冒号 : 和方法的返回类型，一个等于号 = ，最后是方法的主体。
Scala 方法定义格式如下：
  1. def functionName ([参数列表]) : [return type] = {
  2.    function body
  3.    return [expr]
  4. }
复制代码
题外话：scala能使用元组进行打包，返回多个变量，在调用时解构赋值
scala> def useScala() = (1,2,3)
useScala: ()(Int, Int, Int)
scala> val a,b,c = useScala()
a: (Int, Int, Int) = (1,2,3)
b: (Int, Int, Int) = (1,2,3)
c: (Int, Int, Int) = (1,2,3)

  1. object Hello{
  2.    def printMe( ){
  3.       println("Hello, Scala!")
  4.    }
  5. }
复制代码
方法调用

以下是调用方法的标准格式：
  1. functionName( 参数列表 )
复制代码
如果方法使用了实例的对象来调用，我们可以使用类似java的格式 (使用 . 号)：
  1. [instance.]functionName( 参数列表 )
复制代码
类和对象

类是对象的抽象，而对象是类的具体实例。类是抽象的，不占用内存，而对象是具体的，占用存储空间。类是用于创建对象的蓝图，它是一个定义包括在特定类型的对象中的方法和变量的软件模板。
  1. class Point(xc: Int, yc: Int) {
  2.    var x: Int = xc
  3.    var y: Int = yc
  5.    def move(dx: Int, dy: Int) {
  6.       x = x + dx
  7.       y = y + dy
  8.       println ("x 的坐标点: " + x);
  9.       println ("y 的坐标点: " + y);
  10.    }
  11. }
复制代码
构造方法

<ol>主构造方法
在类内部非字段、非方法的部分全部当作构造函数，在类名后参数列表用于接收。
可以看一个SpinalHDL生成verilog的写法：
  1. object MyTopLevelVerilog extends App {
  2.   Config.spinal.generateVerilog(MyTopLevel(4))
  3. }
复制代码
看到App定义：
  1. trait App extends DelayedInit {
  3.   // ...
  4.    
  5.   @deprecatedOverriding("main should not be overridden", "2.11.0")
  6.   def main(args: Array[String]) = {
  7.     this._args = args
  8.     for (proc <- initCode) proc()
  9.     if (util.Properties.propIsSet("scala.time")) {
  10.       val total = currentTime - executionStart
  11.       Console.println("[total " + total + "ms]")
  12.     }
  13.   }
  14. }
复制代码
重写方法

在函数前面加上关键词override
重写toString方法
  1. class Student private (name: String,n: Int)
复制代码
  1. class Child extends Parent{
  2.     //...
  3. }
复制代码
Scala 单例对象

在 Scala 中，是没有 static 这个东西的，但是它也为我们提供了单例模式的实现方法，那就是使用关键字 object。
Scala 中使用单例模式时，除了定义的类之外，还要定义一个同名的 object 对象，它和类的区别是，object对象不能带参数。
当单例对象与某个类共享同一个名称时，他被称作是这个类的伴生对象：companion object。你必须在同一个源文件里定义类和它的伴生对象。类被称为是这个单例对象的伴生类：companion class。类和它的伴生对象可以互相访问其私有成员。
  1. //students. scala
  2. class Students(val name:String,var score:Int){
  3.    def exam(s:Int)=score =s
  4.    override def toString =name +"'s score is "+score +"."
  5. }
  7. object Students {
  8.    def registerStu(name:String,score:Int)=new Students(name,score)
  9. } //registerStu为工厂方法
复制代码
执行以上代码，输出结果为：
  1. scala>import Students._
  2. scala>val stu =registerStu("Tim",100)
  3. stu:Students =Tim's score is 100.
复制代码
伴生对象
  1. class A {
  2.     override def toString = "123456A"
  3. }
  4. val a = new A()
  5. println(a)
复制代码
操作符即方法

​        以冒号结尾的操作符，右操作符是调用对象

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！



欢迎光临 IT评测·应用市场-qidao123.com (https://dis.qidao123.com/) Powered by Discuz! X3.4