[2]SpinalHDL教程——Scala簡單入門

第一個 Scala 程式

shell里面輸入

$ scala

scala> 1 + 1
res0: Int = 2

scala> println("Hello World!")
Hello World!

檔案形式

object HelloWorld {
   /* 這是我的第一個 Scala 程式
    * 以下程式將輸出'Hello World!'
    */
   def main(args: Array[String]) = {
      println("Hello, world!") // 輸出 Hello World
   }
}

接下來我們使用 scalac 命令編譯它：

$ scalac HelloWorld.scala 
$ ls
HelloWorld$.class    HelloWorld.scala
HelloWorld.class    

編譯后我們可以看到目錄下生成了 HelloWorld.class 檔案，該檔案可以在Java Virtual Machine (JVM)上運行，

編譯后，我們可以使用以下命令來執行程式：

$ scala HelloWorld
Hello, world!

基本語法

Scala是運行在jvm上面的一款語言，在語法和概念上難免和java會有相似之處，而java的語法和C語法一脈相承，所以有C基礎的話基本語法還是比較好上手的，

Scala有兩個設計理念：面向物件（OOP）和函式式編程（FP）

面向物件就導致Scala中萬物皆物件；函式式這個概念比較陌生，后續會單獨介紹，

1.變數

使用關鍵詞 "var" 宣告變數，使用關鍵詞 "val" 宣告常量，

宣告變數實體如下：

var myVar : String = "Foo"
var myVar : String = "Too"

Scala是一個靜態型別語言，但編譯器能自動推斷型別

所以上面能這么寫，效果一樣：

var myVar = "Foo"
var myVar = "Too"

2.資料型別

然而，我們說scala是一款萬物皆物件的語言，這些變數都是物件

這就類似于java中的封裝類（Scala的底層實作確實也是用的java的封裝類）

Scala 與 Java有著相同的資料型別，下表列出了 Scala 支持的資料型別：

上表中列出的資料型別都是物件，也就是說scala沒有java中的原生型別，在scala是可以對數字等基礎型別呼叫方法的，

（1）整數字面量、浮點字面量

略

（2）字串字面量

scala> '1'
res0: Char = 1

scala> "1"
res1: String = 1

scala> "\t"
res2: String = "        "

scala> """\t"""
res3: String = \t

字串插值，會對每個運算式求值，并且呼叫toString方法

scala> val a=2.1
a: Double = 2.1

scala> val s=s"Hi,${a+9}!"
s: String = Hi,11.1!

函式

方法定義

方法定義由一個 def 關鍵字開始，緊接著是可選的引數串列，一個冒號 : 和方法的回傳型別，一個等于號 = ，最后是方法的主體，

Scala 方法定義格式如下：

def functionName ([引數串列]) : [return type] = {
   function body
   return [expr]
}

• 以上代碼中 return type 可以是任意合法的 Scala 資料型別，引數串列中的引數可以使用逗號分隔，

題外話：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)

• 函式體最后一行的return推薦省略
• 等號”=“省略條件：回傳型別未顯式宣告，并且回傳型別為Unit，這個類似于 Java 的 void, 實體如下：

object Hello{
   def printMe( ){
      println("Hello, Scala!")
   }
}

方法呼叫

以下是呼叫方法的標準格式：

functionName( 引數串列 )

如果方法使用了實體的物件來呼叫，我們可以使用類似java的格式 (使用 . 號)：

[instance.]functionName( 引數串列 )

類和物件

類是物件的抽象，而物件是類的具體實體，類是抽象的，不占用記憶體，而物件是具體的，占用存盤空間，類是用于創建物件的藍圖，它是一個定義包括在特定型別的物件中的方法和變數的軟體模板，

class Point(xc: Int, yc: Int) {
   var x: Int = xc
   var y: Int = yc

   def move(dx: Int, dy: Int) {
      x = x + dx
      y = y + dy
      println ("x 的坐標點: " + x);
      println ("y 的坐標點: " + y);
   }
}

構造方法

1. 主構造方法

   在類內部非欄位、非方法的部分全部當作建構式，在類名后引數串列用于接收，

   可以看一個SpinalHDL生成verilog的寫法：

   object MyTopLevelVerilog extends App {
     Config.spinal.generateVerilog(MyTopLevel(4))
   }
   

   看到App定義：

   trait App extends DelayedInit {
   
     // ...
       
     @deprecatedOverriding("main should not be overridden", "2.11.0")
     def main(args: Array[String]) = {
       this._args = args
       for (proc <- initCode) proc()
       if (util.Properties.propIsSet("scala.time")) {
         val total = currentTime - executionStart
         Console.println("[total " + total + "ms]")
       }
     }
   }
   

2. 輔助建構式

   def this( ... )

   函式內第一句必須呼叫其他的構造方法this()

3. 私有主構造方法

   如例所示加上private，構造物件時就不能通過主構造方法創建物件，得用輔助構造方法或工廠方法（用于構造物件的方法）

   class Student private (name: String,n: Int)
   

類繼承

extends關鍵詞

class Child extends Parent{
    //...
}

工廠物件和工廠方法

如果定義一個專門用來構造某一個類的物件的方法，那么這種方法就被稱為“工廠方法”，包含這些工廠方法集合的單例物件，稱為“工廠物件”，通常，工廠方法會定義在伴生物件中，尤其是當一系列類存在繼承關系時，可以在基類的伴生物件中定義一系列對應的工廠方法，使用工廠方法的好處是可以不用直接使用new來實體化物件，改用方法呼叫，而且方法名可以是任意的，這樣對外隱藏了類的實作細節，

//students. scala
class Students(val name:String,var score:Int){
   def exam(s:Int)=score =s
   override def toString =name +"'s score is "+score +"."
}

object Students {
   def registerStu(name:String,score:Int)=new Students(name,score)
} //registerStu為工廠方法

用“ import Students._ ”匯入單例物件后,就能這樣使用：

scala>import Students._
scala>val stu =registerStu("Tim",100)
stu:Students =Tim's score is 100.

重寫方法

在函式前面加上關鍵詞override

重寫toString方法

class A {
    override def toString = "123456A"
}
val a = new A()
println(a)

scala> class A {
     |     override def toString = "123456A"
     | }
// defined class A

scala> val a = new A()
val a: A = 123456A

scala> println(a)
123456A

Scala 單例物件

在 Scala 中，是沒有 static 這個東西的，但是它也為我們提供了單例模式的實作方法，那就是使用關鍵字 object，

Scala 中使用單例模式時，除了定義的類之外，還要定義一個同名的 object 物件，它和類的區別是，object物件不能帶引數，

當單例物件與某個類共享同一個名稱時，他被稱作是這個類的伴生物件：companion object，你必須在同一個源檔案里定義類和它的伴生物件，類被稱為是這個單例物件的伴生類：companion class，類和它的伴生物件可以互相訪問其私有成員，

class Point(val xc: Int, val yc: Int) {
   var x: Int = xc
   var y: Int = yc
   def move(dx: Int, dy: Int) {
      x = x + dx
      y = y + dy
   }
}

object Test {
   def main(args: Array[String]) {
      val point = new Point(10, 20)
      printPoint

      def printPoint{
         println ("x 的坐標點 : " + point.x);
         println ("y 的坐標點 : " + point.y);
      }
   }
}

執行以上代碼，輸出結果為：

$ scalac Test.scala 
$ scala Test
x 的坐標點 : 10
y 的坐標點 : 20

伴生物件

// 私有構造方法
class Marker private(val color:String) {

  println("創建" + this)
 
  override def toString(): String = "顏色標記："+ color
 
}

// 伴生物件，與類名字相同，可以訪問類的私有屬性和方法
object Marker{
 
    private val markers: Map[String, Marker] = Map(
      "red" -> new Marker("red"),
      "blue" -> new Marker("blue"),
      "green" -> new Marker("green")
    )
   
    def apply(color:String) = {
      if(markers.contains(color)) markers(color) else null
    }
 
   
    def getMarker(color:String) = {
      if(markers.contains(color)) markers(color) else null
    }
    def main(args: Array[String]) {
        println(Marker("red"))  
        // 單例函式呼叫，省略了.(點)符號  
                println(Marker getMarker "blue")  
    }
}

運算子即方法

1. 前綴運算子

   只有+、-、_{、!有，對應的方法名是unary_+、unary_-、unary_}、unary_!

   2.中綴和后綴運算子

? 以冒號結尾的運算子，右運算子是呼叫物件

標籤：其他

上一篇：理解函式指標和回呼函式

下一篇：Java的值傳遞和參考傳遞