2. Scala变量

时间 2019-12-07

标签 scala 变量栏目 Scala 繁體版

原文原文链接

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

举一个简单的例子java

object boke_demo01 {

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

    var a: Int = 10 //定义一个整型变量,取名 a,并赋初值 10
    var b: Int = 12 //定义一个整型变量,取名 b,并赋初值 12
    b = 9 //给变量b 赋 9
    println("a=" + a) //输出语句,把变量 a 的值输出
    println("b=" + b) //把变量 b 的值输出

  }

}

2.2 变量的介绍

　　2.2.1 概念

变量至关于内存中一个数据存储空间的表示，能够把变量看做是一个房间的门牌号，经过门牌号咱们能够找到对应的房间，而经过变量名能够访问到变量(值)。编程

　　2.2.2 变量使用的基本步骤

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

2) 使用ide

2.3 Scala变量的基本使用

　　2.3.1 快速入门

object boke_demo01 {

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

    var age: Int = 9
    var sal: Double = 9.9
    var name: String = "Jack"
    var ifPass: Boolean = true
    //在scala中，小数默认为Double ,整数默认为Int
    var score: Float = 22.9f
    println(s"${age} ${ifPass}")

  }

}

示意图函数式编程

2.4 Scala变量使用说明

　　2.4.1 变量声明基本语法

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

　　2.4.2 注意事项

1) 声明变量时，类型能够省略(编译器自动推导，即类型推导)this

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

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

4) val修饰的变量在编译后，等同于加上finalcode

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

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

2.5 程序中+号的使用

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

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

2.6 数据类型

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

2) Scala数据类型分为两大类 AnyVal(值类型)和AnyRef(引用类型)，注意不论是AnyVal仍是AnyRef都是对象

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

　　2.6.1 Scala数据类型体系

　　对上面图的小结和整理

1) 在Scala中有一个根类型Any，它是全部类的父类

2) Scala中一切皆为对象，分为两大类 AnyVal(值类型)和AnyRef(引用类型)，它们都是Any的子类

3) Null类型是Scala的特别类型，它只有一个值null，它是bottom class，是全部AnyRef类型的子类

4) Nothing类型也是bottom class，它是全部类的子类，在开发中一般能够将Nothing类型的值返回给任意变量或者函数，这里抛出异常使用不少

object boke_demo01 {

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

    println(sayHello)

  }

  /*好比开发中,咱们有一个方法,就会异常中断,这时就能够返回Nothing
    即当咱们Nothing作返回值,就是明确说明该方法没有没有正常返回值*/
  def sayHello: Nothing = {
    throw new Exception("抛出异常")
  }

}

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

    var num_one = 1.7 //默认为 double
    var num_two = 1.9f //这是 float
    //num_two = num_one ,error ,修改 num_two = num_one.toFloat

　　2.6.2 Scala数据类型列表

2.7 整数类型

　　2.7.1 基本介绍

Scala的整数类型就是用于存放整数值的，好比 9，22，123等等

　　2.7.2 整型的类型

　　2.7.3 整型的使用细节

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

2) Scala的整型常量/字面量默认为Int类型，声明Long类型常量/字面量时，须后加“l”或者“L”

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

4) 案例

object boke_demo01 {

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

    println("Long的最大值:" + Long.MaxValue + "~" + Long.MinValue)
    var a = 10 //a Int
    var b = 10l //b Long
    var c = 9223372036854775807l //说 9223372036854775807 超过 Int
    
  }

}

2.8 浮点类型

　　2.8.1 基本介绍

Scala的浮点类型能够表示一个小数，好比 9.9f，22.9，0.6等等

　　2.8.2 浮点类型的分类

　　2.8.3 浮点类型使用细节

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

2) Scala的浮点类型常量默认为Double类型，声明Float类型常量时，须后加“f”或者“F”

object boke_demo01 {

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

    var num1:Float = 1.2345678912f
    var num2:Double = 1.2345678912
    println("num1=" + num1 + "\n" +"num2=" + num2)
    /*
    运行结果：
    num1=1.2345679
    num2=1.2345678912
    */

  }

}

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

十进制数形式：如5.21，521.0f，.521等 (必须有小数点)

科学计数法形式：如5.21e2 ＝ 5.21 乘以10的2次方，5.21E-2 ＝ 5.21 除以10的2次方

4) 一般状况下，应该使用Double类型，由于它比Float类型更精确(小数点后大体7位)

2.9 字符类型(Char)

　　2.9.1 基本介绍

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

　　2.9.2 案例演示

object boke_demo01 {

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

    var char1: Char = 99
    //当咱们输出一个char类型是，它会输出该数字对应的字符(码值表 unicode)//unicode 码值表包括ascii
    println("char1=" + char1) // c

    //char能够当作数字进行运行
    var char2: Char = 'c'
    var num = 10 + char2
    println("num=" + num) // 109

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

}

　　2.9.3 字符类型使用细节

　　　　　　1) 字符常量是使用单引号( ' ' )括起来的单个字符，例如：var a1 = 'a', var a2 = '张', var a3 = '20'

　　　　　　2) Scala也容许使用转义字符 '\' 来将其后的字符转变为特殊字符型常量，例如：var a4 = '\n' ('\n'表示换行符)

　　　　　　3) 能够直接给Char赋一个整数，而后输出时，会按照对应的Unicode字符输出

　　　　　　4) Char类型是能够进行运算的，至关于一个整数，由于它都对应有Unicode码

2.10 布尔类型(Boolean)

　　2.10.1 基本介绍

布尔类型也叫Boolean类型，Boolean类型数据只容许取值true或false，布尔类型占一个字节

布尔类型适用于逻辑运算，通常用于程序流程控制 [后面详解]

2.11 Unit类型、Null类型和Nothing类型

　　2.11.1 基本说明

　　2.11.2 使用细节案例

　　　　　　1) Unit类型用来标识过程，也就没有明确返回值的函数。因而可知，Unit相似于Java里的void。Unit直邮一个实例，()，这个实例也没有实质的意义

　　　　　　2) Null类只有一个实例对象，null，相似于Java中null的引用。null能够赋值给任意引用类型(AnyRef)，可是不能赋值给值类型(AnyVal，好比：Int，Float，Char， Boolean，Long，Double，Byte，Short)

　　　　　　3) Nothing，能够做为没有正常返回值的方法的返回类型，很是直观的告诉你这个方法不会正常返回，并且因为Nothing是其它任意类型的子类，它还能跟要求返回值的方法兼容

　　　　　　4) 代码案例

object boke_demo01 {

  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 {

  }

}

2.12 值类型转换

　　2.12.1 值类型隐式转换

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

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

　　　　　　自动类型转换细节说明

　　　　　　　　1) 有多种类型的数据混合运算时，系统首先自动将全部数据转换成容量最大的那种数据类型，而后再进行计算 (6.7+10 ＝》double)

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

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

　　　　　　　　4) byte，short，char它们三者能够计算，在计算时首先转换为int类型

　　　　　　　　5) 自动提高原则：表达式结果的类型自动提高为操做数中最大的类型

6) 案例演示

object boke_demo01 {

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

    var n1 = 12
    var n2 = 1.2f

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

    //(byte, short) 和 char 之间不会自动的转换类型
    var n4: Byte = 9
    //var char1 : Char = n4 // 错误，由于byte 不能自动转换char

  }

}

　　2.12.2 高级隐式转换和隐式函数

　　　　　　Scala还提供了很是强大的隐式转换机制(隐式函数，隐式类等等)，后面详解

　　2.12.3 强制类型转换

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

强制类型转换细节说明

　　　　　　 1) 当进行数据的从大到小，就须要强制类型转换

　　　　　　 2) 强转符号只针对于最近的操做数有效，每每会使用小括号提高优先级

　　　　　　 3) Char类型能够保存Int的常量值，但不能保存Int的变量值，须要强转

　　　　　　 4) Byte和Short类型在进行运算时，看成Int类型处理

　　　　　　案例演示

object boke_demo01 {

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

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

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

  }

}

2.14 值类型和String类型的转换

　　2.14.1 介绍

　　　　　　在程序开发中，咱们常常须要将基本数据类型转成String类型，或者将String类型转成基本数据类型

　　2.14.2 基本数据类型转String类型

　　　　　　语法：将基本类型的值+""便可

案例演示：

object boke_demo01 {

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

    val a1 = 19.6
    //基本数据类型转string
    val s1 = a1 + "" //之后看到有下划线,就表示编译器作了转换

  }

}

　　2.14.3 String类型转基本数据类型

　　　　　　语法：经过基本数据类型的String的toXxx方法便可

案例演示：

object boke_demo01 {

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

    //String类型转基本数据类型
    val s2 = "23"
    val num1 = s2.toInt
    val num2 = s2.toByte
    val num3 = s2.toDouble
    val num4 = s2.toLong

  }

}

　　2.14.3 注意事项和细节

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

　　　　　　2) 思考就是要把"5.21"转成Int //？

　　　　　　案例演示：

object boke_demo01 {

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

    //在scala中，不是将小数点后的数据进行截取，而是会抛出异常
    val s1 = "5.21"
    println(s1.toInt) // error
    println(s1.toDouble) //  ok

  }

}

2.15 标识符的命名规范

　　2.15.1 标识符概念

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

　　　　　　2) 凡是本身能够起名字的地方都叫标识符

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

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

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

　　　　　　3) 数字不能够开头

　　　　　　4) 首字符为操做符(好比=-*/)，后续字符也须要跟操做符，至少一个

　　　　　　5) 操做符(好比=-*/)不能在标识符中间和最后

　　　　　　6) 用反引号'....'包括的任意字符，即便是关键字(39个)也能够

object boke_demo01 {

  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 = 99.78
    println("Int=" + Int)

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

}

　　2.15.3 标识符举例说明

hello //true
hello12  //true
1hello  //error
h-b  //error
x h  //error
h_4  //true
_ab  //true
Int  //true 在Scala中，Int不是关键字，而是预约义标识符，能够用，可是不推荐
Float  //true
_  //error 不能够，由于在Scala中，_有不少其它的做用，所以不能使用
Abc  //true
+*-  //true
+a  //error

　　2.15.4 标识符命名注意事项

　　　　　　1) 包名：尽可能采起有意义的包名，简短，有意义

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

　　2.15.5 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