【Scala】——变量&数据类型&运算符
1. 概述
1.1 Scala 和 Java 关系
1.2 scala特点
Scala是一门以Java虚拟机（JVM）为运行环境并将面向对象和函数式编程的最佳特性结合在一起的静态类型编程语言（静态语言需要提前编译的如：Java、c、c++等，动态语言如：js）。
- Scala是一门多范式的编程语言，Scala支持面向对象和函数式编程。（多范式，就是多种编程方法的意思。有面向过程、面向对象、泛型、函数式四种程序设计方法。）
- Scala源代码（.scala）会被编译成Java字节码（.class），然后运行于JVM之上，并可以调用现有的Java类库，实现两种语言的无缝对接。
- Scala单作为一门语言来看，非常的简洁高效。
- Scala在设计时，马丁·奥德斯基是参考了Java的设计思想，可以说Scala是源于Java，同时马丁·奥
德斯基也加入了自己的思想，将函数式编程语言的特点融合到JAVA中。
1.3 scala安装
- 首先确保 JDK1.8 安装成功
- 下载对应的 Scala 安装文件https://www.scala-lang.org/
- 解压 scala-2.12.11.zip
- 配置 Scala 的环境变量
注意 1：解压路径不能有任何中文路径，最好不要有空格。
注意 2：环境变量要大写 SCALA_HOME
2. 变量和数据类型
2.1 变量和常量
2.1.1 语法
var 变量名 [: 变量类型] = 初始值 var i:Int = 10
val 常量名 [: 常量类型] = 初始值 val j:Int = 20
注意：能用常量的地方不用变量
2.1.2 说明
- 声明变量时，类型可以省略，编译器自动推导，即类型推导
- 类型确定后，就不能修改，说明 Scala 是强数据类型语言。
- 变量声明时，必须要有初始值
- 在声明/定义一个变量时，可以使用 var 或者 val 来修饰，var 修饰的变量可改变，val 修饰的变量不可改。
2.1.3 案例
object TestVar {
def main(args: Array[String]): Unit = {
//（1）声明变量时，类型可以省略，编译器自动推导，即类型推导
var age = 18
age = 30
//（2）类型确定后，就不能修改，说明 Scala 是强数据类型语言。
// age = "tom" // 错误
//（3）变量声明时，必须要有初始值
// var name //错误
//（4）在声明/定义一个变量时，可以使用 var 或者 val 来修饰，var 修饰 的变量可改变 ,val 修饰的变量不可改
var num1 = 10 // 可变
val num2 = 20 // 不可变
num1 = 30 // 正确
//num2 = 100 //错误，因为 num2 是 val 修饰的
// p1 是 var 修饰的，p1 的属性可以变，而且 p1 本身也可以变
var p1 = new Person()
p1.name = "dalang"
p1 = null
// p2 是 val 修饰的，那么 p2 本身就不可变（即 p2 的内存地址不能变）， 但是 ，p2 的属性是可以变 ，因为属性并没有用 val 修饰 。
val p2 = new Person()
p2.name = "jinlian"
// p2 = null // 错误的，因为 p2 是 val 修饰的
}
}
class Person {
var name: String = "jinlian"
}
2.2 标识符的命名规范
- 以字母或者下划线开头，后接字母、数字、下划线
- 以操作符开头，且只包含操作符（+ - * / # !等）
- 用反引号…包括的任意字符串，即使是 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.3 字符串输出
2.3.1 基本语法
- 字符串，通过+号连接
- printf 用法：字符串，通过%传值。
- 字符串模板（插值字符串）：通过$获取变量值
2.3.2 案例
object TestCharType {
def main(args: Array[String]): Unit = {
var name: String = "jingling"
var age: Int = 123;
//（1）字符串，通过+号连接
println(name + " " + age)
//（2）printf 用法字符串，通过%传值。
printf("name=%s age=%d\n", name, age)
//（3）字符串，通过$引用
//多行字符串，在 Scala中，利用三个双引号包围多行字符串就可以实现。
//输入的内容，带有空格、\t 之类，导致每一行的开始位置不能整洁对齐。
//应用 scala 的 stripMargin 方法，在 scala 中 stripMargin 默认 是“|”作为连接符， //在多行换行的行头前面加一个“|”符号即可。
val s =
"""
| select
| name
,
| age
| from user
|where name="zhangsan"
""".stripMargin
println(s)
println("--------------------------------")
//如果需要对变量进行运算，那么可以加${}
val s1 =
s"""
|select
| name,
| age
|from user
|where name="$name" and age=${age + 2}
""".stripMargin
println(s1)
println("--------------------------------")
val s2 = s"name=$name"
println(s2)
println("--------------------------------")
}
}
2.5 键盘输入
2.5.1 语法
//Read a full line from the default input. Returns null if the end of the input stream has been reached.
StdIn.readLine()
//Reads a short value from an entire line of the default input.
StdIn.readShort()
//Reads a double value from an entire line of the default input.
StdIn.readDouble()
2.5.2 案例
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 数据类型
2.6.1 概述
- Scala中一切数据都是对象，都是Any的子类。
- Scala中数据类型分为两大类：数值类型（AnyVal）、引用类型（AnyRef），不管是值类型还是引用类型都是对象。
- Scala数据类型仍然遵守，低精度的值类型向高精度值类型，自动转换（隐式转换）
- Scala中的StringOps是对Java中的String增强
- Unit：对应Java中的void，用于方法返回值的位置，表示方法没有返回值。Unit是 一个数据类型，只有一个对象就是()。Void不是数据类型，只是一个关键字
- Null是一个类型，只有一个对象就是null。它是所有引用类型（AnyRef）的子类。
- Nothing，是所有数据类型的子类，主要用在一个函数没有明确返回值时使用，因为这样我们可以把抛出的返回值，返回给任何的变量或者函数。
- Scala中一切都是对象，都是Any的子类，10 和new User() 意义一样
2.6.2 整数类型（Byte、Short、Int、Long）
- Scala 各整数类型有固定的表示范围和字段长度，不受具体操作的影响，以保证 Scala 程序的可移植性。
// 正确
var n1: Byte = 127
var n2: Byte = -128
// 错误
// var n3:Byte = 128
// var n4:Byte = -129
- Scala 的整型，默认为 Int 型，声明 Long 型，须后加‘l’或‘L
var n5 = 10
println(n5)
var n6 = 9223372036854775807L
println(n6)
- Scala 程序中变量常声明为 Int 型，除非不足以表示大数，才使用 Long
2.6.3 浮点类型（Float、Double）
// 建议，在开发中需要高精度小数时，请选择 Double
var n7 = 2.2345678912f
var n8 = 2.2345678912
println("n7=" + n7)
println("n8=" + n8)
2.6.4 字符类型（char）
- 字符类型可以表示单个字符，字符类型是 Char。
- 字符常量是用单引号 ’ ’ 括起来的单个字符。
- \t ：一个制表位，实现对齐的功能
- \n ：换行符
- \ ：表示\
- " ：表示"
//（1）字符常量是用单引号 ' ' 括起来的单个字符。
var c1: Char = 'a'
println("c1=" + c1)
//注意：这里涉及自动类型提升，其实编译器可以自定判断是否超出范围，
//不过 idea 提示报错
var c2:Char = 'a' + 1
println("c2="+c2)
//（2）\t ：一个制表位，实现对齐的功能
println("姓名\t 年龄")
//（3）\n ：换行符
println("西门庆\n 潘金莲")
//（4）\\ ：表示\
println("c:\\岛国\\avi")
//（5）\" ：表示"
println("同学们都说：\"大海哥最帅\"")
2.6.5 布尔类型（Booleam）
- 布尔类型也叫 Boolean 类型，Booolean 类型数据只允许取值 true 和 false
- boolean 类型占 1 个字节。
var isResult : Boolean = false
var isResult2 : Boolean = true
2.6.6 Unit类型、Null类型、Nothing类型
- Unit 类型用来标识过程，也就是没有明确返回值的函数。由此可见，Unit 类似于 Java 里的 void。Unit 只有一个实例——( )，这个实例也没有实质意义
object TestSpecialType {
def main(args: Array[String]): Unit = {
val ok = sayOk
println(ok)
}
def sayOk: Unit = { // unit 表示没有返回值，即 void
}
}
- Null 类只有一个实例对象，Null 类似于 Java 中的 null 引用。Null 可以赋值给任 意引用类型（AnyRef），但是不能赋值给值类型（AnyVal）
object TestSpecialType {
def main(args: Array[String]): Unit = {
var cat = new Cat()
println(cat)
cat = null
println(cat)
}
}
class Cat {
}
- Nothing，可以作为没有正常返回值的方法的返回类型，非常直观的告诉你这个方 法不会正常返回，而且由于 Nothing 是其他任意类型的子类，他还能跟要求返回值的方法兼 容。
def test(): Nothing = {
throw new Exception()
}
test
2.7 类型转换
2.7.1 数值类型自动转换
• 当 Scala 程序在进行赋值或者运算时，精度小的类型自动转换为精度大的数值类型，这 个就是自动类型转换（隐式转换）。数据类型按
• 自动提升原则：有多种类型的数据混合运算时，系统首先自动将所有数据转换成 精度大的那种数据类型，然后再进行计算。
• 把精度大的数值类型赋值给精度小的数值类型时，就会报错，反之就会进行自动 类型转换。
• （byte，short）和 char 之间不会相互自动转换。
• byte，short，char 他们三者可以计算，在计算时首先转换为 int 类型。
object TestValueTransfer {
def main(args: Array[String]): Unit = {
//（1）自动提升原则：有多种类型的数据混合运算时，系统首先自动将所有 数据转换成精度大的那种数值类型 ，然后再进行计算 。
var n = 1 + 2.0
println(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 //错误
}
}
2.7.2 强制类型转换
• 自动类型转换的逆过程，将精度大的数值类型转换为精度小的数值类型。使用时要加上 强制转函数，但可能造成精度降低或溢出，格外要注意。
• 将数据由高精度转换为低精度，就需要使用到强制转换
• 强转符号只针对于最近的操作数有效，往往会使用小括号提升优先级
Java : int num = (int)2.5
Scala : var num : Int = 2.7.toInt
object TestForceTransfer {
def main(args: Array[String]): Unit = {
//（1）将数据由高精度转换为低精度，就需要使用到强制转换
var n1: Int = 2.5.toInt // 这个存在精度损失
println("n1="+n1)
//（2）强转符号只针对于最近的操作数有效，往往会使用小括号提升优先级
var r1: Int = 10 * 3.5.toInt + 6 * 1.5.toInt // 10 *3 + 6*1 = 36
var r2: Int = (10 * 3.5 + 6 * 1.5).toInt // 44.0.toInt =44
println("r1=" + r1 + " r2=" + r2)
}
}
2.7.3 数值类型和String类型转换
• 数值类型转 String 类型（语法：将基本类型的值+“” 即可）
• String 类型转基本数值类型（语法：s1.toInt、s1.toFloat、s1.toDouble、s1.toByte、s1.toLong、s1.toShort）
• 在将 String 类型转成基本数值类型时，要确保 String 类型能够转成有效的数据，比如我 们可以把"123"，转成一个整数，但是不能把"hello"转成一个整数。
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. 运算符
3.1 算数运算符
• 对于除号“/”，它的整数除和小数除是有区别的：整数之间做除法时，只保留整数部分而舍弃小数部分。
• 对一个数取模 a%b，和 Java 的取模规则一样。
object TestArithmetic {
def main(args: Array[String]): Unit = {
//（1）对于除号“/”，它的整数除和小数除是有区别的：整数之间做除法 时，只保留整数部分而舍弃小数部分。
var r1: Int = 10 / 3 // 3
println("r1=" + r1)
var r2: Double = 10 / 3 // 3.0
println("r2=" + r2)
var r3: Double = 10.0 / 3 // 3.3333
println("r3=" + r3)
println("r3=" + r3.formatted("%.2f")) // 含义：保留小数点 2位，使用四舍五入
//（2）对一个数取模 a%b，和 Java 的取模规则一样。
var r4 = 10 % 3 // 1
println("r4=" + r4)
}
}
3.2 关系运算符
object TestRelation {
def main(args: Array[String]): Unit = {
// 测试：>、>=、<=、<、==、!=
var a: Int = 2
var b: Int = 1
println(a > b) // true
println(a >= b) // true
println(a <= b) // false
println(a < b) // false
println("a==b" + (a == b)) // false
println(a != b) // true
}
}
3.3 赋值运算符
Scala 中没有++、–操作符，可以通过+=、-=来实现同样的效果
3.4 运算符本质
在 Scala 中其实是没有运算符的，所有运算符都是方法。
• 当调用对象的方法时，点.可以省略
• 如果函数参数只有一个，或者没有参数，()可以省略
object TestOpt {
def main(args: Array[String]): Unit = {
// 标准的加法运算
val i: Int = 1.+(1)
// （1）当调用对象的方法时，.可以省略
val j: Int = 1 + (1)
// （2）如果函数参数只有一个，或者没有参数，()可以省略
val k: Int = 1 + 1
println(1.toString())
println(1 toString())
println(1 toString)
}
}