Scala-day02-变量和数据类型

一：注释

        与java一模一样

二：变量和常量

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

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

1：声明变量时，类型可以省略，编译器自动推导，即类型推导
2：类型确定后，就不能修改，说明 Scala 是强数据类型语言
3：变量声明时，必须要有初始值
4：在声明 定义一个变量时，可以使用var或者val来修饰，var修饰的变量可改变

val bob = new Student("bob",23)

bob = new Student("bob",25)会出错，因为bob为val

但是可以用bob.age=25，来进行改变

三：标识符

        1：命名规则

Scala中的标识符声明，基本和Java是一致的，但是细节上会有所变化，有以下三种

1：以字母或者下划线开头，后接字母、数字、下划线

2：以操作符开头，且只包含操作符（+ - * / # ！等）

3：用反引号'....'包括的任意字符串，即使是Scala关键字也可以        

        2： 案例实操

package chapter02

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

    // 以字母或者下划线开头，后接字母，数字，下划线
    var hello:String = ""
    var hello12:String = ""
    //var 1hello:String = "" //数字不能开头

    var h-b:String = "" // 不能有-号，这个在运行代码的时候才会显示出来
    var x h:String = ""
    var h_4:String = ""
    var _ab:String = ""
    var Int:String = ""
    var _:String = "hello" //单独一个下划线不能作为标识符，因为_被认为是一个方法
    println(_)

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

    // 用反引号'....'包含的任意字符串，即使是Scala关键字也可以
    var if :String = "" //不能使用关键字
    var `if` : String = "" //用`...`包括的任意字符串，包括关键字
  }
}

 四：字符串

        1：基本语法

1：字符串，通过+号连接

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

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

        2：案例实操（代码）

package chapter02

object TestCharType {
  def main(args: Array[String]): Unit = {
    var name : String = "jinlian"
    var age : Int = 18

    // 字符串，通过+号连接
    println(name + " " + age)

    // printf用法字符串，通过%传值
    printf("name=%s age=%d\n",name,age)

    // 字符串，通过$引入
    println(s"${age}岁的${name}在学习")

    val num : Double = 2.3456
    println(f"The num is ${num}%2.2f") //格式化模板字符串，可以设置保留多少位小数

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

         3：结果

五： 键盘输入

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

六：读写文件

 七：数据类型

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

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

八：整数和浮点，字符类型

        1：整数分类

Byte：-128~127

Short：-32768~32767

Int：-2147483648~2147483647

Long：负的，2的63次方至2的63次方-1

        2：实操

package chapter02

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

    //1.整数类型
    val a1:Byte = 127
    val a2:Byte = -128

    //   val a2:Byte = 128 //ERROR

    val a3 = 12 //整数默认类型为int
    val a4 = 1232434334343L   //超出int范围，加一个L

    val b1:Byte = 10
    val b2 = 10 + 20

//    val b3:Byte = b1 + 20
    val b3 : Byte = (b1 + 20).toByte

    //浮点
    val f1 : Float = 1.2345f
    val d1 = 34.313

    // 字符类型
    val c1:Char = 'a'
    println(c1)

    val c2:Char = '9'
    println(c2)

    val c3:Char = '\t'
    val c4:Char = '\n'
    println("abc" + c3 + "def")
    println("abc" + c4 + "def")

    //转义字符
    val c5 = '\\'  //表示\自身
    val c6 = '\"'  //表示"
    println("abc"+c5+"def")
    println("abc"+c6+"def")

    // ASCII码
    val i1:Int = c1
    println("i1: " + i1)
    val i2:Int =c2
    println("i2: " + i2)

    // 布尔类型
    val isTrue:Boolean = true
    println(isTrue)
  }
}

九：空类型

        1：基本说明

Unit：表示无值，和其他语言中void等同。用作不返回任何结果的方法的结果类型。Unit只有一个实例值，写成()。

Null：null，Null类型只有一个实例值null

Nothing：Nothing类型在Scala的类层级最低端；它是任何其他类型的子类型。 当一个函数，我们确定没有正常的返回值，可以用Nothing来指定返回类型，这样有一个好处，就是我们可以把返回的值（异常）赋给其它的函数或者变量（兼容性）

        2：案例

package chapter02

import chapter01.Student

object TestNull {

  // 控制Unit
  def m1():Unit = {
    println("m1被调用执行")
  }

  val a = m1()
  println(a)        //这个a输出是（）

  // 空引用null
  val student:Student = new Student("alice",20)
  student = null
  println(student)

  //nothing
  def m2(n:Int):Nothing = {
    throw new NullPointerException
  }

  val b = m2(0)
  println(b)
}

十：类型转换

        精度小的类型自动转换为精度大的数值类型，这个就是自动类型转换，隐式转换。

        1：基本说明

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

                2：把精度大的数值类型赋值给精度小的数值类型时，会报错，反正就会自动类型转换

                3：（byte、short）和char之间不会相互自动转化

                4：byte、short、char他们三种可以计算，在计算时首先转换为int类型

        2：案例

package chapter02

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

    //1
    val a1:Byte = 10
    val b1:Long = 2353L
    val result1 = a1 + b1 //Long类型

    val result11:Int = (a1 + b1).toInt  //int类型

    //2
    val a2:Byte = 10
    val b2:Int = a2
    val c2:Byte = b2  //error

    //3
    val a3:Byte = 10
    val b3:Char = 'b'
    // val c3:Byte = b3  //error
    val c3:Byte = b3.toByte
    println(c3)

    //4
    val a4:Byte = 12
    val b4:Short = 25
    val c4:Char = 'c'
   // val result4:Short = a4 + b4//error
  }
}

十一：强制类型转换

        强转可能照成精度的降低，或者数据的溢出

        1：高精度转低精度，要使用强制类型转换

val n1:Int = 2.5.toInt
println("n1: " + n1)  //结果为2，如果时-2.5的话，取-2，只是取整数部分

        2：强转符号只针对于最近的操作数有效，往往会使用小括号提升优先级

val n2:Int = 2.6.toInt + 3.7.toInt
val n3:Int = (2.6 + 3.7).toInt
println("n2: " + n2)  //n2是5，实际得到应该是6.3取整为6
println("n3: " + n3)

        3：string和数值转换

//数值类型和String类型
    //数值转string
        val n:Int = 27
        val s:String = n + ""
        println(s)

    //string转数值
        val m:Int = "12".toInt
        val f:Float = "12.3".toFloat
        val f2:Int = "12.3".toInt  //这个是有问题的
        val f3:Int = "12.3".toDouble.toInt  //先转换为double，再转int

        4：强转溢出

                130源码补码最后八位是：1000 0010

                byte截取最后一个字节得到补码，1000 0010，得到对应原码取反加一，符号位不变

                即是：1111 1110：-126，则b为-126