Scala-变量和数据类型

1. 注释

1. 与Java一致
2. 生成API方式 -> scaladoc 与Java中的javadoc对应

1. 单行注释：//
2. 多行注释：/* */
3. 文档注释：/**
	*
    */

2. 变量和常量

1. 变量 > var

// 1. var 变量名：数据类型 = 值
var age:Int = 18

// 2.  声明变量时，类型可以省略，编译器自动推导，即类型推导
var age = 18

// 3. 类型确定后，就不能修改，说明Scala是强数据类型语言。
var age = 18
// age = "abc" // 错误得

// 4. 变量声明时，必须要有初始值
var age:Int = 18

// 5. var修饰的对象引用可以改变
class Student{
	var name:String = "tiantian"
}
var st:Student = new Student
st.name = "changchang"
println(st.name) // "changchang"

常量 > val

// 1. val 变量名：数据类型 = 值
val age:Int = 18

//2. 不能改变值
val age:Int = 18
// age = 16 //直接报错

// 3. val修饰的对象则不可改变，但对象的状态（值）却是可以改变的。
class Student{
	var name:String = "tiantian"
}
val stu:Student = new Student
stu.name = "changchang" // 因为类中得name并不是val修饰，所以可以改变

3. 标识符

1. 普通得与Java一致
2. 以操作符开头，且只包含操作符（+ - * / # !等）
3. 用反引号....包括的任意字符串，即使是Scala关键字（39个）也可以

// （1）以字母或者下划线开头，后接字母、数字、下划线
    var hello: String = "" // ok
    var Hello12: String = "" // ok
    //var 1hello: String = "" // error 数字不能开头

    //var h-b: String = "" // error   不能用-
    //var x h: String = "" // error   不能有空格
    var h_4: String = "" // ok
    var _ab: String = "" // ok
    var Int: String = "" // ok 因为在Scala中Int是预定义的字符,不是关键字，但不推荐

    //var _: String = "hello" // ok 单独一个下划线不可以作为标识符，因为_被认为是一个方法
    //println(_)

    //（2）以操作符开头，且只包含操作符（+ - * / # !等）
    var +*-/#!@%& : String = "" // ok
    //var +*-/#!1 : String = "" // error 以操作符开头，必须都是操作符

    //（3）用反引号`....`包括的任意字符串，即使是Scala关键字（39个）也可以
    //var if : String = "" // error 不能用关键字
    var `if` : String = "" // ok 用反引号`....`包括的任意字符串,包括关键字

4. 字符串输出

1. 字符串，通过+号连接
2. printf用法：字符串，通过%传值。
3. 字符串模板（插值字符串）：通过$获取变量值

var name:String = "Scorpion"
    var age:Int = 18

    // 1. 字符串，通过+号连接
    println("欢迎"+ age + "岁的" + name +"来到学校学习")

    // 2. printf用法：字符串，通过%传值。
    printf("欢迎%d岁的%s来到学校学习",age,name)

    // 3. 字符串模板（插值字符串）：通过$获取变量值
    println("欢迎${age}岁的${name}来到学校学习")
      // 3.1 加 "s" 解析字符串中得${}
    println(s"欢迎${age}岁的${name}来到学校学习")
      // 3.2 加 "f" 进行格式化输出
    println(f"欢迎${age}%.2f岁的${name}来到学校学习")
      // 3.3 加 "raw" 让字符串不进行转义，原样输出(与Python中得"r"一样)
    println(raw"欢\n\t\n迎${age}岁的${name}来到学校学习")
      // 3.4 文本格式输出用""" ... """
    println(s"""
               |select
               |	*
               |from
               |	user
               |where
               |	name = ${name}
               |and
               |	age  = ${age + 1}
      """.stripMargin)

4. 键盘输入

1. 键盘输入用 “StdIn”

 println("请输入你的名字")
    var nameT:String = StdIn.readLine()

    //String类型可以省略，类型推导
    var sex = StdIn.readLine()

    val name: String = StdIn.readLine()
    println("请输入你的年龄")
    val age: Int = StdIn.readInt()

    println(s"欢迎${age}岁的${name}来到学校")

5. 数据类型

1. 若是一个函数想返回一个Int类型，但是加了异常之后，返回类型应该依然是Int才行
2. 如果纯异常类，可以用Nothing，打个标记

 -Any
	*AnyVal 值类型 
	*AnyRef	引用类型 

-几个比较特殊的类型
	*Unit 
		>表示返回值为空，相当于Java的void
		>Unit是类型，只有一个实例 ()

	*Null
		>表示当前引用没有指向任何对象
		>只有一个实例	null
		>null只能赋值给引用类型(Java中的String为引用类型)，不能赋值给值类型

	*Nothing
		>属于一个标记类，是抽象的
		>一般用于方法不能正常返回的时候（抛出异常等），使用Nothing做一个标记
		>是所有类型的子类型

//整数类型   在编译阶段 可以去确定值在Byte范围之内，会自动将Int转换为Byte
    var b:Byte = 10 + 20
    var a:Byte = 10
    var c:Byte = 20

    //在编译阶段，确定不了范围，所以编译就报错
    // var d:Byte = a + b // 错得
    // println(d)

    //如果是Long类型，需要加后缀标记，建议大写
    var a = 10L

    //在Scala中，如果是整数，默认Int；如果是浮点数，默认是Double
    var e = 10.0
    // println(e)

	 //字符类型
    //（1）字符常量是用单引号 ' ' 括起来的单个字符。
    var c1: Char = 'a'
    println("c1=" + c1)
    //注意：这里涉及自动类型提升，其实编译器可以自定判断是否超出范围，
    //不过idea提示报错
    var c2:Char = 'a' + 1
    println(c2) // b

6. 类型转化

当Scala程序在进行赋值或者运算时，精度小的类型自动转换为精度大的数值类型，这个就是自动类型转换（隐式转换）

1. 自动提升原则：有多种类型的数据混合运算时，系统首先自动将所有数据转换成精度大的那种数据类型，然后再进行计算。
2. 把精度大的数值类型赋值给精度小的数值类型时，就会报错，反之就会进行自动类型转换。
3. （byte，short）和char之间不会相互自动转换。
4. byte，short，char他们三者可以计算，在计算时首先转换为int类型。

//（1）自动提升原则：有多种类型的数据混合运算时，系统首先自动将所有数据转换成精度大的那种数据类型，然后再进行计算。
    // var a = 10L + 2
    // println(a) // Long

    //（2）把精度大的数值类型赋值给精度小的数值类型时，就会报错，反之就会进行自动类型转换。
    // var a:Int = 10
    // var b:Long = a   //自动类型转换
    // println(b) //Long

    // var a:Long = 10
    // var b:Int = a   //把精度大的数值类型赋值给精度小的数值类型时，就会报错
    // println(b)

    //（3）（byte，short）和char之间不会相互自动转换。
    //var b:Byte = 10
    //var s:Short = 20
    //var c1:Char = b
    //var c2:Char = s

    //（4）byte，short，char他们三者可以计算，在计算时首先转换为int类型。
    //Byte->Short->Int ->Long -> Float -> Double
    //      Char ->
    //var b:Byte = 10
    //var s:Short = 20
    //var c1:Char = 'a'
    //var res = b + s + c1
    //println(res)

    //强制类型转换  Java:   int a = (int)3.5
    //（1）将数据由高精度转换为低精度，就需要使用到强制转换
    //var a:Int = 3.5.toInt
    //println(a)

    //（2）强转符号只针对于最近的操作数有效，往往会使用小括号提升优先级
    //var res:Int = 3.5.toInt + 4.6.toInt
    //var res:Int = (3.5 + 4.6).toInt

    //值类型和字符串之间进行转换
    // var a:Int = 10
    // println(a.toString)
    // println(a + "")
    //在将字符串转换为对应的值类型之前，确定是可以转换的
    // var s:String = "20"
    // println(s.toInt)

7. 扩展

 	var n:Int = 128
    var b:Byte = n.toByte
    println(b) //-128

解析

	Int 128->Byte(-128~127)
	最高位符号为  0 正数  1 负数

	源码:00000000 00000000 00000000 10000000
	补码:00000000 00000000 00000000 10000000

	截取之后
		补码：10000000->反码:11111111->源码10000000
		10000000--->-0 --->11111111负数的最大值  -->10000000 负数的最小值 --> -128
		00000000--->+0
		
	---------------------------------------------------------
	
	Int 130->Byte(-128~127)
	最高位符号为  0 正数  1 负数

	源码:00000000 00000000 00000000 10000010
	补码:00000000 00000000 00000000 10000010
	截取之后
		补码：10000010->反码11111101->源码11111110 --> -126
		
	---------------------------------------------------------
	
	Int -130->Byte(-128~127)
	最高位符号为  0 正数  1 负数

	源码:10000000 00000000 00000000 10000010
	反码:11111111 11111111 11111111 01111101
	补码:11111111 11111111 11111111 01111110
	截取之后
		补码：01111110 ->源码01111110 --> 126