第 2 章 变量和数据类型

2.1 注释

Scala 注释使用和 Java 完全一样。

注释是一个程序员必须要具有的良好编程习惯。将自己的思想通过注释先整理出来，再用代码去体现。

1） 基本语法

（1）单行注释：//

（2）多行注释：/* */

（3）文档注释：

/**
  * 
  */

2） 案例实操

package com.neuedu.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） 代码规范

（1） 使用一次 tab 操作，实现缩进，默认整体向右边移动，用 shift+tab 整体向左移

（2） 或者使用 ctrl + alt + L 来进行格式化

（3）运算符两边习惯性各加一个空格。比如：2 + 4 * 5。

（4）一行最长不超过 80 个字符，超过的请使用换行展示，尽量保持格式优雅

2.2 变量和常量（重点）

常量：在程序执行的过程中，其值不会被改变的变量

0） 回顾：Java 变量和常量语法

变量类型 变量名称 = 初始值 int a = 10

final 常量类型 常量名称 = 初始值 final int b = 20

1） 基本语法

var 变量名 [: 变量类型] = 初始值 var i:Int = 10

val 常量名 [: 常量类型] = 初始值 val j:Int = 20

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

2） 案例实操

（1） 声明变量时，类型可以省略，编译器自动推导，即类型推导

（2） 类型确定后，就不能修改，说明 Scala 是强数据类型语言。

（3） 变量声明时，必须要有初始值

（4） 在声明/定义一个变量时，可以使用 var 或者 val 来修饰，var 修饰的变量可改变，

val 修饰的变量不可改。

package com.neuedu.chapter02 object TestVar {def main(args: Array[String]): Unit = { //（1）声明变量时，类型可以省略，编译器自动推导，即类型推导var age = 18age = 30 //（2）类型确定后，就不能修改，说明 Scala 是强数据类型语言。// age = "tom" // 错 误//（3）变量声明时，必须要有初始值// var name //错误

（5） ttttttttttttttttttScala3691.png)

ttttttttttttttttttScala3692.png)

var 修饰的对象引用可以改变，val 修饰的对象则不可改变，但对象的状态（值） 却是可以改变的。（比如：自定义对象、数组、集合等等)

2.3 标识符的命名规范

Scala 对各种变量、方法、函数等命名时使用的字符序列称为标识符。即：凡是自己可以起名字的地方都叫标识符。

1） 命名规则

Scala 中的标识符声明，基本和 Java 是一致的，但是细节上会有所变化，有以下三种规则：

（1） 以字母或者下划线开头，后接字母、数字、下划线

（2） 以操作符开头，且只包含操作符（+ - * / # !等）

（3） 用反引号包括的任意字符串，即使是 Scala 关键字（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、

ttttttttttttttttttScala4324.png)if，这些名字是否合法。

，

ttttttttttttttttttScala4352.png)

2.4 ttttttttttttttttttScala4361.png)字符串输出

1） 基本语法

（1） 字符串，通过+号连接

（2） printf 用法：字符串，通过%传值。

（3） 字符串模板（插值字符串）：通过$获取变量值

2）

ttttttttttttttttttScala4427.png)

案例实操

ttttttttttttttttttScala4458.png)

ttttttttttttttttttScala4463.png)尚硅谷大数据技术之 Scala

ttttttttttttttttttScala4480.png)—————————————————————————————

2.5 键盘输入

在编程中，需要接收用户输入的数据，就可以使用键盘输入语句来获取。

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 ttttttttttttttttttScala5005.png)ttttttttttttttttttScala5006.png)ttttttttttttttttttScala5007.png)数据类型（重点）

2.7 整数类型（Byte、Short、Int、Long）

Scala 的整数类型就是用于存放整数值的，比如 12，30，3456 等等。

1） 整型分类

数据类型	描述
Byte [1]	8 位有符号补码整数。数值区间为 -128 到 127
Short [2]	16 位有符号补码整数。数值区间为 -32768 到 32767
Int [4]	32 位有符号补码整数。数值区间为 -2147483648 到 2147483647
Long [8]	64 位有符号补码整数。数值区间为 -9223372036854775808 到9223372036854775807 = 2 的(64-1)次方-1

2） 案例实操

（1） Scala 各整数类型有固定的表示范围和字段长度，不受具体操作的影响，以保证

Scala 程序的可移植性。

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

（2） Scala 的整型，默认为Int 型，声明 Long 型，须后加‘l’或‘L’

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

（3） Scala 程序中变量常声明为Int 型，除非不足以表示大数，才使用Long

2.8 浮点类型（Float、Double）

Scala 的浮点类型可以表示一个小数，比如 123.4f，7.8，0.12 等等。

1） 浮点型分类

数据类型	描述
Float [4]	32 位, IEEE 754 标准的单精度浮点数
Double [8]	64 位 IEEE 754 标准的双精度浮点数

2） 案例实操

Scala 的浮点型常量默认为Double 型，声明 Float 型常量，须后加‘f’或‘F’。

object TestDataType { def main(args: Array[String]): Unit = { // 建议，在开发中需要高精度小数时，请选择Double var n7 = 2.2345678912fvar n8 = 2.2345678912 println("n7=" + n7) println("n8=" + n8)}}

//运行的结果

n7=2.2345679n8=2.2345678912

2.9 字符类型（Char）

1） 基本说明

字符类型可以表示单个字符，字符类型是 Char。

2） 案例实操

（1） 字符常量是用单引号 ' ' 括起来的单个字符。

（2） t ：一个制表位，实现对齐的功能

（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 ：一个制表位，实现对齐的功能println("姓名t 年龄")//（3）n ：换行符println("西门庆n 潘金莲")//（4） ：表示println("c:岛国avi")//（5）" ：表示"println("同学们都说："大海哥最帅"")}}

2.10 布尔类型：Boolean

1） 基本说明

（1） 布尔类型也叫Boolean 类型，Booolean 类型数据只允许取值 true 和 false

（2） boolean 类型占 1 个字节。

2） 案例实操

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

2.11 Unit 类型、Null 类型和Nothing 类型（重点）

1） 基本说明

数据类型	描述
Unit	表示无值，和其他语言中 void 等同。用作不返回任何结果的方法的结果类型。Unit 只有一个实例值，写成()。
Null	null , Null 类型只有一个实例值 null
Nothing	Nothing 类型在 Scala 的类层级最低端；它是任何其他类型的子类型。当一个函数，我们确定没有正常的返回值，可以用 Nothing 来指定返回类型，这样有一个好处，就是我们可以把返回的值（异常）赋给其它的函数或者变量（兼容性）

2） 案例实操

（1） Unit 类型用来标识过程，也就是没有明确返回值的函数。

ttttttttttttttttttScala7213.png)由此可见，Unit 类似于 Java 里的void。Unit 只有一个实例——( )，这个实例也没有实质意义

（2） ttttttttttttttttttScala7274.png)Null 类只有一个实例对象，Null 类似于 Java 中的 null 引用。Null 可以赋值给任意引用类型（AnyRef），但是不能赋值给值类型（AnyVal）

（3） ttttttttttttttttttScala7370.png)ttttttttttttttttttScala7371.png)Nothing，可以作为没有正常返回值的方法的返回类型，非常直观的告诉你这个方法不会正常返回，而且由于 Nothing 是其他任意类型的子类，他还能跟要求返回值的方法兼容。

2.12 类型转换

扩展 Java 面试题（隐式类型转换）：

ttttttttttttttttttScala7490.png)

2.12.1 数值类型自动转换

ttttttttttttttttttScala7502.png)当 Scala 程序在进行赋值或者运算时，精度小的类型自动转换为精度大的数值类型，这个就是自动类型转换（隐式转换）。数据类型按精度（容量）大小排序为：

1） 基本说明

（1） 自动提升原则：有多种类型的数据混合运算时，系统首先自动将所有数据转换成精度大的那种数据类型，然后再进行计算。

（2） 把精度大的数值类型赋值给精度小的数值类型时，就会报错，反之就会进行自动类型转换。

（3）（byte，short）和 char 之间不会相互自动转换。

（4）byte，short，char 他们三者可以计算，在计算时首先转换为 int 类型。

2） 案例实操

object TestValueTransfer {def main(args: Array[String]): Unit = { //（1）自动提升原则：有多种类型的数据混合运算时，系统首先自动将所有数据转换成精度大的那种数值类型，然后再进行计算。var n = 1 + 2.0println(n) // n 就 是 Double//（2）把精度大的数值类型赋值给精度小的数值类型时，就会报错，反之就会进行自动类型转换。var n2 : Double= 1.0//var n3 : Int = n2 //错误，原因不能把高精度的数据直接赋值和低精度。//（3）（byte，short）和 char 之间不会相互自动转换。var n4 : Byte = 1//var c1 : Char = n4 //错误var n5:Int = n4 //（4）byte，short，char 他们三者可以计算，在计算时首先转换为 int类型。var n6 : Byte = 1 var c2 : Char = 1// var n : Short = n6 + c2 //当 n6 + c2 结果类型就是int// var n7 : Short = 10 + 90 //错误}}

注意：Scala 还提供了非常强大的隐式转换机制（隐式函数，隐式类等），我们放在高级部分专门用一个章节来讲解。

2.12.2 强制类型转换

1） 基本说明

ttttttttttttttttttScala8395.png)自动类型转换的逆过程，将精度大的数值类型转换为精度小的数值类型。使用时要加上强制转函数，但可能造成精度降低或溢出，格外要注意。

2） 案例实操

（1） 将数据由高精度转换为低精度，就需要使用到强制转换

（2） 强转符号只针对于最近的操作数有效，往往会使用小括号提升优先级

object TestForceTransfer { def main(args: Array[String]): Unit = { //（1）将数据由高精度转换为低精度，就需要使用到强制转换var n1: Int = 2.5.toInt // 这个存在精度损失//（2）强转符号只针对于最近的操作数有效，往往会使用小括号提升优先级var r1: Int = 10 * 3.5.toInt + 6 * 1.5.toInt // 10 3 + 61= 36var r2: Int = (10 * 3.5 + 6 * 1.5).toInt // 44.0.toInt =44 println("r1=" + r1 + " r2=" + r2)}}

2.12.3 数值类型和String 类型间转换

1） 基本说明

在程序开发中，我们经常需要将基本数值类型转成 String 类型。或者将 String 类型转成基本数值类型。

2） 案例实操

（1） 基本类型转 String 类型（语法：将基本类型的值+"" 即可）

（2） String 类型转基本数值类型（语法：s1.toInt、s1.toFloat、s1.toDouble、s1.toByte、

s1.toLong、s1.toShort）

object TestStringTransfer { def main(args: Array[String]): Unit = { //（1）基本类型转 String 类型（语法：将基本类型的值+"" 即可）var str1 : String = true + "" var str2 : String = 4.5 + "" var str3 : String = 100 +"" //（2）String 类型转基本数值类型（语法：调用相关 API） var s1 : String = "12" var n1 : Byte = s1.toByte var n2 : Short = s1.toShort var n3 : Int = s1.toInt var n4 : Long = s1.toLong}}

（3） 注意事项

在将 String 类型转成基本数值类型时，要确保 String 类型能够转成有效的数据，比如我们可以把"123"，转成一个整数，但是不能把"hello"转成一个整数。

var n5:Int = "12.6".toInt 会出现NumberFormatException 异常。

扩展面试题

ttttttttttttttttttScala9581.png)