---

2.1 注釋

Scala 注釋使用和 Java 完全一樣。

注釋是一個程序員必須要具有的良好編程習(xí)慣。將自己的思想通過注釋先整理出來，再用代碼去體現(xiàn)。

1）基本語法
（1）單行注釋：//
（2）多行注釋：/* /
（3）文檔注釋：/*
*
*/
2）案例實操

package com.atguigu.chapter02
object TestNotes {def main(args: Array[String]): Unit = {//（1）單行注釋：//println("dalang")//（2）多行注釋：/* *//*println("dalang")println("jinlian")*///（3）文檔注釋：/**//*//*//*** println("qingge")println("qingge")println("qingge")*/}
}

3） 代碼規(guī)范
（1）使用一次 tab 操作，實現(xiàn)縮進(jìn)，默認(rèn)整體向右邊移動，用 shift+tab 整體向左移
（2）或者使用 ctrl + alt + L 來進(jìn)行格式化
（3）運算符兩邊習(xí)慣性各加一個空格。比如：2 + 4 * 5。
（4）一行最長不超過 80 個字符，超過的請使用換行展示，盡量保持格式優(yōu)雅

2.2 變量和常量（重點）

常量：在程序執(zhí)行的過程中，其值不會被改變的變量

0）回顧：Java 變量和常量語法

• 變量類型 變量名稱 = 初始值 int a = 10

• final 常量類型 常量名稱 = 初始值 final int b = 20

1）基本語法

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

注意：能用常量的地方不用變量
2）案例實操

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

package com.atguigu.chapter02
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 修飾的}
}

• （5）var 修飾的對象引用可以改變，val 修飾的對象則不可改變，但對象的狀態(tài)（值）卻是可以改變的。（比如：自定義對象、數(shù)組、集合等等）

object TestVar {def main(args: Array[String]): Unit = {// 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.3 標(biāo)識符的命名規(guī)范

??Scala 對各種變量、方法、函數(shù)等命名時使用的字符序列稱為標(biāo)識符。即：凡是自己可以起名字的地方都叫標(biāo)識符。

1）命名規(guī)則

Scala 中的標(biāo)識符聲明，基本和 Java 是一致的，但是細(xì)節(jié)上會有所變化，有以下三種規(guī)則：
（1）以字母或者下劃線開頭，后接字母、數(shù)字、下劃線
（2）以操作符開頭，且只包含操作符（+ - * / # !等）
（3）用反引號....包括的任意字符串，即使是 Scala 關(guān)鍵字（39 個）也可以
? 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）案例實操

需求：判斷 hello、Hello12、1hello、h-b、x h、h_4、ab、Int、、+-/#!、+-/#!1、if、if，這些名字是否合法。

object TestName {def main(args: Array[String]): Unit = {// （1）以字母或者下劃線開頭，后接字母、數(shù)字、下劃線var hello: String = "" // okvar Hello12: String = "" // okvar 1hello: String = "" // error 數(shù)字不能開頭var h-b: String = "" // error 不能用-var x h: String = "" // error 不能有空格var h_4: String = "" // okvar _ab: String = "" // okvar Int: String = "" // ok 因為在 Scala 中 Int 是預(yù)定義的字符,
不是關(guān)鍵字，但不推薦var _: String = "hello" // ok 單獨一個下劃線不可以作為標(biāo)識符，
因為_被認(rèn)為是一個方法println(_)//（2）以操作符開頭，且只包含操作符（+ - * / # !等）var +*-/#! : String = "" // okvar +*-/#!1 : String = "" // error 以操作符開頭，必須都是操作符//（3）用反引號`....`包括的任意字符串，即使是 Scala 關(guān)鍵字（39 個）
也可以var if : String = "" // error 不能用關(guān)鍵字var `if` : String = "" // ok 用反引號`....`包括的任意字符串,
包括關(guān)鍵字}
}

2.4 字符串輸出

1）基本語法

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

2）案例實操

package com.atguigu.chapter02
object TestCharType {def main(args: Array[String]): Unit = {var name: String = "jinlian"var age: Int = 18//（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"""".stripMargin
println(s)
//如果需要對變量進(jìn)行運算，那么可以加${}val s1 =s"""|select| name,| age|from user|where name="$name" and age=${age+2}""".stripMarginprintln(s1)val s2 = s"name=$name"println(s2)}
}

2.5 鍵盤輸入

在編程中，需要接收用戶輸入的數(shù)據(jù)，就可以使用鍵盤輸入語句來獲取。
1）基本語法
StdIn.readLine()、StdIn.readShort()、StdIn.readDouble()
2）案例實操
需求：可以從控制臺接收用戶信息，【姓名，年齡，薪水】。

import scala.io.StdIn
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ù)類型（重點）

回顧：Java數(shù)據(jù)類型

Java基本類型：char、byte、short、int、long、float、double、boolean
Java引用類型：（對象類型）由于Java有基本類型，而且基本類型不是真正意義的對象，即使后面產(chǎn)生了基本類型的包裝類，但是仍然存在基本數(shù)據(jù)類型，所以Java語言并不是真正意思的面向?qū)ο蟆?br /> 注意：Java中基本類型和引用類型沒有共同的祖先。
Java基本類型的包裝類：Character、Byte、Short、Integer、Long、Float、Double、Boolean

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

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

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

??Scala 的整數(shù)類型就是用于存放整數(shù)值的，比如 12，30，3456 等等。
1）整型分類

2）案例實操

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

object TestDataType {def main(args: Array[String]): Unit = {// 正確var n1:Byte = 127var n2:Byte = -128// 錯誤// var n3:Byte = 128// var n4:Byte = -129}
}

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

object TestDataType {def main(args: Array[String]): Unit = {var n5 = 10println(n5)var n6 = 9223372036854775807Lprintln(n6)}
}

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

2.8 浮點類型（Float、Double）

??Scala 的浮點類型可以表示一個小數(shù)，比如 123.4f，7.8，0.12 等等。
1）浮點型分類

2）案例實操
??Scala 的浮點型常量默認(rèn)為 Double 型，聲明 Float 型常量，須后加‘f’或‘F’。

object TestDataType {def main(args: Array[String]): Unit = {// 建議，在開發(fā)中需要高精度小數(shù)時，請選擇 Doublevar n7 = 2.2345678912fvar n8 = 2.2345678912println("n7=" + n7)println("n8=" + n8)}
}

//運行的結(jié)果

n7=2.2345679
n8=2.2345678912

2.9 字符類型（Char）

1）基本說明

• 字符類型可以表示單個字符，字符類型是 Char。

2）案例實操

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

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

2.10 布爾類型：Boolean

1）基本說明

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

2）案例實操

object TestBooleanType {def main(args: Array[String]): Unit = {var isResult : Boolean = falsevar isResult2 : Boolean = true}
}

2.11 Unit 類型、Null 類型和 Nothing 類型（重點）

1）基本說明

2）案例實操

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

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

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

object TestDataType {def main(args: Array[String]): Unit = {//null 可以賦值給任意引用類型（AnyRef），但是不能賦值給值類型
（AnyVal）var cat = new Cat();cat = null // 正確var n1: Int = null // 錯誤println("n1:" + n1)}
}
class Cat {
}

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

object TestSpecialType {def main(args: Array[String]): Unit = {def test() : Nothing={throw new Exception()}test}
}

2.12 類型轉(zhuǎn)換

擴展 Java 面試題（隱式類型轉(zhuǎn)換）

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

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

1）基本說明

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

object TestValueTransfer {def main(args: Array[String]): Unit = {//（1）自動提升原則：有多種類型的數(shù)據(jù)混合運算時，系統(tǒng)首先自動將所有
數(shù)據(jù)轉(zhuǎn)換成精度大的那種數(shù)值類型，然后再進(jìn)行計算。var n = 1 + 2.0println(n) // n 就是 Double//（2）把精度大的數(shù)值類型賦值給精度小的數(shù)值類型時，就會報錯，反之就
會進(jìn)行自動類型轉(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 //錯誤}
}

注意：Scala 還提供了非常強大的隱式轉(zhuǎn)換機制（隱式函數(shù)，隱式類等），我們放在高 級部分專門用一個章節(jié)來講解。

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

1）基本說明

自動類型轉(zhuǎn)換的逆過程，將精度大的數(shù)值類型轉(zhuǎn)換為精度小的數(shù)值類型。使用時要加上強制轉(zhuǎn)函數(shù)，但可能造成精度降低或溢出，格外要注意。

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

2）案例實操

• （1）將數(shù)據(jù)由高精度轉(zhuǎn)換為低精度，就需要使用到強制轉(zhuǎn)換
• （2）強轉(zhuǎn)符號只針對于最近的操作數(shù)有效，往往會使用小括號提升優(yōu)先級

object TestForceTransfer {def main(args: Array[String]): Unit = {//（1）將數(shù)據(jù)由高精度轉(zhuǎn)換為低精度，就需要使用到強制轉(zhuǎn)換var n1: Int = 2.5.toInt // 這個存在精度損失//（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.12.3 數(shù)值類型和 String 類型間轉(zhuǎn)換

1）基本說明

在程序開發(fā)中，我們經(jīng)常需要將基本數(shù)值類型轉(zhuǎn)成 String 類型?；蛘邔?String 類型轉(zhuǎn)成基本數(shù)值類型。

2）案例實操

• （1）基本類型轉(zhuǎn) String 類型（語法：將基本類型的值+“” 即可）
• （2）String 類型轉(zhuǎn)基本數(shù)值類型（語法：s1.toInt、s1.toFloat、s1.toDouble、s1.toByte、s1.toLong、s1.toShort）

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）注意事項

在將 String 類型轉(zhuǎn)成基本數(shù)值類型時，要確保 String 類型能夠轉(zhuǎn)成有效的數(shù)據(jù)，比如我們可以把"123"，轉(zhuǎn)成一個整數(shù)，但是不能把"hello"轉(zhuǎn)成一個整數(shù)。var n5:Int = “12.6”.toInt 會出現(xiàn) NumberFormatException 異常。

擴展面試題