大数据技术之_16_Scala学习_02

第二章变量 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 字符类型：Char 2.9.1 基本介绍 2.9.2 案例演示 2.9.3 字符类型使用细节 2.9.4 字符类型本质探讨 2.10 布尔类型：Boolean 2.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 中找相应的方法。