详解 Scala 的变量、标识符、数据类型

一、注释

Scala 注释与 Java 一致

scala 复制代码

// 单行注释

/*
 * 多行注释
 */

/**
 * 文档注释
 */

二、变量与常量

1. 语法

scala 复制代码

// 变量，类型可以省略
var varName:varClass = value
// 常量，类型可以省略
val valName:valClass = value

2. 案例

scala 复制代码

// 使用 var/val 才会在类中声明属性，否则只是参数
class Student(name:String, var age:Int) { 
    def printInfo():Unit = {
        println(name + "," + age + "," + Student.school)
    }
}

object TestVariable {
    def main(args: Array[String]): Unit = {
        // 定义变量和常量的通用语法
        var a: Int = 10
        val b: String = "James"
        
        // 声明变量时，类型可以省略，编译器自动推导，即类型推导
        var a1 = 10
        
        // 变量类型确定后，就不能修改，Scala 是强数据类型语言
        var a2 = 20
        // a2 = "Bob"  // 报错
        
        // 变量声明时，必须要有初始值
        // var a3: Int   // 报错
        
        // var 修饰的变量可改变，val 修饰的变量不可改
        val b1 = 30
        // b1 = 25 // 报错
        
        // var 修饰的对象引用可以改变，val 修饰的对象不可改变，但对象的属性可以改变
        var tom = new Student("Tom", 20)
        tom = new Student("tom", 18)
        
        val rose = new Student("rose", 16)
        // rose = new Student("Rose", 18) // 报错
        rose.age = 18
        // rose.name = "Rose" // 报错
    }
}

三、标识符

Scala 对各种变量、方法、函数等命名时使用的字符序列称为标识符

1. 规则

第一类：以字母或者下划线开头，后接字母、数字、下划线
第二类：以操作符开头，且只包含操作符（+ - * / # !等）

第三类：用反引号 `` 包括的任意字符串，即使是 Scala 关键字（39 个）也可以

scala 复制代码

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. 案例

scala 复制代码

object TestIdentifier {
    def main(args: Array[String]): Unit = {
        // 以字母或者下划线开头，后接字母、数字、下划线
        var hello = "hello"
        var hello123 = "hello123"
        var _hello = "_hello"
        
        // var h-b = 10 // 报错
        // var 123abc = 20 // 报错
        
        // 以操作符开头，且只包含操作符（+ - * / # !等）
        var -+/% = 30
        println(-+/%)
        
        // var -a+4/b = 30 // 报错
        
        // 用反引号 `` 包括的任意字符串
        var `class` = "class"
        println(`class`)
        
        // var class = "class" // 报错
    }
}

四、字符串输出

scala 复制代码

object TestString {
    def main(args: Array[String]): Unit = {
        // 字符串通过 + 或 * 号拼接
        var name = "James"
        var age = 37
        println(age + "岁的" + name + "还在征战 NBA")
        println(name * 4) //字符串复制拼接
		
        // printf 将字符串格式输出，通过 % 占位传值
        printf("%d岁的%s还在征战 NBA", age, name)
		println()
        
        // 字符串模板（插值字符串）：通过 $ 获取变量值
        // s"${var}"
        println(s"${age}岁的${name}还在征战 NBA")
        
        // f"${var}%"：格式化模板字符串
        var num = 2.3456 // 默认 Double 类型
        println(f"The number is ${num}%2.2f") // The number is 2.35，保留两位小数
        
        // raw"${}"：保留原始格式输出
        println(raw"The number is ${num}%2.2f") // The number is 2.3456%2.2f
        
        // 三引号模板字符串：保持多行字符串的原格式输出，s""" """
        val sql = s"""
                |select
                | name,
                | age
                |from student 
                |where name = ${name}
                |and age > ${age}
                """.stripMargin
        println(sql)
        
    }
}

五、控制台输入

1. 语法

scala 复制代码

// 使用 scala.io 包下的 StdIn 类的方法
StdIn.readLine()
StdIn.readInt()

2. 案例

scala 复制代码

import scala.io.StdIn

object TestStdIn {
    def main(args: Array[String]): Unit = {
        println("请输入姓名：")
        val name = StdIn.readLine()
        println("请输入年龄：")
        val age = StdIn.readInt()
        
        println(s"欢迎${age}岁的${name}")
    }
}

六、读写文件

scala 复制代码

import scala.io.Source

object TestStdIn {
    def main(args: Array[String]): Unit = {
        // 读取文件数据
        Source.fromFile("src/main/resources/test.txt").foreach(print)
        
        // 写入数据到文件，使用 Java 的类库
        val writer = new PrintWriter(new File("src/main/resources/output.txt"))
        writer.write("hello scala from java writer")
        writer.close()
    }
}

七、数据类型

Scala 中一切数据都是对象，都是 Any 的子类
Scala 中数据类型分为两大类：数值类型（AnyVal）、引用类型（AnyRef），不管是值类型还是引用类型都是对象
Scala 数据类型仍然遵守，低精度的值类型向高精度值类型，自动转换（隐式转换）
Scala 中的 StringOps 是对 Java 中 String 的增强
Unit：对应 Java 中的 void，用于方法返回值的位置，表示方法没有返回值。Unit是一个数据类型，只有一个对象就是()。void 不是数据类型，只是一个关键字
Null是一个类型，只有一个对象就是 null。它是所有引用类型（AnyRef）的子类
Nothing，是所有数据类型的子类，主要用在一个函数没有明确返回值时使用，这样可以把抛出的返回值，返回给任何的变量或者函数

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

案例：

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
        
        // 整数默认为 Int
        val a1 = 10
        
        // 数值范围超过 Int，则需要声明为 Long 型且必须后加 l 或 L(建议)
        val a2: Long = 9223372036854775807L
        
        // 不同类型计算
        val a3: Byte = (10 + 20) // IDEA报错，但可以正确运行
        val a4: Byte = 10
        // val a5: Byte = (a4 + 20) // 运行报错
        val a6: Byte = (a4 + 20).toByte
    }
}

2. 浮点类型

分类：

类型描述

Float[4] 32 位, IEEE 754 标准的单精度浮点数

Double[8] 64 位 IEEE 754 标准的双精度浮点数

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

案例：

scala 复制代码

object TestDataType {
    def main(args: Array[String]): Unit = {
        // 浮点数默认为 Double
        val d1 = 3.1415
        
        // 声明 Float 型常量，须后加 f 或 F
        var f1: Float = 2.2345678912f
        // var f2: Float = 2.2345678912 //报错
        
    }
}

3. 字符类型

说明：字符类型 Char 表示单个字符

案例：

scala 复制代码

object TestDataType {
    def main(args: Array[String]): Unit = {
        // 字符常量是用单引号 '' 括起来的单个字符
        val c1: Char = 'a'
        val c2 = '9'
        
        // 控制字符
        val c3 = '\t' // 制表符
        val c4 = '\n' // 换行符
        
        // 转义字符
        val c5 = '\\' // 表示 \
        val c5 = '\""' // 表示 ""
        
        // 字符类型底层保存的 ASCII 码值
        val i1: Int = c1 // 97
        val i2: Int = c2 // 57
    }
}

4. 布尔类型

说明：
- 布尔类型也叫 Boolean 类型，Booolean 类型数据只允许取值 true 和 false
- Boolean 类型占 1 个字节

案例：

scala 复制代码

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

5. Unit/Null/Nothing 类型

说明

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

案例

scala 复制代码

object TestDataType {
    def main(args: Array[String]): Unit = {
        // 1.空值 Unit
        def m1(): Unit = {
            println("m1 被调用")
        }
        
        val a: Unit = m1()
        println("a:" + a) // a:()
        
        // 2.空引用 Null
        // val b: Int = null // 报错
        var stu: Student = new Student("tom", 18)
        stu = null
        println("stu:" + stu) // stu:null
        
        // 3.Nothing
        def m2(n: Int): Nothing = {
            throw new NullPointerException
        }
        
    }
}

八、类型转换

1. 自动类型转换

自动提升原则：有多种类型的数据混合运算时，系统首先自动将所有数据转换成精度大的那种数据类型，然后再进行计算
把精度大的数值类型赋值给精度小的数值类型时，就会报错，反之就会进行自动类型转换
(Byte, Short) 和 Char 之间不会相互自动转换
Byte，Short，Char 三者可以计算，在计算时首先转换为 Int 类型
虽然 Byte 可以自动提升为 Short 精度，但是二者在运算时必须提升为 Int

scala 复制代码

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 n7: Short = 2
        var c2: Char = 1
        // var n : Short = n6 + c2 + n7 // n6 + c2  结果类型是 int
        // var n8 : Short = n6 + n7 // 错误
        
    }
}

2. 强制类型转换

将数据由高精度转换为低精度，就需要使用到强制转换，但存在精度损失或数据溢出
强转符号只针对于最近的操作数有效，往往会使用小括号提升优先级

scala 复制代码

object TestDataTypeConversion {
    def main(args: Array[String]): Unit = {
        val a: Int = 10
        // val a1: Byte = a // 报错
        val a1: Byte = a.toByte  // 调用转换方法：toShort/toInt/toLong.....
        
    }
}

object TestType {
    def main(agrs: Array[String]): Unit = {
        // 强制类型转换数据溢出
        val n: Int = 130
        val b: Byte = n.toByte
        println("b:" + b) // -126
        
        /*
          解析：8421码
          Int 类型的 130 在底层的存储(4 字节，32 位)：
          原码：0000 0000 0000 0000 0000 0000 1000 0010
          反码：0000 0000 0000 0000 0000 0000 1000 0010
          补码：0000 0000 0000 0000 0000 0000 1000 0010
          
          Int转Byte：1 字节，8 位
          补码：1000 0010
          反码：1000 0001
          原码：1111 1110
          -126
        */
    }
}

3. 数值与String转换

scala 复制代码

object TestNumAndStringConversion {
    def main(agrs: Array[String]): Unit = {
        // 1.数值转String
        val a: Int = 3
        val str: String = a + ""
        
        // 2.String转数值
        var s1 : String = "12"
        var s2 : String = "12.3"
        var n1 : Byte = s1.toByte
        var n2 : Short = s1.toShort
        var n3 : Int = s1.toInt
        var n4 : Long = s1.toLong
        
        // var n5: Int = s2.toInt // 运行抛 NumberFormatException
        // var nn5: Int = "hello".toInt // 报错
        var n6: Double = s2.toDouble
        
    }
}