Scala（二）：变量

1.为什么需要变量

一个程序就是一个世界，在scala中一切都是对象

2.变量是程序的基本组成单位

不论是使用哪种高级程序语言编写程序,变量都是其程序的基本组成单位，比如：

object ScalaFunDemo01 {
    def main(args: Array[String]): Unit = {
        var a : Int = 1 //定义一个整型变量,取名a,并赋初值1
        var b : Int = 3 //定义一个整型变量,取名b,并赋初值3
        b = 89 //给变量b 赋 89
        println("a=" + a) //输出语句,把变量a的值输出
        println("b=" + b) //把变量b的值输出
    }
}

3.变量的介绍

3.1 概念

变量相当于内存中一个数据存储空间的表示，你可以把变量看做是一个房间的门 牌号，通过门牌号我们可以找到房间，而通过变量名可以访问到变量(值)。

3.2 变量使用的基本步骤

1) 声明/定义变量 (scala要求变量声明时初始化)

2) 使用

4.变量基本使用

5.Scala变量使用说明

5.1 变量声明基本语法

var | val 变量名 [: 变量类型] = 变量

5.2 注意事项

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

object VarDemo01 {
    def main(args: Array[String]): Unit= {
        //编译器，动态的(逃逸分析)
        var age: Int = 10
        var sal: Double = 10.9
        var name:String = "tom"
        var isPass:Boolean = true
        //在 scala中，小数默认为Double ,整数默认为Int
        var score:Float = 70.9f
        printIn(s"${age} ${isPass}")
    }
}

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

3) 在声明/定义一个变量时，可以使用var 或者 val 来修饰， var 修饰的变量可改变， val 修饰的变量不可改.

object VarDemo02{
    def main(args: Array[String]): Unit = {
        
        //类型推导
        var num= 10//这时num就是Int
        //方式1，可以利用idea的提示来证明,给出提示
        //方式2，使用isInstanceOf[Int]判断
        println(num.isInstanceOf[Int])

        //类型确定后，就不能修改，说明Scala是强数据类型语言()
        // num = 2.3，错误
    
        //3.在声明/定义一个变量时，可以使用var或者 val来修饰，var修饰的变量可改变，val修饰的变量不可改
        var age = 10//即 age是可以改变的.
        age = 30 // ok
        
        val num2= 30
        //num2 = 40 // val 修饰的变量是不可以改变.

        //scala设计者为什么设计var和 val
        //(1)在实际编程，我们更多的需求是获取/创建一个对象后，读取该对象的属性
        //或者是修改对象的属性值，但是我们很少去改变这个对象本身
        //dog = new Dog() dog.age = 10 dog = new Dog()
        //这时，我们就可以使用val
        //(2)因为val 没有线程安全问题，因此效率高，scala 的设计者推荐我们val
        //(3)如果对象需要改变，则使用var

        val dog = new Dog
        //dog =new Dog //Reassignment to val
        dog.age = 90 //ok
        dog.name ="小花"//ok
    }
}

class Dog {
    //声明一个age属性，给了一个默认值_
    var age :Int = 0 //

    //声明名字
    var name:String =""//
}

4) val修饰的变量在编译后，等同于加上final， 通过反编译看下底层代码。

object VarDemo03{
    var namc = "hcllo"
    val age = 100
    def main(args: Array[String]): Unit= {
        println("ok")
    }
}


对应的底层的反编译的代码
public final class VarDemo03${
    public static final MODULE$;
    private String name;
    private final int age;
}

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

class Dog {
    var age = 100
}

6) 变量声明时，需要初始值。 

6.程序中 +号的使用

1) 当左右两边都是数值型时，则做加法运算

2) 当左右两边有一方为字符串，则做拼接运算

7.数据类型

1) Scala 与 Java有着相同的数据类型，在Scala中数据类型都是对象，也就是说scala 没有java中的原生类型

2) Scala数据类型分为两大类 AnyVal(值类型) 和 AnyRef(引用类型)， 注意：不管是 AnyVal还是AnyRef 都是对象。[案例演示 Int , Char] 

var num1 : Int = 10
println("num1" + num1)
var char1 : Char = 'a' println("char1的code= ")

3) 相对于java的类型系统，scala要复杂些！也正是这复杂多变的类型系统才让面向 对象编程和函数式编程完美的融合在了一起

4) 案例

object TypeDemo01{
    def main(args: Array[String): Unit = {
        var numl: Int = 10
        //因为Int是一个类，因此他的一个实例，就是可以使用很多方法
        //在 scala 中，如果一个方法，没有形参，则可以省略()
        println(num1.toDouble + "\t"+num1.toString + 100.toDouble)

        var isPass = true //
        ptintln(isPass.toSting)
        
        sayHi()
}

    def sayHi(): Unit ={
        println("say hi"")
    }
}

7.1 scala数据类 型体系一览 图(记住)

对上面图的小结和整理

1) 在scala中有一个根类型Any ,他是所有类的父类.

2) scala中一切皆为对象，分为两大类AnyVal(值类型)，AnyRef(引用类型)，他们都是Any子类.

3) Null类型是scala的特别类型，它只有一个值 null，他是bottom calss ,是所有AnyRef类型的子类.

4) Nothing类型也是bottom class ,他是所有类的子类，在开发中通常可以将Nothing类型的值返回给任意变量或者函数，这里抛出异常使用很多.

object TypeDemo02{
    def main(args: Array[String]): Unit = {
        println(sayHello)
    }

    //比如开发中，我们有一个方法，就会异常中断，这时就可以返回Nothing
    //即当我们Nothing 做返回值，就是明确说明该方法没有没有正常返回值
    def sayHello: Nothing = {
        throw new Exception("抛出异常")
    }
}

5)在scala中仍然遵守，低精度的值，向高精度的值自动转换(implicit conversion)隐式转换.

var num= 1.2//默认为double
var num2= 1.7fl/这是float
//num2 =num ,error ,修改num2= num.toFloat

7.2 scala数据类型列表

8.整数类型

基本介绍

Scala的整数类型就是用于存放整数值的，比如 12 , 30, 3456等等

整型的类型

整型的使用细节 

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

2) Scala的整型 常量/字面量 默认为 Int 型，声明Long型 常量/字面量 须后加 ‘l’’或‘L’ 

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

4)案例

object TyepDemo03 {
    def main(args: Array[String]): Unit ={
        println("long 的最大值"+ Long.MaxValue + "~"+ Long.MinValue)
        var i= 10l/i Int
        var j= 101/lj Long
        var e = 92233720368547758071//说 92233720368547758071超过int
    }
}

9.浮点类型

基本介绍

Scala的浮点类型可以表示一个小数，比如 123.4f，7.8 ，0.12等等

浮点型的分类

浮点型使用细节 

1) 与整数类型类似，Scala 浮点类型也有固定的表数范围和字段长度，不受具体OS 的影响。

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

object TyepDemo03{
    def main(args: Array[String]): Unit ={
        printIln("long 的最大值"+ Long.MaxValue + "~"+ Long.MinValue)
        var i= 10//i Int
        var j= 101/lj Long
        var e = 92233720368547758071//说 92233720368547758071超过int

        //2.2345678912f ,2.2345678912
        var num1:Float= 2.2345678912f
        var num2:Double= 2.2345678912
        println("num1=" + num1 + "num2=" + num2)
   }
} 

3) 浮点型常量有两种表示形式

十进制数形式：	如：5.12 512.0f .512 (必须有小数点）
科学计数法形式：	科学计数法形式:

4) 通常情况下，应该使用Double型，因为它比Float型更精确(小数点后大致7位)

//测试数据 ：2.2345678912f , 2.234567891

10.字符类型(Char)

基本介绍

字符类型可以表示单个字符,字符类型是Char， 16位无符号Unicode字符(2个字节), 区间值为 U+0000 到 U+FFFF

案例演示

object CharDemo {
    def main(args: Array[String]): Unit = {
        var char1: Char= 97
        //当我们输出一个char类型是，他会输出该数字对应的字符(码值表unicode)
        //unicode码值表包括ascii
        println("char1=" + char1)l/ a

        //char可以当做数字进行运行var char2: Char = 'a'
        var num= 10 + char2
        println("num="+ num)// 107

        //原因和分析
        //1.当把一个计算的结果赋值一个变量,则编译器会进行类型转换及判断(即会看范围+类型)
        //2.当把一个字面量赋值一个变量，则编译器会进行范围的判定
        //var c2: Char = 'a'+ 1
        //var c3: Char= 97＋1
        //var c4 : Char = 98
    }
}

字符类型使用细节

1) 字符常量是用单引号(‘ ’)括起来的单个字符。例如：var c1 = 'a‘ var c2 = '中‘ var c3 = '9'

2) Scala 也允许使用转义字符‘\’来将其后的字符转变为特殊 字符型常量。例如：var c3 = ‘\n’ // '\n'表示换行符

3) 可以直接给Char赋一个整数，然后输出时，会按照对应 的unicode 字符输出 ['\u0061' 97]

4) Char类型是可以进行运算的，相当于一个整数，因为它都 对应有Unicode码.

字符类型本质探讨

1) 字符型 存储到 计算机中，需要将字符对应的码值（整数）找出来

存储：	字符——>码值——>二进制——>存储
读取：	二进制——>码值——> 字符——>读取

2) 字符和码值的对应关系是通过字符编码表决定的(是规定好)， 这一点和Java 一样

11.布尔类型：Boolean

基本介绍

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

2) boolean类型占1个字节。

3) boolean 类型适于逻辑运算，一般用于程序流程控制：

if条件控制语句；

while循环控制语句；

do-while循环控制语句；

for循环控制语句

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

基本说明

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

使用细节和注意事项

1) Null类只有一个实例对象，null，类似于Java中的null引用。null可以赋值给任意 引用类型(AnyRef)，但是不能赋值给值类型(AnyVal: 比如 Int, Float, Char, Boolean, Long, Double, Byte, Short)

2) Unit类型用来标识过程，也就是没有明确返回值的函数。 由此可见，Unit类似于Java里的void。Unit只有一个实例， ()，这个实例也没有实质的意义

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

4) 代码

object UnitNullNothingDemo {
    def main(args: Array[String]): Unit= {
        val res = sayHello()
        println("res=" + res)
        
        //Null类只有一个实例对象,null,类似于Java中的null引用。null可以赋值给任意引用类型(AnyRef),但是不能赋值给值类型(AnyVal: 比如 Int, Float, Char, Boolean, Long, Double, Byte, Short)
        val dog: Dog = null
        //错误
        val char1 : Char = null
        println("ok~~~")
    }
    //Unit等价于java的 void,只有一个实例值()
    def sayHello(): Unit= {
    }
}
class Dog {
}

13.值类型转换

值类型隐式转换

1) 介绍：当Scala程序在进行赋值或者运算时，精度小的类型自动转换为精度大的数 据类型，这个就是自动类型转换(隐式转换)。

2) 数据类型按精度(容量)大小排序为

 3) 自动类型转换细节说明

1.有多种类型的数据混合运算时，系统首先自动将所有数据转换成容量最大的那种数据类 型，然后再进行计算。 5.6 + 10 = 》double

2.当我们把精度(容量)大 的数据类型赋值给精度(容量)小 的数据类型时，就会报错，反之 就会进行自动类型转换。

3.(byte, short) 和 char之间不会相互自动转换。

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

5. 自动提升原则： 表达式结果的类型自动提升为 操作数中最大的类型

object Demo01 {
    def main(args: Array[String]): Unit= {
        var nl = 10
        var n2 = 1.1f
        //1,有多种类型的数据混合运算时，系统首先自动将所有数据转换成容量最大的那种数据类型，然后再进行计算
        var n3 =nl +n2

        //2.(byte, short)和 char 之间不会自动的转换类型
        var n4: Byte = 10
        //var char1 : Char = n4 //错误，因为byte不能自动转换char
    }
}

高级隐式转换和隐式函数

scala还提供了非常强大的隐式转换机制(隐式函数，隐式类等等)，我们放在高级部 分专门用一个章节来讲解

强制类型转换

1) 介绍

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

2) 案例演示

java : int num = (int)2.5
scala : var num : Int = 2.7.toInt //对象

3) 强制类型转换细节说明

1.当进行数据的 从 大——>小，就需要使用到强制转换

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

object Demo02 {
    def main(args: Array[String]): Unit ={
        val num1: Int= 10 * 3.5.toInt + 6 * 1.5.toInt // 36
        val num2: Int =(10*3.5+6*1.5).toInt // 44
        printIn(numl +" "+ num2)

        val char1 : Char = 1
        val num3 = 1
        //val char2 : Char = num3 //错
    }
}

3.Char类型可以保存 Int的常量值，但不能保存Int的变量值，需要强转

4.Byte和Short类型在进行运算时，当做Int类型处理

14.值类型和String类型的转换

介绍

在程序开发中，我们经常需要将基本数据类型转成String 类型。 或者将String类型转成基本数据类型。

基本类型转String类型

语法： 将基本类型的值+"" 即可 案例演示：

val d1 =1.2
//基本数据类型转string
val sl = dl ＋""//以后看到有下划线，就表示编译器做了转换

String类型转基本数据类型

语法：通过基本类型的String的 toXxx方法即可

注意事项

1) 在将String 类型转成 基本数据类型时，要确保String类型能够转成有效的数据， 比如 我们可以把 "123" , 转成一个整数，但是不能把 "hello" 转成一个整数

2) 把 "12.5" 转成 Int 

15.标识符的命名规范

标识符概念

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

2) 凡是自己可以起名字的地方都叫标识符

标识符的命名规则(记住)

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

1) 首字符为字母，后续字符任意字母和数字，美元符号，可后接下划线_

2) 数字不可以开头。

3) 首字符为操作符(比如+ - * / )，后续字符也需跟操作符 ,至少一个(反编译)

4) 操作符(比如+-*/)不能在标识符中间和最后.

5) 用反引号`....`包括的任意字符串，即使是关键字(39个)也可以 [true]

标识符举例说明

hello // ok
hello12 // ok
1hello // error
h-b // error
x h // error
h_4 // ok _ab // ok
Int // ok, 在scala中，Int 不是关键字，而是预定义标识符,可以用，但是不推荐
Float // ok _ // 不可以，因为在scala中，_ 有很多其他的作用，因此不能使用
Abc // ok
+*- // ok
+a // error

标识符命名注意事项

1) 包名：尽量采取有意义的包名，简短，有意义

2) 变量名、函数名 、方法名 采用驼峰法

16.Scala关键字

关键字介绍

Scala有39个关键字：

• package, import, class, object, trait, extends, with, type, forSome

• 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

17.代码说明

17.1 dataconvert（数据转换）

1.Demo01（案例1）

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

    var n1 = 10
    var n2 = 1.1f

    //1,有多种类型的数据混合运算时，系统首先自动将所有数据转换成容量最大的那种数据类型，然后再进行计算
    var n3 = n1 + n2

    //2.(byte, short) 和 char 之间不会自动的转换类型
    var n4: Byte = 10
    //var char1 : Char = n4 // 错误，因为byte 不能自动转换char

  }
}

2.Demo02（案例2）

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

    val num1: Int = 10 * 3.5.toInt + 6 * 1.5.toInt  // 36
    val num2: Int = (10 * 3.5 + 6 * 1.5).toInt // 44
    println(num1 + " " + num2)

    val char1 : Char = 1
    val num3 = 1
    //val char2 : Char = num3 //错
  }
}

3.string2basic（string的2个基础）

object string2basic {
  def main(args: Array[String]): Unit = {
    val d1 = 1.2
    //基本数据类型转 string
    val s1 = d1 + "" //以后看到有下划线，就表示编译器做了转换

    //String类型转基本数据类型

    val s2 = "12"
    val num1 = s2.toInt
    val num2 = s2.toByte
    val num3 = s2.toDouble
    val num4 = s2.toLong

    println("ok~")

    //在将String 类型转成 基本数据类型时，要确保String类型能够转成有效的数据，比如 我们可以把 "123" , 转成一个整数，但是不能把 "hello" 转成一个整数
//    val s3 = "hello"
//    println(s3.toInt)

    //思考就是要把 "12.5" 转成 Int
    //在scala中，不是讲小数点后的数据进行截取，而是会抛出异常
    val s4 = "12.5"
    println(s4.toInt) // error
    println(s4.toDouble) //  ok
  }
}

17.2 datatype（数据类型）

1.TypeDemo01（类型案例1）

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

    var num1: Int = 10
    //因为Int 是一个类，因此他的一个实例，就是可以使用很多方法
    //在scala中，如果一个方法，没有形参，则可以省略()
    println(num1.toDouble + "\t" +num1.toString + 100.toDouble)


    var isPass = true //
    println(isPass.toString)


    sayHi()

  }

  def sayHi(): Unit = {
    println("say hi")
  }
}

2.TypeDemo02（类型案例2）

object TypeDemo02 {
  def main(args: Array[String]): Unit = {
    println(sayHello)

    var num = 1.2 //默认为double
    var num2 = 1.7f //这是float
    //num2 = num ,error ,修改num2 = num.toFloat
  }

  //比如开发中，我们有一个方法，就会异常中断，这时就可以返回Nothing
  //即当我们Nothing做返回值，就是明确说明该方法没有没有正常返回值
  def sayHello: Nothing = {
      throw  new Exception("抛出异常")

  }
}

3.TyepDemo03（类型案例3）

object TyepDemo03 {
  def main(args: Array[String]): Unit = {
    println("long的最大值" + Long.MaxValue + "~" + Long.MinValue)

    var i = 10 //i Int
    var j = 10l //j Long
    var e = 9223372036854775807l //说 9223372036854775807 超过int

    //2.2345678912f  , 2.2345678912
    var num1:Float = 2.2345678912f
    var num2:Double = 2.2345678912
    println("num1=" + num1 + "num2=" + num2)
  }
}

4.CharDemo（char案例）

object CharDemo {
  def main(args: Array[String]): Unit = {
    var char1: Char = 97
    //当我们输出一个char类型是，他会输出该数字对应的字符(码值表 unicode)//unicode 码值表包括ascii
    println("char1=" + char1) // a

    //char 可以当做数字进行运行
    var char2: Char = 'a'
    var num = 10 + char2
    println("num=" + num) // 107

    //原因和分析
    //1. 当把一个计算的结果赋值一个变量，则编译器会进行类型转换及判断（即会看范围+类型）
    //2. 当把一个字面量赋值一个变量，则编译器会进行范围的判定
//    var c2: Char = 'a' + 1
//    var c3: Char = 97 + 1
//    var c4: Char = 98

  }
}

5.UnitNullNothingDemo（UnitNullNothing三者案例）

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

    val res = sayHello()
    println("res=" + res)

    //Null类只有一个实例对象，null，类似于Java中的null引用。null可以赋值给任意引用类型(AnyRef)，但是不能赋值给值类型(AnyVal: 比如 Int, Float, Char, Boolean, Long, Double, Byte, Short)
    val dog: Dog = null
    //错误
//    val char1: Char = null
//    println("ok~~~")

  }
  //Unit等价于java的void,只有一个实例值()
  def sayHello(): Unit = {

  }


}

class Dog {

}

17.3 iden（标识符）

object IdenDemo01 {
  def main(args: Array[String]): Unit = {
    //首字符为操作符(比如+ - * / )，后续字符也需跟操作符 ,至少一个
    val ++ = "hello,world!"
    println(++)

    val -+*/ = 90 //ok
    println("res=" + -+*/)

    //看看编译器怎么处理这个问题
    // ++  => $plus$plus

    //val +q = "abc" //error

    //用反引号`....`包括的任意字符串，即使是关键字(39个)也可以

    var `true` = "hello,scala!"
    println("内容=" + `true`)

    val Int = 90.45
    println("Int=" + Int)

    //不能使用_ 做标识符
//    var _ = "jack"
//    println(_)


  }
}