第一個 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 支援的資料型別:
資料型別 | 描述 |
---|---|
Byte | 8位有符號補碼整數。數值區間為 -128 到 127 |
Short | 16位有符號補碼整數。數值區間為 -32768 到 32767 |
Int | 32位有符號補碼整數。數值區間為 -2147483648 到 2147483647 |
Long | 64位有符號補碼整數。數值區間為 -9223372036854775808 到 9223372036854775807 |
Float | 32 位, IEEE 754 標準的單精度浮點數 |
Double | 64 位 IEEE 754 標準的雙精度浮點數 |
Char | 16位無符號Unicode字元, 區間值為 U+0000 到 U+FFFF |
String | 字元序列 |
Boolean | true或false |
Unit | 表示無值,和其他語言中void等同。用作不返回任何結果的方法的結果型別。Unit只有一個例項值,寫成()。 |
Null | null 或空引用 |
Nothing | Nothing型別在Scala的類層級的最底端;它是任何其他型別的子型別。 |
Any | Any是所有其他類的超類 |
AnyRef | AnyRef類是Scala裡所有引用類(reference class)的基類 |
上表中列出的資料型別都是物件,也就是說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);
}
}
構造方法
-
主構造方法
在類內部非欄位、非方法的部分全部當作建構函式,在類名後引數列表用於接收。
可以看一個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]") } } }
-
輔助建構函式
def this( ... )
函式內第一句必須呼叫其他的構造方法this()
-
私有主構造方法
如例所示加上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")
}
}
運算子即方法
-
字首運算子
只有+、-、、!有,對應的方法名是unary_+、unary_-、unary_、unary_!
2.中綴和字尾運算子
以冒號結尾的運算子,右運算子是呼叫物件