Scala-变量和数据类型

深藏阁楼爱情的钟 2022-08-30 14:54 220阅读 0赞

# 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的数据类型**：

![在这里插入图片描述][a7d085d7731237d25c6352a6f247e27b.png]

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

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

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

![在这里插入图片描述][f55b3bb80098147df47da60c8ec1323e.png]

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 等等。

![在这里插入图片描述][a200ed746ca531e3be4d097e99921597.png]

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类型 ##

![在这里插入图片描述][b841e2d0c53e041b908ee257f13ada85.png]

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

![在这里插入图片描述][4110846546914694390fe238248759da.png]

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
        }
    }

[a7d085d7731237d25c6352a6f247e27b.png]: /images/20220829/41a3dc4d5b184ee4aedc9bedaa854c02.png
[f55b3bb80098147df47da60c8ec1323e.png]: /images/20220829/692efbd8c8e44db1bc296ed3815b4b06.png
[a200ed746ca531e3be4d097e99921597.png]: /images/20220829/7a213860989645e3a02a82c990f7d30a.png
[b841e2d0c53e041b908ee257f13ada85.png]: /images/20220829/a6548e91abab433c8de3c32aba3bea02.png
[4110846546914694390fe238248759da.png]: /images/20220829/cf58af2872e34615a10daf256810b003.png