Scala（二）：变量_scala程序实现可移植性依靠的是什么-CSDN博客

本文链接：https://blog.csdn.net/weixin_44800710/article/details/123579094

本文详细介绍了Scala中的变量，包括变量的概念、使用步骤、声明语法及注意事项。讲解了Scala的变量类型，如Int、Char、Boolean等，并讨论了数据类型的转换、String与基本类型之间的转换，以及标识符的命名规范。此外，还提到了Scala的关键字和数据转换的示例。

摘要由CSDN通过智能技术生成

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(_)


  }
}