Scala-变量和数据类型

Scala变量和数据类型

注释和编码规范

Scala中的注释和Java中完全相同

// 单行注释

/*
	多行注释
	多行注释
*/

/**
 * 文档注释
 * 文档注释
 */

代码规范

1. 使用一次 tab 操作,实现缩进,默认整体向右边移动,用 shift+tab 整体向左移；
2. 或者使用 ctrl + alt + L 来进行格式化；
3. 运算符两边习惯性各加一个空格。比如:2 + 4 * 5。
4. 一行最长不超过 80 个字符,超过的请使用换行展示,尽量保持格式优雅

变量和常量

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

// var 变量名 [i: 变量类型] = 初始值
var i:Int = 10
// 或者省略[i: 变量类型]
var i = 10

// val 常量名 [j: 常量类型] = 初始值
val j:Int = 10
var j = 10

可以像js那样，省略中括号中的变量类型，并且能用常量的地方最好不要使用变量。

• 声明变量时,类型可以省略,编译器会自动推导,即类型推导；
• 类型确定后,就不能修改,说明 Scala 是强数据类型语言；
• 变量声明时,必须要有初始值；
• 在声明/定义一个变量时,可以使用 var 或者 val 来修饰**,var 修饰的变量可改变**,val 修饰的变量不可改，val修饰的对象，该对象里面的值也是可以更改的。

标识符的命名规范

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

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

var `if` = "if"

字符串输出

基本语法
1、字符串,通过+号连接
2、printf 用法:字符串,通过%传值。
3、字符串模板(插值字符串):通过$获取变量值

// 字符串,通过+号连接
val name = "test"
println("hello " + name) // hello test
// *用于讲一个字符串复制多次并拼接
println(name * 3) // testtesttest


// printf 用法:字符串,通过%传值。
printf("hello %s", name) // hello test


// 字符串模板(插值字符串):通过$获取变量值
// s""表示模板字符串
println(s"hello ${name}") // hello test

// f""表示格式化模板字符串
val num: Double = 2.3456
println(f"hello %{num}%2.2f") // hello 2.34

// row""原始输出
println(f"hello %{num}%2.2f") // hello 2.3456%2.2f

// 三引号表示字符串，保持多行字符串的原格式输出
val sql = s"""
       |select *
       |from
       |  student
       |where
       |  name = ${name}
       |""".stripMargin
println(sql)
// 结果如下：
/*
select *
from
  student
where
  name = test
*/

键盘输入

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

基本语法：StdIn.readLine()、StdIn.readShort()、StdIn.readDouble()

实操：

object StdInTest {

    def main(args: Array[String]): Unit = {

        // 输入信息
        println("请输入你的大名：")
        val name = StdIn.readLine()

        println("请输入你的年龄")
        val age = StdIn.readInt()

        println(s"欢迎${age}岁的${name}")
    }
}

结果如下：

请输入你的大名：
test
请输入你的年龄
12
欢迎12岁的test

读写文件

object FileReadAndWrite {

    def main(args: Array[String]): Unit = {

        // 从文件中读取数据
        Source.fromFile("datas/scala/test").foreach(print)

        // 将数据写入文件
        val writer = new PrintWriter(new File("datas/scala/out"))
        writer.write("hello hahahahaha")
        writer.close()
    }
}

数据类型

Java基本类型:char、byte、short、int、long、float、double、boolean

Java引用类型:(对象类型)

由于Java有基本类型,而且基本类型不是真正意义的对象,即使后面产生了基本类型的包装类,但是仍然存在基本数据类型,所以Java语言并不是真正意思的面向对象。

Java基本类型的包装类:Character、Byte、Short、Integer、Long、Float、Double、Boolean

注意:Java中基本类型和引用类型没有共同的祖先

所有类的最终祖先都是Object，但是基本类型不是

Scala的数据类型：

Unit唯一的对象是()，小括号。

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

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

Byte的-128为1000000,127为10000001,0为00000000,127为01111111

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 = 10
        println(n5)
        var n6 = 9223372036854775807L
        println(n6)
    }
}

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

浮点类型（Float、Double）

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

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

字符类型（Char）

字符类型可以表示单个字符,字符类型是 Char。字符变量底层保存ASCII码。

1、字符常量是用单引号 ’ ’ 括起来的单个字符

2、\t :一个制表位,实现对齐的功能

3、n :换行符

4、\\ :表示\

5、\" :表示"

布尔类型（Boolean）

布尔类型也叫 Boolean 类型,Booolean 类型数据只允许取值 true 和 false。boolean 类型占 1 个字节。

Unit类型、Null类型、Nothing类型

Unit 类型用来标识过程,也就是没有明确返回值的函数。由此可见,Unit 类似于 Java 里的 void。Unit 只有一个实例( ),这个实例也没有实质意义

object TestSpecialType {
    def main(args: Array[String]): Unit = {
        def sayOk : Unit = {
            println("我被调用了")
        }
        
        println(sayOk) // ()
    }
}

Null 类只有一个实例对象,Null 类似于 Java 中的 null 引用。Null 可以赋值给任意引用类型(AnyRef),但是不能赋值给值类型(AnyVal)

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

类型转换

隐式类型转换

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

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

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

3、(byte,short)和 char 之间不会相互自动转换。

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

强制类型转换

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

Java : int num = (int)2.5
Scala : var num : Int = 2.7.toInt

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

强转可能会造成精度丢失，也可能会造成数据溢出。

数值类型和 String 类型间转换

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

基本类型转 String 类型(语法:将基本类型的值+"" 即可)；

String 类型转基本数值类型(语法:s1.toInt、s1.toFloat、s1.toDouble、s1.toByte、s1.toLong、s1.toShort)

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

/**
 * 正数的补码就是其本身
 * 负数的补码是在其原码的基础上, 符号位不变, 其余各位取反（符号位不变）, 最后+1. (即在反码的基础上+1)
 *
 * 128：Int类型，占据4个字节，32位
 * 原码：0000 0000 0000 0000 0000 0000 1000 0000
 * 补码：0000 0000 0000 0000 0000 0000 1000 0000
 * 截取最后一个字节
 * 得到补码1000 0000，导出原码（取反+1）1000 0000
 * 1000 0000 表示最大的Byte负数-128
 *
 * 130：Int类型，占据4个字节，32位
 * 原码：0000 0000 0000 0000 0000 0000 1000 0010
 * 补码：0000 0000 0000 0000 0000 0000 1000 0010
 * 截取最后一个字节
 * 得到补码1000 0010，导出原码（取反+1）1111 1110
 * 1111 1110 表示最大的Byte负数-126
 *
 */
object DataTypeChange {

    def main(args: Array[String]): Unit = {

        var m: Int = 128
        println(m.toByte) // -128

        var n: Int = 130
        println(n.toByte) // -126
    }
}