第二章 變量2.1 變量是程式的基本組成機關2.2 Scala 變量的介紹2.2.1 概念2.2.2 Scala 變量使用的基本步驟2.3 Scala 變量的基本使用2.4 Scala 變量使用說明2.4.1 變量聲明基本文法2.4.2 注意事項2.5 Scala 程式中 +号 的使用2.6 Scala 資料類型2.6.1 scala 資料類型體系一覽圖2.6.2 scala 資料類型清單2.7 整數類型2.7.1 基本介紹2.7.2 整型的類型2.7.3 整型的使用細節2.8 浮點類型2.8.1 基本介紹2.8.2 浮點型的分類2.8.3 浮點型使用細節2.9 字元類型：Char2.9.1 基本介紹2.9.2 案例示範2.9.3 字元類型使用細節2.9.4 字元類型本質探讨2.10 布爾類型：Boolean2.11 Unit 類型、Null 類型和 Nothing 類型2.11.1 基本說明2.11.2 使用細節和注意事項2.12 值類型轉換2.12.1 值類型隐式轉換2.12.2 自動類型轉換細節說明2.12.3 進階隐式轉換和隐式函數2.12.4 強制類型轉換2.13 值類型轉換練習題2.14 值類型和 String 類型的轉換2.14.1 介紹2.14.2 基本資料類型轉 String 類型2.14.3 String 類型轉基本資料類型2.14.4 注意事項2.15 辨別符的命名規範2.15.1 辨別符概念2.15.2 辨別符的命名規則(要記住)2.15.3 辨別符舉例說明2.15.4 辨別符命名注意事項2.15.5 Scala 關鍵字2.16 作業01
第二章 變量
為什麼需要變量：一個程式就是一個世界，在 scala 中一切都是對象。而在 java 中不完全是！因為有基本資料類型。
2.1 變量是程式的基本組成機關
不論是使用哪種進階程式語言編寫程式，變量都是其程式的基本組成機關，比如:
package com.atguigu.chapter02
object ScalaFunDemo01 {
def main(args: Array[String]): Unit = {
val a: Int = 1 // 定義一個整型變量，取名 a，并賦初值1
val b: Int = 3 // 定義一個整型變量，取名 b，并賦初值3
b = 89 // 給變量 b 賦 89
println("a=" + a) // 輸出語句，把變量 a 的值輸出
println("b=" + b) // 把變量 b 的值輸出
}
}
2.2 Scala 變量的介紹
2.2.1 概念
變量相當于記憶體中一個資料存儲空間的表示，你可以把變量看做是一個房間的門牌号，通過門牌号我們可以找到房間，而通過變量名可以通路到變量(值)。
2.2.2 Scala 變量使用的基本步驟
1、聲明/定義變量 (scala 要求變量聲明時需要初始化)
2、使用
2.3 Scala 變量的基本使用
示例代碼：
package com.atguigu.chapter02.vars
/**
* @author chenmingjun
* 2019-03-23 9:53
*/
object VarDemo01 {
def main(args: Array[String]): Unit = {
var age: Int = 10
var sal: Double = 10.9
var name: String = "tom"
var isPass: Boolean = true
// 在 scala 中，小數預設為 Double，整數預設是 Int
var score: Float = 59.9f
println(s"${age} ${sal} ${name} ${isPass} ${score}")
}
}
輸出結果為：
10 10.9 tom true 59.9
注意
：現代的編譯器是動态的，會做逃逸分析。
即：一個資料空間的生命周期很長，且多個變量引用同一個資料空間，這樣的資料空間放在堆中。
如果一個資料空間隻是臨時用一下，生命周期短，我們往往會把它放在棧裡面。
2.4 Scala 變量使用說明
2.4.1 變量聲明基本文法
var|val 變量名[: 變量類型] = 變量值
2.4.2 注意事項
1、聲明變量時，類型可以省略（編譯器自動推導，即類型推導）。
2、類型确定後，就不能修改，說明 Scala 是強資料類型語言。
3、在聲明/定義一個變量時，可以使用 var 或者 val 來修飾， var 修飾的變量可改變，val 修飾的變量不可改。
4、val 修飾的變量在編譯後，等同于加上 final，通過反編譯看下底層代碼。
5、var 修飾的對象的引用可以改變，val 修飾的則不可以改變，但是對象的狀态（值）卻是可以改變的。
6、變量聲明時，需要初始值。
package com.atguigu.chapter02.vars
/**
* @author chenmingjun
* 2019-03-23 10:43
*/
object VarDemo02 {
def main(args: Array[String]): Unit = {
// 1、聲明變量時，類型可以省略（編譯器自動推導，即類型推導）
var num = 10 // 省略類型，這時 num 就是 Int
// 方式一：可以利用 idea 的提示來證明
// 方式二：使用 isInstanceOf[Int] 來判斷
println(num.isInstanceOf[Int])
// 2、類型确定後，就不能修改，說明 Scala 是強資料類型語言
// num = 2.5 // 錯誤
// 3、在聲明/定義一個變量時，可以使用 var 或者 val 來修飾， var 修飾的變量可改變，val 修飾的變量不可改。
var age =10
age = 30 // 正确
val num2 = 40
// num2 = 50 // 錯誤
// scala 設計者為什麼設計 var 和 val ？
// (1) 因為在實際程式設計中，我們更多的需求是擷取/建立一個對象後，讀取該對象的屬性或者是修改該對象的屬性值，但是我們很少去改變這個對象的本身（即記憶體位址值）。
// (2) 因為 val 沒有線程安全問題，是以效率較高。
// (3) 如果對象需要改變，則使用 var。
val dog = new Dog
// dog = new Dog // Reassignment to val
dog.age = 90 // ok
dog.name = "小呆萌" // ok
}
}
class Dog {
// 聲明一個 age 屬性，給了一個預設值
var age: Int = 0
// 聲明名字
var name: String = ""
}
通過反編譯看下底層代碼
package com.atguigu.chapter02.vars
/**
* @author chenmingjun
* 2019-03-23 11:10
*/
object VarDemo03 {
var name = "小呆萌"
val age = 2
def main(args: Array[String]): Unit = {
println("ok")
}
}
通過反編譯看下底層代碼：
public final class VarDemo03$
{
public static final MODULE$;
private String name;
private final int age;
static
{
new ();
}
public String name()
{
return this.name; }
public void name_$eq(String x$1) { this.name = x$1; }
public int age() { return this.age; }
public void main(String[] args) {
Predef..MODULE$.println("ok");
}
private VarDemo03$() { MODULE$ = this;
this.name = "小呆萌";
this.age = 2;
}
}
2.5 Scala 程式中 +号 的使用
1、當左右兩邊都是數值型時，則做加法運算。
2、當左右兩邊有一方為字元串，則做拼接運算。
2.6 Scala 資料類型
1、Scala 與 Java 有着相同的資料類型，
在 Scala 中資料類型都是對象
，也就是說 Scala 沒有 Java 中的原生類型
2、Scala 資料類型分為兩大類 AnyVal(值類型) 和 AnyRef(引用類型)， 注意：不管是 AnyVal 還是 AnyRef 都是對象。
3、相對于 Java 的
類型系統
，scala 要
複雜些
！也正是這複雜多變的類型系統才讓面向對象程式設計和函數式程式設計完美的融合在了一起。
package com.atguigu.chapter02.datatype
/**
* @author chenmingjun
* 2019-03-23 11:22
*/
object TypeDemo01 {
def main(args: Array[String]): Unit = {
var num1: Int = 10
// 因為Int 是一個類，是以它的一個執行個體裡面就有很多方法可以使用
println(num1.toDouble + "\t" + num1.toString + "\t" + 100.toDouble)
// 在 scala 中，如果一個方法沒有形參，則可以省略()
sayHi
sayHi()
var isPass = true
println(isPass.toString)
}
def sayHi(): Unit = {
println("say hi")
}
}
10.0 10 100.0
say hi
say hi
true
2.6.1 scala 資料類型體系一覽圖
對上圖的小結和整理
1、在 scala中有一個根類型，它是所有類的父類。
2、scala 中一切皆為對象，分為兩大類 AnyVal(值類型)和 AnyRef(引用類型)，它們都是 Any 的子類。
3、Null 類型是 scala 的特别類型，它隻有一個值 null，它是 bottom class，是所有 AnyRef 類型的子類。
4、Nothing 類型也是 bottom class，它是所有類型的子類。在開發中通常可以将 Nothing 類型的值傳回給任意變量或者函數，這裡在抛出異常使用很多。
package com.atguigu.chapter02.datatype
/**
* @author chenmingjun
* 2019-03-23 11:53
*/
object TypeDemo02 {
def main(args: Array[String]): Unit = {
println(sayHello)
}
// 比如在開發中，我們有一個方法，就會異常中斷，這時就可以傳回 Nothing
// 即當我們使用 Nothing 作為傳回值時，就是明确說明該方法沒有正常傳回值。
def sayHello: Nothing = {
throw new Exception("抛出異常")
}
}
Exception in thread "main" java.lang.Exception: 抛出異常
at com.atguigu.chapter02.datatype.TypeDemo02$.sayHello(TypeDemo02.scala:15)
at com.atguigu.chapter02.datatype.TypeDemo02$.main(TypeDemo02.scala:9)
at com.atguigu.chapter02.datatype.TypeDemo02.main(TypeDemo02.scala)
5、在 scala 中仍然遵守，低精度的值向高精度的值得自動轉換（implicit conversion:隐式轉換）
var num = 1.2 // 預設是 Double
var num2 = 1.7f // 這裡是 Float
// num2 = num // 錯誤
num2 = num.toFloat // 正确
2.6.2 scala 資料類型清單
2.7 整數類型
2.7.1 基本介紹
Scala 的整數類型就是用于存放整數值的，比如：12, 30, 3456 等等
2.7.2 整型的類型
2.7.3 整型的使用細節
1、Scala 各整數類型有固定的表數範圍和字段長度，不受具體作業系統的影響，以保證 Scala 程式的可移植性。
2、Scala 的整型
常量/字面量
預設為 Int 型，聲明 Long 型
常量/字面量
須後加“l”’或"L"。 【可以反編譯檢視】。
3、Scala 程式中變量常聲明為 Int 型，除非不足以表示大數，才使用 Long。
package com.atguigu.chapter02.datatype
/**
* @author chenmingjun
* 2019-03-23 12:47
*/
object TypeDemo03 {
def main(args: Array[String]): Unit = {
println("Long的範圍：" + Long.MaxValue + "~" + Long.MinValue)
var i = 10 // i Int
var j = 10l // j Long
var k = 10L // j Long
var m = 9223372036854775807L // 9223372036854775807 超過 Int
}
}
2.8 浮點類型
2.8.1 基本介紹
Scala 的浮點類型可以表示一個小數，比如 123.4f，7.8，0.12 等等
2.8.2 浮點型的分類
2.8.3 浮點型使用細節
1、與整數類型類似，Scala 浮點類型也有固定的表數範圍和字段長度，不受具體作業系統的影響。
2、Scala 的浮點型常量預設為 Double 型，聲明 Float 型常量，須後加“f”或"F"。
var f1: Float = 1.1 // Double->Float，錯誤
var f2 = 1.2 // ok 類型推斷
var f3: Double = 1.3 // ok
var f4: Float = 1.4f // ok
var f5: Double = 1.5f // Float->Double, ok，隐式轉換
3、浮點型常量有兩種表示形式
十進制數形式，如：5.12 512.0f .512 (必須有小數點）
科學計數法形式，如：5.12e2 = 5.12乘以10的2次方 5.12E-2 = 5.12除以10的2次方
4、通常情況下，應該使用 Double 型，因為它比 Float 型更精确(小數點後大緻7位)
// 測試資料：2.2345678912f, 2.2345678912
var num1: Float = 2.2345678912f
var num2: Double = 2.2345678912
println("num1=" + num1 + "\t" + "num2=" + num2)
// 輸出結果：num1=2.2345679 num2=2.2345678912
2.9 字元類型：Char
2.9.1 基本介紹
字元類型可以表示單個字元，字元類型是 Char， 16 位無符号 Unicode 字元(2個位元組), 區間值為 U+0000 到 U+FFFF
2.9.2 案例示範
package com.atguigu.chapter02.datatype
/**
* @author chenmingjun
* 2019-03-23 13:10
*/
object CharDemo04 {
def main(args: Array[String]): Unit = {
var char1: Char = 97
// 當我們輸出一個 char 類型時，它會輸出該數字對應的字元（Unicode 碼表） Unicode 碼表包含 ASCII 碼表
println("chart1=" + char1) // a
// Char 可以當做數字進行運算
var char2: Char = 'a'
var num = 10 + char2
println("num=" + num) // 107
// var c2: Char = 'a' + 1 // Int->Char 錯誤
// var c3: Char = 97 + 1 // Int->Char 錯誤
var c4: Char = 98 // 正确
var c5: Char = 65535 // 正确
// var c6: Char = 65536 // 錯誤
// 原因和分析
// 1、當把一個計算的結果指派給一個變量，則編譯器會進行類型轉換和判斷（即會看類型和範圍）。
// 2、當把一個字面量指派給一個變量，則編譯器隻會進行範圍的判定。
var c6 = '\n'//
println("c6=" + c6 + "hello")
}
}
2.9.3 字元類型使用細節
1、字元常量是用單引号 ('') 括起來的單個字元。例如：var c1 = 'a' var c2 = '中' var c3 = '9'
2、Scala 也允許使用轉義字元 '\' 來将其後的字元轉變為特殊字元型常量。例如：var c3 = '\n' // '\n' 表示換行符
3、可以直接給 Char 賦一個整數，然後輸出時，會按照對應的 Unicode 字元輸出 ['\u0061' 97]
4、Char 類型是可以進行運算的，相當于一個整數，因為它都對應有 Unicode碼。
2.9.4 字元類型本質探讨
-
字元型 存儲到 計算機中，需要将字元對應的碼值（整數）找出來
存儲：字元 -> 碼值 -> 二進制 -> 存儲
讀取：二進制 -> 碼值 -> 字元 -> 讀取
- 字元和碼值的對應關系是通過字元編碼表決定的(是規定好的)， 這一點和 Java 一樣。
var c7: Char = '中'
println("c7=" + c7 + "，c7對應的碼值=" + c7.toInt)
var c8: Char = '國'
println("c8=" + c8 + "，c8對應的碼值=" + c8.toInt)
c7=中，c7對應的碼值=20013
c8=國，c7對應的碼值=22269
2.10 布爾類型：Boolean
基本介紹
布爾類型也叫 Boolean 類型，Booolean 類型資料隻允許取值 true 和 false
Boolean 類型占 1 個位元組。
Boolean 類型适于邏輯運算，一般用于程式流程控制。如下：
- if 條件控制語句
- while 循環控制語句
- do-while 循環控制語句
- for 循環控制語句
2.11 Unit 類型、Null 類型和 Nothing 類型
2.11.1 基本說明
2.11.2 使用細節和注意事項
1、Null 類隻有一個執行個體對象，null，類似于 Java 中的 null 引用。null 可以指派給任意引用類型(AnyRef)，但是不能指派給值類型(AnyVal: 比如 Byte, Short, Int, Long, Float, Double, Char, Boolean)
2、Unit 類型用來辨別過程，也就是沒有明确傳回值的函數。由此可見，Unit 類似于 Java 裡的 void。Unit 隻有一個執行個體，()，這個執行個體也沒有實質的意義。
3、Nothing，可以作為沒有正常傳回值的方法的傳回類型，非常直覺的告訴你這個方法不會正常傳回，而且由于 Nothing 是其他任意類型的子類，它還能跟要求傳回值的方法相容。
package com.atguigu.chapter02.datatype
/**
* @author chenmingjun
* 2019-03-23 13:52
*/
object UnitNullNothingDemo05 {
def main(args: Array[String]): Unit = {
val result = sayHello()
println("result="+ result) // result=()
// Null 類隻有一個執行個體對象，null，類似于 Java 中的 null 引用。null 可以指派給任意引用類型(AnyRef)，但是不能指派給值類型(AnyVal: 比如 Byte, Short, Int, Long, Float, Double, Char, Boolean)
val dog: Dog = null
// var chart1: Char = null // 運作報錯
println("OK")
}
// Unit 類似于 Java 裡的 void。Unit 隻有一個執行個體，()，這個執行個體也沒有實質的意義。
def sayHello(): Unit = {
}
}
class Dog() {
}
result=()
OK
2.12 值類型轉換
2.12.1 值類型隐式轉換
介紹：
當 Scala 程式在進行指派或者運算時，精度小的類型自動轉換為精度大的資料類型，這個就是自動類型轉換=隐式轉換。
資料類型按精度(容量)大小排序為：
2.12.2 自動類型轉換細節說明
1、有多種類型的資料混合運算時，系統首先自動将目前所有資料轉換成容量最大的那種資料類型(
尖叫提示
：是參與運算的類型中容量最大的)，然後再進行計算。 5.6 + 10 -> Double
2、當我們把精度(容量)大的資料類型指派給精度(容量)小的資料類型時，就會報錯，反之就會進行自動類型轉換。
3、【Byte, Short】 和 Char之間不會互相自動轉換。
尖叫提示
：Byte 可以自動轉換為 Short。
4、Byte，Short，Char 他們三者可以計算，在計算時首先轉換為 Int 類型。
5、自動提升原則： 表達式結果的類型自動提升為操作數中最大的類型。
package com.atguigu.chapter02.dataConvert
/**
* @author chenmingjun
* 2019-03-23 15:59
*/
object ConvertDemo01 {
def main(args: Array[String]): Unit = {
var n1 = 10
var n2 = 1.1
// 1、有多種類型的資料混合運算時，系統首先自動将目前所有資料轉換成容量最大的那種資料類型，然後再進行計算。
var n3 = n1 + n2 // n3 是 Double，注意：當 var n2 = 1.1f 時，n3 是 Float
// 2、Byte, Short 和 Char之間不會互相自動轉換。
var n4: Byte = 10
// var n5: Char = n4 // 錯誤
}
}
2.12.3 進階隐式轉換和隐式函數
scala 還提供了非常強大的隐式轉換機制(隐式函數、隐式類等等)，我們放在進階部分專門用一個章節來講解。
2.12.4 強制類型轉換
自動類型轉換的逆過程，将容量大的資料類型轉換為容量小的資料類型。使用時要加上強制轉函數，但
可能造成精度降低或溢出
，格外要注意。
案例示範：
java : int num = (int) 2.5; // 文法糖
scala : var num: Int = 2.7.toInt // 對象
強制類型轉換細節說明：
1、當進行資料的 從大 —> 小，就需要使用到強制轉換。
2、
強轉符号隻針對于最近的操作數有效
，往往會使用小括号提升優先級。
3、Char 類型可以儲存 Int 類型的常量值，但不能儲存 Int 類型的變量值，非要儲存的話，需要強轉。
4、Byte 和 Short 類型在進行運算時，當做 Int 類型處理。
val num1: Int = 10 * 3.5.toInt + 6 * 1.5.toInt // 36
val num2: Int = (10 * 3.5 + 6 * 1.5).toInt // 44
println(num1 + " " + num2)
2.13 值類型轉換練習題
判斷是否能夠通過編譯，并說明原因
1） var s: Short = 5 // ok
s = s-2 // error，因為有運算，Int -> Short
2） var b: Byte = 3 // ok
b = b + 4 // error，因為有運算，Int -> Byte
b = (b+4).toByte // ok，使用強制轉換
3） var c: Char = 'a' // ok
var i: Int = 5 // ok
var d: Float = .314F //ok
var result: Double = c + i + d // ok，Float -> Double
4） var b: Byte = 5 // ok
var s: Short = 3 // ok
var t: Short = s + b // error，因為有運算，Int -> Short
var t2 = s + b // ok，使用了類型推導
2.14 值類型和 String 類型的轉換
2.14.1 介紹
在程式開發中，我們經常需要将基本資料類型轉成 String 類型。
或者将 String 類型轉成基本資料類型。
2.14.2 基本資料類型轉 String 類型
文法： 将基本類型的值+"" 即可
2.14.3 String 類型轉基本資料類型
文法：通過基本類型的 String 的 toXxx 方法即可
package com.atguigu.chapter02.dataConvert
/**
* @author chenmingjun
* 2019-03-23 16:37
*/
object String2Basic {
def main(args: Array[String]): Unit = {
val d1 = 1.2
// 基本資料類型轉 String 類型
val s1 = d1 + "" // 以後看到下劃線，就表示編譯器做了轉換
// String 類型轉 基本資料類型
val s2 = "12"
val num1 = s2.toInt
val num2 = s2.toByte
val num3 = s2.toDouble
val num4 = s2.toLong
}
}
2.14.4 注意事項
1、在将 String 類型轉成 基本資料類型時，要確定 String 類型能夠轉成有效的資料，比如我們可以把 "123"，轉成一個整數，但是不能把 "hello" 轉成一個整數。
2、思考就是要把 "12.5" 轉成 Int？
// 1、在将 String 類型轉成 基本資料類型時，要確定 String 類型能夠轉成有效的資料，比如我們可以把 "123"，轉成一個整數，但是不能把 "hello" 轉成一個整數。
var s3 = "hello"
println(s3.toInt) // 錯誤
// 2、思考就是要把 "12.5" 轉成 Int？
var s4 = "12.5"
println(s4.toInt) // 錯誤，Double -> Int，在 scala 中不能将小數點後面的資料進行截取，而是會抛出異常
println(s4.toDouble) // 正确
2.15 辨別符的命名規範
2.15.1 辨別符概念
Scala 對各種變量、方法、函數等命名時使用的字元序列稱為辨別符。
凡是自己可以起名字的地方都叫辨別符。
2.15.2 辨別符的命名規則(要記住)
1、Scala 中的辨別符聲明，基本和 Java 是一緻的，但是細節上會有所變化。
2、首字元為字母，後續字元任意字母和數字、美元符号，可後接下劃線_。
3、數字不可以開頭。
4、
首字元為操作符【比如 + - * /】，後續字元也需跟操作符，至少一個【反編譯檢視】
。
5、操作符【比如 + - * /】不能在辨別符中間和最後。
6、用反引号
....
包括的任意字元串，即使是關鍵字(39個)也可以。
package com.atguigu.chapter02.identify
import scala.collection.immutable.RedBlackTree.BlackTree
/**
* @author chenmingjun
* 2019-03-23 16:58
*/
object IdenDemo01 {
def main(args: Array[String]): Unit = {
// 首字元為操作符【比如 + - * /】，後續字元也需跟操作符，至少一個【反編譯檢視】。
val ++ = "hello" // ++ => $plus$plus
println(++)
val -+ = 90 // -+ => $minus$plus
println(-+)
val -+*/ = 90 // -+*/ => $minus$plus$times$div
println(-+*/)
var `true` = "world"
println(`true`)
var Double = 95.5
println(Double)
var Float = 85.5
println(Float)
var Long = 75.5
println(Long)
var Int = 65.5
println(Int)
var Short = 55.5
println(Short)
var Char = 45.5
println(Char)
var Byte = 35.5
println(Byte)
// var _ = "jack"
// println(_) // 錯誤，因為在scala中，下劃線有很多其他的作用，是以不能使用。
}
}
hello
90
90
world
95.5
85.5
75.5
65.5
55.5
45.5
35.5
2.15.3 辨別符舉例說明
hello // ok
hello12 // ok
1hello // error
h-b // error
x h // error
h_4 // ok
_ab // ok
Int // ok，在scala中，Int 不是關鍵字，而是預定義辨別符，可以用，但是不推薦。Double、Float、Long、Short、Char、Byte 同理。
_ // 不可以，因為在scala中，下劃線有很多其他的作用，是以不能使用。
Abc // ok
+*- // ok
+a // error
2.15.4 辨別符命名注意事項
1、包名：盡量采取有意義的包名，簡短，有意義。
2、變量名、函數名 、方法名 采用駝峰法。
2.15.5 Scala 關鍵字
Scala 有 39 個關鍵字：
package, import, class, object, trait, extends, with, type, forSome
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.16 作業01
1、在 Scala REPL(Read Evaluation Print Loop)中，計算3的平方根，然後再對該值求平方。現在，這個結果與3相差多少？
提示
：scala.math 找相應的方法。
2、Scala 語言的 sdk 是什麼？
答：sdk指的是scala的開發工具包。
3、Scala 環境變量配置及其作用。
4、Scala 程式的編寫、編譯、運作步驟是什麼？能否一步執行？
答：
編寫：就是使用工具，開發 scala 程式。
編譯：就是将 .scala 檔案編譯成 .class 【指令：scalac]】。
運作：就是使用 scala 來将 .class 檔案加載到 jvm 并運作，可以直接運作 .scala, 但是速度慢。【指令：scala xxx.scala】。
可以一步執行。
5、Scala 程式編寫的規則。
答：略。
6、簡述：在配置環境、編譯、運作各個步驟中常見的錯誤。
7、如何檢測一個變量是 val 還是 var?？
答：定義一個 val 和 var 的變量，然後通過指派就可以看出。
8、Scala 允許你用數字去乘一個字元串，去 REPL 中試一下 "crazy"*3。這個操作做什麼？在 Scaladoc 中如何找到這個操作？
答：搜尋礦中輸入 string，找到 StringOps 或者 WrappedString
Copyright ©2018-2019
【轉載文章務必保留出處和署名，謝謝！】