变量声明

声明变量

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

声明常量

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

​ 注意：能用常量的地方不用变量
案例实操

package chapter01

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

    //声明一个变量的通用语法
    var a:Int = 1
    println(a) //结果：1

//    （1）声明变量时，类型可以省略，编译器自动推导，即类型推导
    var a1 = 10
    val b1 =20
    println(a1) //结果：10
    println(b1) //结果：20
    
//    （2）类型确定后，就不能修改，说明Scala是强数据类型语言。
    var a2 = 15
    a2 = "hello"//报错
    
//    （3）变量声明时，必须要有初始值
    var a3:Int  //报错

//    （4）在声明/定义一个变量时，可以使用var或者val来修饰，var修饰的变量可改变，val修饰的变量不可改。    
    a1 = 12
    b1 = 25 //报错
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

数据类型

Scala 与 Java有着相同的数据类型，下表列出了 Scala 支持的数据类型：

Scala类型层次结构

Any是所有类型的超类型，也称为顶级类型。它定义了一些通用的方法如equals、hashCode和toString。Any有两个直接子类：AnyVal和AnyRef，不管是值类还是引用类都是对象。

AnyVal代表值类型。有9个预定义的非空的值类型分别是：Double、Float、Long、Int、Short、Byte、Char、Unit和Boolean。

AnyRef代表引用类型。所有非值类型都被定义为引用类型。在Scala中，每个用户自定义的类型都是AnyRef的子类型。如果Scala被应用在Java的运行环境中，AnyRef相当于java.lang.Object。
1)Scala数据类型仍然遵守，低精度的值类型向高精度值类型，自动转换（隐式转换)
2)Scala中的StringOps是对Java中的String增强
3)Unit :对应Java中的void，用于方法返回值的位置，表示方法没有返回值。Unit是不带任何意义的值类型，它仅有一个实例可以像这样声明：()。所有的函数必须有返回，所以说有时候Unit也是有用的返回类型。Void不是数据类型，只是一个关键字
4)Null是一个类型，只有一个对象就是null。它是所有引用类型(AnyRef)的子类。
5)Nothing，是所有数据类型的子类，主要用在一个函数没有明确返回值时使用，因为这样我们可以把抛出的返回值，返回给任何的变量或者函数。

整数、浮点和布尔类型

整数
整型数据类型用于存放整数值

    val a1:Byte=127
    val a2:Byte= -12
    //val a3:Byte = 128//error

    val b1:Byte = 10

    val b2:Byte = (10+20)//强制类型转换
    //val b3:Byte = (b1+20)//error
    val b2:Byte = (10+20).toByte
1
2
3
4
5
6
7
8
9

浮点型
如果浮点数后面有f或者F后缀时，表示这是一个Float类型，否则就是一个Double类型的。如果在声明变量/常量没有指定类型，并且值为小数，scala默认归为Double类型
布尔型
布尔型数据类型有 true 和 false

字符类型

在 Scala 字符变量使用单引号 ’ 来定义

val c1:Char = 'a' 
val c2:Char = '\u0041'
val c3:Char = '\n'
val c1:Char = '\t'
1
2
3
4

Scala常见转义字符

Unit、Null和Nothing类型

    //unit
    def m1():Unit ={
      println("m1被调用") //结果：m1被调用
    }

    val a:Unit = m1()
    println("a: "+a)//结果：a: ()

    //null
    //val n:Int =null //error
    //an expression of type Null is ineligible for implicit conversion
    var student:Student = new Student(name = "alice",age = 20)
    student = null
    println(student) //结果：null

    //nothing
    def m2(n:Int):Int ={
      if(n==0)
        throw  new NullPointerException
      else
        return n
    }
    val b =m2(2)
    println("b:" +b) //结果：b:2
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

类型转换

自动类型转换
当 Scala 程序在进行赋值或者运算时，精度小的类型自动转换为精度大的数值类型。数据类型按精度（容量）大小排序为Byte, Short, Char -> Int -> Long -> Float -> Double
（1）自动提升原则：有多种类型的数据混合运算时，系统首先自动将所有数据转换成 精度大的那种数据类型，然后再进行计算。
（2）把精度大的数值类型赋值给精度小的数值类型时，就会报错，反之就会进行自动类型转换。
（3）（byte，short）和 char 之间不会相互自动转换。 char只会转为int
（4）byte，short，char 他们三者可以计算，在计算时首先转换为 int 类型。

//  （1）自动提升原则：有多种类型的数据混合运算时，系统首先自动将所有 数据转换成精度大的那种数值类型，然后再进行计算。
    var n = 1 + 2.0
    println(n) // 结果：3.0，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

    val res: Int = n6 + c2
    println(res)//结果：2
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

强制类型转换
自动类型转换的逆过程，将精度大的数值类型转换为类型小的数值类型，使用时要加上强制转换函数，强转会造成精度降低或溢出

var num:Int = 9.0.toInt
1

（1）将数据由高精度转换为低精度，就需要使用到强制转换
（2）强转符号只针对于最近的操作数有效，往往会使用小括号提升优先级

  //（1）将数据由高精度转换为低精度，就需要使用到强制转换
  var n1: Int = 2.5.toInt // 这个存在精度损失
  println(n1)//2

  //（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)//36
  println(r2)//44
1
2
3
4
5
6
7
8
9