第二章 變量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
9、10 max 2 的含義是什么？max 方法定義在哪個類中？
答：返回兩個數中的最大值，10 max 2 等價於 10.max(2)，定義在 Int 類和 RichInt 類中。
10、用 BigInt 計算 2 的 1024 次方。提示：在 BigInt 找相應的方法。
11、在 Scala 中如何獲取字符串 “Hello” 的首字符和尾字符？ 提示: 在 String 中找相應的方法。
