Scala（二）之 变量与数据类型

2. 变量和数据类型

2.1 变量和常量

2.1.1基本语法

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

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

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

2.1.2案例实操

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

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

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

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

var num1 = 10   // 可变
val num2 = 20   // 不可变

num1 = 30  // 正确
//num2 = 100  //错误，因为num2是val修饰的

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

object TestVar {

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

        // 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 字符串输出

2.2.1基本语法

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

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

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

2.2.2案例实操

object TestCharType {
  def main(args: Array[String]): Unit = {
    var name="张三"
    var age=18
    //(1)字符串，通过+号连接
    println(name+age)
    //(2)printf用法，字符串、通过%传值
    printf("name=%s  age=%d",name,age)
    //(3)字符串，通过$引用
    //多行字符串，在Scala中，利用三个双引号包围多行字符串就可以实现。
    // 输入的内容，带有空格、\t之类，导致每一行的开始位置不能整洁对齐。
    //应用scala的stripMargin方法，在scala中stripMargin默认是“|”作为连接符，
    // 在多行换行的行头前面加一个“|”符号即可。
    val s=
      """
        |select
        | name,age
        |from user;
      """.stripMargin
    println(s)
    //如果需要对变量进行运算，那么可以加${}
    val s1=
      s"""
        |select
        | $name,$age
        |from user;
      """.stripMargin
    println(s1)
  }

}

2.3 键盘输入

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

2.3.1基本语法

StdIn.readLine()、StdIn.readShort()、StdIn.readDouble()

2.3.2案例实操

需求：可以从控制台接收用户信息，【姓名，年龄，薪水】。

import scala.io.StdIn

object TestInput {
  def main(args: Array[String]): Unit = {
    println("请输入姓名：")
    var name=StdIn.readLine()
    println("请输入年龄：")
    var age=StdIn.readInt()
    println("请输入工资：")
    var sal=StdIn.readDouble()

    println(s"$name 你好，今年$age 岁，工资$sal")
  }
}

2.4 数据类型

• Any：所有类型的超类（顶级类型）
• AnyVal：表示值类型的超类
• AnyRef：表示引用类型的超类，对应java.lang.Object
• Unit：表示无值，类似Java中的void
• Nothing：所有类型的子类
• Null：表示null或空引用

1）Scala中一切数据都是对象，都是Any的子类。

2）Scala中数据类型分为两大类：数值类型（AnyVal）、引用类型（AnyRef），不管是值类型还是引用类型都是对象。

3）Scala数据类型仍然遵守，低精度的值类型向高精度值类型，自动转换（隐式转换）

4）Unit：对应Java中的void，用于方法返回值的位置，表示方法没有返回值。Unit是一个数据类型，只有一个对象就是==（）==。Void不是数据类型，只是一个关键字

6）Null是一个类型，只有一个对象就是nul。它是所有引用类型（AnyRef）的子类。

5）Nothing，是所有数据类型的子类，主要用在一个函数没有明确返回值时使用，因为这样我们可以把抛出的返回值，返回给任何的变量或者函数。

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

2.5.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.5.2案例实操

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

		// 正确
        var n1:Byte = 127
        var n2:Byte = -128

        // 错误
        // var n3:Byte = 128
        // var n4:Byte = -129

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

		var n5 = 10
        println(n5)

        var n6 = 9223372036854775807L
        println(n6)

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

2.6 浮点类型（Float、Double）

2.6.1浮点型分类

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

2.6.2案例实操

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

 // 建议，在开发中需要高精度小数时，请选择Double
var n7 = 2.2345678912f
var n8 = 2.2345678912

println("n7=" + n7)
println("n8=" + n8)

n7=2.2345679
n8=2.2345678912

2.7 字符类型（Char）

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

2.7.1案例实操

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

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

（3）\n ：换行符

（4）\ ：表示\

（5）" ：表示"

        //（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("同学们都说：\"xxx最帅\"")

2.8 布尔类型（Boolean）

2.8.1基本说明

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

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

2.9 Unit类型、Null类型和Nothing类型

2.9.1基本说明

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

2.9.2案例实操

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

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

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

//null可以赋值给任意引用类型（AnyRef），但是不能赋值给值类型（AnyVal）
        var cat = new Cat();
        cat = null	// 正确

        var n1: Int = null // 错误
        println("n1:" + n1)

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

object TestSpecialType {

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

        def test() : Nothing={
            throw new Exception()
        }
        test
    }
}

2.10 类型转换

2.10.1 数值类型自动转换

当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.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.10.2 强制类型转换

1）基本说明

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

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

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 + 6*1 = 36
        var r2: Int = (10 * 3.5 + 6 * 1.5).toInt  // 44.0.toInt = 44

        println("r1=" + r1 + " r2=" + r2)
    }
}

2.10.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异常。

2.10.4 扩展面试题

object TestType {
  def main(args: Array[String]): Unit = {
    var n:Int=128
    var b:Byte=n.toByte
    println(b)
  }
}

结果为

-128

数据类型	字节大小	多少位二进制数	二进制位数含义(第一位从0开始)
int	4个字节	32位二进制数	第0位到第30位是数字位，第31位是符号位
byte	1个字节	8位二进制数	第0到第6位是数字位，第7位是符号位

类型	正数	负数
原码	将数字转换为二进制，即得到源码	将对应的整数的符号位改为1即得到该负数的原码
反码	反码与源码相同	将对应的原码除符号位(最高位)外，其余为全部取反(0变1，1变0)
补码	补码与反码相同	将对应反码，在末尾加1，即得到补码

1、将int类型的常量128转换为二进制为：

第24位到第31位	第16位到第23位	第8位到第15位	第0位到第7位
00000000	00000000	00000000	10000000

2、将int类型的常量，强制转换为byte类型，则从32位变成了8位，则砍掉高24位，则转换后的二进制为：

第0位到第7位
10000000

3、因为正数127的原码是：0111 1111，则-127的原码是1111 1111

(将对应的整数的符号位改为1即得到该负数的原码)

4、-127的反码是：1000 0000

(将对应的原码除符号位(最高位)外，其余为全部取反(0变1，1变0))

5、-127的补码是：1000 0001

(将对应反码，在末尾加1，即得到补码)

6、-128的补码是：1000 0000

(-127在减去1等于-128)