1. 概述

1.1 Scala 和 Java 關(guān)系

1.2 scala特點

??Scala是一門以Java虛擬機（JVM）為運行環(huán)境并將面向?qū)ο蠛秃瘮?shù)式編程的最佳特性結(jié)合在一起的靜態(tài)類型編程語言（靜態(tài)語言需要提前編譯的如：Java、c、c++等，動態(tài)語言如：js）。

1. Scala是一門多范式的編程語言，Scala支持面向?qū)ο蠛秃瘮?shù)式編程。（多范式，就是多種編程方法的意思。有面向過程、面向?qū)ο?、泛型、函?shù)式四種程序設(shè)計方法。）
2. Scala源代碼（.scala）會被編譯成Java字節(jié)碼（.class），然后運行于JVM之上，并可以調(diào)用現(xiàn)有的Java類庫，實現(xiàn)兩種語言的無縫對接。
3. Scala單作為一門語言來看，非常的簡潔高效。
4. Scala在設(shè)計時，馬丁·奧德斯基是參考了Java的設(shè)計思想，可以說Scala是源于Java，同時馬丁·奧
   德斯基也加入了自己的思想，將函數(shù)式編程語言的特點融合到JAVA中。

1.3 scala安裝

1. 首先確保 JDK1.8 安裝成功
2. 下載對應(yīng)的 Scala 安裝文件https://www.scala-lang.org/
3. 解壓 scala-2.12.11.zip
4. 配置 Scala 的環(huán)境變量
   
   
   注意 1：解壓路徑不能有任何中文路徑，最好不要有空格。
   注意 2：環(huán)境變量要大寫 SCALA_HOME

2. 變量和數(shù)據(jù)類型

2.1 變量和常量

2.1.1 語法

var 變量名 [: 變量類型] = 初始值 var i:Int = 10
val 常量名 [: 常量類型] = 初始值 val j:Int = 20

注意：能用常量的地方不用變量

2.1.2 說明

1. 聲明變量時，類型可以省略，編譯器自動推導(dǎo)，即類型推導(dǎo)
2. 類型確定后，就不能修改，說明 Scala 是強數(shù)據(jù)類型語言。
3. 變量聲明時，必須要有初始值
4. 在聲明/定義一個變量時，可以使用 var 或者 val 來修飾，var 修飾的變量可改變，val 修飾的變量不可改。

2.1.3 案例

object TestVar {def main(args: Array[String]): Unit = {//（1）聲明變量時，類型可以省略，編譯器自動推導(dǎo)，即類型推導(dǎo)var age = 18age = 30//（2）類型確定后，就不能修改，說明 Scala 是強數(shù)據(jù)類型語言。// age = "tom" // 錯誤//（3）變量聲明時，必須要有初始值// var name //錯誤//（4）在聲明/定義一個變量時，可以使用 var 或者 val 來修飾，var 修飾 的變量可改變 ,val 修飾的變量不可改var num1 = 10 // 可變val num2 = 20 // 不可變num1 = 30 // 正確//num2 = 100 //錯誤，因為 num2 是 val 修飾的// p1 是 var 修飾的，p1 的屬性可以變，而且 p1 本身也可以變var p1 = new Person()p1.name = "dalang"p1 = null// p2 是 val 修飾的，那么 p2 本身就不可變（即 p2 的內(nèi)存地址不能變）， 但是 ，p2 的屬性是可以變 ，因為屬性并沒有用 val 修飾 。val p2 = new Person()p2.name = "jinlian"// p2 = null // 錯誤的，因為 p2 是 val 修飾的}
}class Person {var name: String = "jinlian"}

2.2 標(biāo)識符的命名規(guī)范

1. 以字母或者下劃線開頭，后接字母、數(shù)字、下劃線
2. 以操作符開頭，且只包含操作符（+ - * / # !等）
3. 用反引號…包括的任意字符串，即使是 Scala 關(guān)鍵字（39 個）也可以
4. package, import, class, object, trait, extends, with, type, for
   ? private, protected, abstract, sealed, final, implicit, lazy, override
   ? try, catch, finally, throw
   ? if, else, match, case, do, while, for, return, yield
   ? def, val, var
   ? this, super
   ? new
   ? true, false, null

2.3 字符串輸出

2.3.1 基本語法

1. 字符串，通過+號連接
2. printf 用法：字符串，通過%傳值。
3. 字符串模板（插值字符串）：通過$獲取變量值

2.3.2 案例

object TestCharType {def main(args: Array[String]): Unit = {var name: String = "jingling"var age: Int = 123;//（1）字符串，通過+號連接println(name + " " + age)//（2）printf 用法字符串，通過%傳值。printf("name=%s age=%d\n", name, age)//（3）字符串，通過$引用//多行字符串，在 Scala中，利用三個雙引號包圍多行字符串就可以實現(xiàn)。//輸入的內(nèi)容，帶有空格、\t 之類，導(dǎo)致每一行的開始位置不能整潔對齊。//應(yīng)用 scala 的 stripMargin 方法，在 scala 中 stripMargin 默認(rèn) 是“|”作為連接符， //在多行換行的行頭前面加一個“|”符號即可。val s ="""| select| name,| age| from user|where name="zhangsan"""".stripMarginprintln(s)println("--------------------------------")//如果需要對變量進行運算，那么可以加${}val s1 =s"""|select| name,| age|from user|where name="$name" and age=${age + 2}""".stripMarginprintln(s1)println("--------------------------------")val s2 = s"name=$name"println(s2)println("--------------------------------")}}

2.5 鍵盤輸入

2.5.1 語法

//Read a full line from the default input. Returns null if the end of the input stream has been reached.
StdIn.readLine()
//Reads a short value from an entire line of the default input.
StdIn.readShort()
//Reads a double value from an entire line of the default input.
StdIn.readDouble()

2.5.2 案例

object TestInput {def main(args: Array[String]): Unit = {// 1 輸入姓名println("input name:")var name = StdIn.readLine()// 2 輸入年齡println("input age:")var age = StdIn.readShort()// 3 輸入薪水println("input sal:")var sal = StdIn.readDouble()// 4 打印println("name=" + name)println("age=" + age)println("sal=" + sal)}
}

2.6 數(shù)據(jù)類型

2.6.1 概述

1. Scala中一切數(shù)據(jù)都是對象，都是Any的子類。
2. Scala中數(shù)據(jù)類型分為兩大類：數(shù)值類型（AnyVal）、引用類型（AnyRef），不管是值類型還是引用類型都是對象。
3. Scala數(shù)據(jù)類型仍然遵守，低精度的值類型向高精度值類型，自動轉(zhuǎn)換（隱式轉(zhuǎn)換）
4. Scala中的StringOps是對Java中的String增強
5. Unit：對應(yīng)Java中的void，用于方法返回值的位置，表示方法沒有返回值。Unit是 一個數(shù)據(jù)類型，只有一個對象就是()。Void不是數(shù)據(jù)類型，只是一個關(guān)鍵字
6. Null是一個類型，只有一個對象就是null。它是所有引用類型（AnyRef）的子類。
7. Nothing，是所有數(shù)據(jù)類型的子類，主要用在一個函數(shù)沒有明確返回值時使用，因為這樣我們可以把拋出的返回值，返回給任何的變量或者函數(shù)。
8. Scala中一切都是對象，都是Any的子類，10 和new User() 意義一樣

2.6.2 整數(shù)類型（Byte、Short、Int、Long）

1. Scala 各整數(shù)類型有固定的表示范圍和字段長度，不受具體操作的影響，以保證 Scala 程序的可移植性。

// 正確
var n1: Byte = 127
var n2: Byte = -128
// 錯誤
// var n3:Byte = 128
// var n4:Byte = -129

2. Scala 的整型，默認(rèn)為 Int 型，聲明 Long 型，須后加‘l’或‘L

var n5 = 10
println(n5)
var n6 = 9223372036854775807L
println(n6)

3. Scala 程序中變量常聲明為 Int 型，除非不足以表示大數(shù)，才使用 Long

2.6.3 浮點類型（Float、Double）

// 建議，在開發(fā)中需要高精度小數(shù)時，請選擇 Double
var n7 = 2.2345678912f
var n8 = 2.2345678912
println("n7=" + n7)
println("n8=" + n8)

2.6.4 字符類型（char）

1. 字符類型可以表示單個字符，字符類型是 Char。
2. 字符常量是用單引號 ’ ’ 括起來的單個字符。
3. \t ：一個制表位，實現(xiàn)對齊的功能
4. \n ：換行符
5. \ ：表示\
6. " ：表示"

//（1）字符常量是用單引號 ' ' 括起來的單個字符。
var c1: Char = 'a'
println("c1=" + c1)
//注意：這里涉及自動類型提升，其實編譯器可以自定判斷是否超出范圍，
//不過 idea 提示報錯
var c2:Char = 'a' + 1
println("c2="+c2)
//（2）\t ：一個制表位，實現(xiàn)對齊的功能
println("姓名\t 年齡")
//（3）\n ：換行符
println("西門慶\n 潘金蓮")
//（4）\\ ：表示\
println("c:\\島國\\avi")
//（5）\" ：表示"
println("同學(xué)們都說：\"大海哥最帥\"")

2.6.5 布爾類型（Booleam）

1. 布爾類型也叫 Boolean 類型，Booolean 類型數(shù)據(jù)只允許取值 true 和 false
2. boolean 類型占 1 個字節(jié)。

var isResult : Boolean = false  
var isResult2 : Boolean = true

2.6.6 Unit類型、Null類型、Nothing類型

1. Unit 類型用來標(biāo)識過程，也就是沒有明確返回值的函數(shù)。由此可見，Unit 類似于 Java 里的 void。Unit 只有一個實例——( )，這個實例也沒有實質(zhì)意義

object TestSpecialType {def main(args: Array[String]): Unit = {val ok = sayOkprintln(ok)}def sayOk: Unit = { // unit 表示沒有返回值，即 void}
}

2. Null 類只有一個實例對象，Null 類似于 Java 中的 null 引用。Null 可以賦值給任 意引用類型（AnyRef），但是不能賦值給值類型（AnyVal）

object TestSpecialType {def main(args: Array[String]): Unit = {var cat = new Cat()println(cat)cat = nullprintln(cat)}
}
class Cat {
}

3. Nothing，可以作為沒有正常返回值的方法的返回類型，非常直觀的告訴你這個方 法不會正常返回，而且由于 Nothing 是其他任意類型的子類，他還能跟要求返回值的方法兼 容。

def test(): Nothing = {throw new Exception()
}
test

2.7 類型轉(zhuǎn)換

2.7.1 數(shù)值類型自動轉(zhuǎn)換

? 當(dāng) Scala 程序在進行賦值或者運算時，精度小的類型自動轉(zhuǎn)換為精度大的數(shù)值類型，這 個就是自動類型轉(zhuǎn)換（隱式轉(zhuǎn)換）。數(shù)據(jù)類型按

? 自動提升原則：有多種類型的數(shù)據(jù)混合運算時，系統(tǒng)首先自動將所有數(shù)據(jù)轉(zhuǎn)換成 精度大的那種數(shù)據(jù)類型，然后再進行計算。
? 把精度大的數(shù)值類型賦值給精度小的數(shù)值類型時，就會報錯，反之就會進行自動 類型轉(zhuǎn)換。
? （byte，short）和 char 之間不會相互自動轉(zhuǎn)換。
? byte，short，char 他們?nèi)呖梢杂嬎?#xff0c;在計算時首先轉(zhuǎn)換為 int 類型。

object TestValueTransfer {def main(args: Array[String]): Unit = {//（1）自動提升原則：有多種類型的數(shù)據(jù)混合運算時，系統(tǒng)首先自動將所有 數(shù)據(jù)轉(zhuǎn)換成精度大的那種數(shù)值類型 ，然后再進行計算 。var n = 1 + 2.0println(n) // n 就是 Double//（2）把精度大的數(shù)值類型賦值給精度小的數(shù)值類型時，就會報錯，反之就 會進行自動類型轉(zhuǎn)換var n2: Double = 1.0//var n3 : Int = n2 //錯誤，原因不能把高精度的數(shù)據(jù)直接賦值和低 精度//（3）（byte，short）和 char 之間不會相互自動轉(zhuǎn)換。var n4: Byte = 1//var c1 : Char = n4 //錯誤var n5: Int = n4//（4）byte，short，char 他們?nèi)呖梢杂嬎?#xff0c;在計算時首先轉(zhuǎn)換為 int 類var n6: Byte = 1var c2: Char = 1// var n : Short = n6 + c2 //當(dāng) n6 + c2 結(jié)果類型就是 int// var n7 : Short = 10 + 90 //錯誤}}

2.7.2 強制類型轉(zhuǎn)換

? 自動類型轉(zhuǎn)換的逆過程，將精度大的數(shù)值類型轉(zhuǎn)換為精度小的數(shù)值類型。使用時要加上 強制轉(zhuǎn)函數(shù)，但可能造成精度降低或溢出，格外要注意。
? 將數(shù)據(jù)由高精度轉(zhuǎn)換為低精度，就需要使用到強制轉(zhuǎn)換
? 強轉(zhuǎn)符號只針對于最近的操作數(shù)有效，往往會使用小括號提升優(yōu)先級

Java : int num = (int)2.5 
Scala : var num : Int = 2.7.toInt

object TestForceTransfer {def main(args: Array[String]): Unit = {//（1）將數(shù)據(jù)由高精度轉(zhuǎn)換為低精度，就需要使用到強制轉(zhuǎn)換var n1: Int = 2.5.toInt // 這個存在精度損失println("n1="+n1)//（2）強轉(zhuǎn)符號只針對于最近的操作數(shù)有效，往往會使用小括號提升優(yōu)先級var r1: Int = 10 * 3.5.toInt + 6 * 1.5.toInt // 10 *3 + 6*1 = 36var r2: Int = (10 * 3.5 + 6 * 1.5).toInt // 44.0.toInt =44println("r1=" + r1 + " r2=" + r2)}}

2.7.3 數(shù)值類型和String類型轉(zhuǎn)換

? 數(shù)值類型轉(zhuǎn) String 類型（語法：將基本類型的值+“” 即可）
? String 類型轉(zhuǎn)基本數(shù)值類型（語法：s1.toInt、s1.toFloat、s1.toDouble、s1.toByte、s1.toLong、s1.toShort）
? 在將 String 類型轉(zhuǎn)成基本數(shù)值類型時，要確保 String 類型能夠轉(zhuǎn)成有效的數(shù)據(jù)，比如我 們可以把"123"，轉(zhuǎn)成一個整數(shù)，但是不能把"hello"轉(zhuǎn)成一個整數(shù)。

object TestStringTransfer {def main(args: Array[String]): Unit = {//（1）基本類型轉(zhuǎn) String 類型（語法：將基本類型的值+"" 即可）var str1: String = true + ""var str2: String = 4.5 + ""var str3: String = 100 + ""//（2）String 類型轉(zhuǎn)基本數(shù)值類型（語法：調(diào)用相關(guān) API）var s1: String = "12"var n1: Byte = s1.toBytevar n2: Short = s1.toShortvar n3: Int = s1.toIntvar n4: Long = s1.toLong}
}

3. 運算符

3.1 算數(shù)運算符

? 對于除號“/”，它的整數(shù)除和小數(shù)除是有區(qū)別的：整數(shù)之間做除法時，只保留整數(shù)部分而舍棄小數(shù)部分。
? 對一個數(shù)取模 a%b，和 Java 的取模規(guī)則一樣。

object TestArithmetic {def main(args: Array[String]): Unit = {//（1）對于除號“/”，它的整數(shù)除和小數(shù)除是有區(qū)別的：整數(shù)之間做除法 時，只保留整數(shù)部分而舍棄小數(shù)部分。var r1: Int = 10 / 3 // 3println("r1=" + r1)var r2: Double = 10 / 3 // 3.0println("r2=" + r2)var r3: Double = 10.0 / 3 // 3.3333println("r3=" + r3)println("r3=" + r3.formatted("%.2f")) // 含義：保留小數(shù)點 2位，使用四舍五入//（2）對一個數(shù)取模 a%b，和 Java 的取模規(guī)則一樣。var r4 = 10 % 3 // 1println("r4=" + r4)}
}

3.2 關(guān)系運算符

object TestRelation {def main(args: Array[String]): Unit = {// 測試：>、>=、<=、<、==、!=var a: Int = 2var b: Int = 1println(a > b) // trueprintln(a >= b) // trueprintln(a <= b) // falseprintln(a < b) // falseprintln("a==b" + (a == b)) // falseprintln(a != b) // true}
}

3.3 賦值運算符

Scala 中沒有++、–操作符，可以通過+=、-=來實現(xiàn)同樣的效果

3.4 運算符本質(zhì)

在 Scala 中其實是沒有運算符的，所有運算符都是方法。
? 當(dāng)調(diào)用對象的方法時，點.可以省略
? 如果函數(shù)參數(shù)只有一個，或者沒有參數(shù)，()可以省略

object TestOpt {def main(args: Array[String]): Unit = {// 標(biāo)準(zhǔn)的加法運算val i: Int = 1.+(1)// （1）當(dāng)調(diào)用對象的方法時，.可以省略val j: Int = 1 + (1)// （2）如果函數(shù)參數(shù)只有一個，或者沒有參數(shù)，()可以省略val k: Int = 1 + 1println(1.toString())println(1 toString())println(1 toString)}
}