Scala之变量与数据类型

目录

一、变量与常量

二、标识符

注：scala关键字

三、字符串

四、键盘输入

五、数据类型

 1.整数类型

2.浮点类型

3.字符类型

4.布尔类型

5.Unit类型、Null类型和Nothing类型

六、类型转换

1.数值类型自动转换

2.强制类型转换

 3.数值类型和String类型间转换

一、变量与常量

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

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

注意事项：

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

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

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

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

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

代码示例：

object Hello {
  def main(args: Array[String]): Unit = {
    //声明变量时，类型可以省略，编译器自动推导，即类型推导
    var i1 = 10
    //Scala是强数据类型语言,类型确定后，就不能修改
    var i2: Int = 10
    i2 = "10" //报错
    //变量声明时，必须要有初始值
    var i3: Int//报错
    //在声明/定义一个变量时，可以使用var或者val来修饰，var修饰的变量可改变，val修饰的变量不可改
    var i4: Int = 10
    val i5: Int = 20
    i4 = 30
    i5 = 40 //报错
    //var修饰的对象引用可以改变，val修饰的对象则不可改变，
    // 但对象的状态（值）却是可以改变的。（比如：自定义对象、数组、集合等等）
    val stu01 = new stu()
    var stu02 = new stu()
    // var 可以修改引用数据类型的地址值,val不行
    stu01 = new stu() //报错
    stu02 = new stu()
    // 引用数据类型中的属性值能否发生变化，取决于内部的属性在定义的时候是var还是val
    stu01.age = 26 //报错
    stu01.name = "lss"
    //在类中定义为_可以让编译器自动设置初始值
    println(stu02.i7)
    
  }
class stu {
      var name: String = "ls"
      val age: Int = 25
      var i7: Int = _
    }
}

二、标识符

        Scala对各种变量、方法、函数等命名时使用的字符序列称为标识符。

        命名规则：（1）字母下划线开头，后跟数字字母下划线。 a1 a2_

                          （2）只包含+ - * / # !

                          （3）用反引号` `包含的字段，可包括39个关键字

注：scala关键字

• 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 Int:String = "a" //在Scala中Int是预定义的字符,不是关键字
  var _: String = "a" // 单独一个下划线不可以作为标识符，因为_被认为是一个方法
  println(_) // IDEA不报错，运行报错

三、字符串

        字符串的基本用法

1.通过+号拼接

2.重复字符串拼接

3.printf:通过%传值

4.通过$获取变量值

5.应用三引号和scala的stripMargin方法，在scala中stripMargin默认是“|”作为连接符

object test01 {
  def main(args: Array[String]): Unit = {
    //1.通过+号拼接
    println("hello"+"world")//helloworld
    //2.重复字符串拼接
    println("hello"*10)//hellohellohellohellohellohellohellohellohellohello
    //3.printf:通过%传值
    printf("hello %s world %d\n",1,2) //hello 1 world 2
    //4.通过$获取变量值
    var name = "ls"
    var age = 25
    val s1 = s"name:${name},age:${age}" //name:ls,age:25
    println(s1)
    //5.长字符串
    println("1" +
      "2" +
      "3")//123
    //6.应用三引号和scala的stripMargin方法，在scala中stripMargin默认是“|”作为连接符
    println(
      """一
        |只
        |老
        |虎
        |""".stripMargin) //一
                          //只
                          //老
                          //虎
  }
}

四、键盘输入

输入字符串：StdIn.readLine()

输入整型：StdIn.readInt()

输入浮点型：StdIn.readDouble()

object test02 {
  def main(args: Array[String]): Unit = {
    print("请输入姓名")
    val name = StdIn.readLine()
    print("请输入年龄")
    val age = StdIn.readInt()
    print(s"姓名：${name},年龄：${age}")
  }
}
//请输入姓名ls
//请输入年龄25
//姓名：ls,年龄：25

五、数据类型

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

        2) Scala中数据类型分为两大类:数值类型(AnyVa1) 、引用类型（AnyRef)，不管是值类型还是引用类型都是对象。

        3)Scala数据类型仍然遵守低精度的值类型向高精度值的自动转换

        4)Scala中的StringOps是对Java中的String增强

        5)Unit :对应Java中的void，用于方法返回值的位置,表示方法没有返回值。Unit是一个数据类型，只有一个对象就是()。Void不是数据类型，只是一个关键字。

        6)Null是一个类型，只有一个对象就是ru1l。它是所有引用类型(AnyRef〉的子类。

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

 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

object test03 {
  def main(args: Array[String]): Unit = {
    //scala中任何代码都会被当做代码块执行，最终将最后一行代码的返回值返回
    val i:Int = {
      5 + 4
      2
      6
    }
    //val unit:Unit= print(i)

    //val exception:Nothing = throw new RuntimeException()
    val i1 = 5
    //Scala各整数类型有固定的表示范围和字段长度，不受具体操作的影响，以保证Scala程序的可移植性
    //val i2:Byte = 128//报错
    val i2:Byte = 126+1
    println(i2)
    var i3 = 1
    //var i1:Byte = 126 + i3 //因此每一行都是代码块 一行一行编辑 此时不知道i3的值 报错
  }
}

2.浮点类型

数据类型	描述
Float [4]	32 位, IEEE 754标准的单精度浮点数//float是科学计数法，long为二进制
Double [8]	64位 IEEE 754标准的双精度浮点数

object test04 {
  def main(args: Array[String]): Unit = {
    var i1:Float = 12.0f
    var i2:Double = 12.36
  }
}

3.字符类型

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

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

（3）\n ：换行符

（4）\\ ：表示\

      （5）\" ：表示"

object test05 {
  def main(args: Array[String]): Unit = {
    //字符常量是用单引号 ' ' 括起来的单个字符
    val a1: Char = 'a' //a
    val a2: Char = 97  //a

    // \t ：一个制表位，实现对齐的功能
    val a3: Char = '\t'
    println(a3)

    // \n ：换行符
    val a4: Char = '\n'
    println(a3 + 0) //9
    println(a4 + 0) //10

    // \\ ：表示\
    val a5: Char = '\\'
    println(a5 + 0) //92

    // \" ：表示"
    val a6: Char = '\"'
    println(a6 + 0) //34
  }
}

4.布尔类型

（1）Booolean类型数据只允许取值true和false

（2）boolean类型占1个字节

val bo1: Boolean = true
val bo2: Boolean = false

5.Unit类型、Null类型和Nothing类型

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

Unit：Unit只有一个实例（）

def main(args: Array[String]): Unit = {
  val `unit`:Unit = {
    1+1
    println(1)
  }
  println(`unit`) //()
  //如果标记对象的类型是unit的话,后面有返回值也没法接收
  val i:Unit = "hello"
  println(i) // Unit虽然是数值类型,但是可以接收引用数据类型,表示不接收返回值
}

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

 var s:String = "hello"
    s = null
    println(s) //null
    
    var i2:Int = 5
    i2 = null //报错

Nothing：可以作为没有正常返回值的方法的返回类型，而且该方法不会正常返回

 val value: Nothing = {
      println("hello")
      1 + 1
      throw new RuntimeException()
    }

六、类型转换

1.数值类型自动转换

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

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

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

（3）（byte，short）和char之间不会相互自动转换，因为byte和short是有符号的数值,而char是无符号的

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

object test07 {
  def main(args: Array[String]): Unit = {
    //自动提升原则
    val num:Double = 1 + 2.0f + 3.65
    //把精度大的数值类型赋值给精度小的数值类型时，就会报错，反之就会进行自动类型转换
    val num1:Double = 2.0
    //num1 = 1 //报错
    //（byte，short）和char之间不会相互自动转换
    var c:Char = 'a'
    //byte，short，char他们三者可以计算，在计算时首先转换为int类型
    val a:Short = 20
    val b:Byte = 30
    println(a+b+c)
  }
}

2.强制类型转换

        自动类型转换的逆过程，将精度大的数值类型转换为精度小的数值类型。

（1）将数据由高精度转换为低精度，就需要使用到强制转换

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

val a1:Double = 2.3
    println(a1.toInt) //2
    println((a1+0.5).toInt) //四舍五入

 3.数值类型和String类型间转换

（1）基本类型转String类型（语法：将基本类型的值+"" 即可）

（2）String类型转基本数值类型（语法：s1.toInt、s1.toFloat、s1.toDouble、s1.toByte、s1.toLong、s1.toShort）

     //基本类型转String类型
    val s1:Int = 20
    println(s1+"")
    val s2: String = s1.toString
    //String类型转基本类型
    val str1 = "3.14"
    val double: Double = str1.toDouble