Scala编程学习之二-变量

2.1变量的介绍
2.1.1概念

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

2.1.2变量使用的基本步骤
1)声明/定义变量 (scala要求变量声明时初始化)
2)使用

2.2Scala变量使用说明
2.2.1变量声明基本语法
var | val 变量名 [: 变量类型] = 变量值

2.2.2注意事项
1)声明变量时，类型可以省略（就是叫 类型推断）
2)类型确定后，就不能修改，说明Scala 是强数据类型语言.
3)在声明/定义一个变量时，可以使用var 或者 val 来修饰， var 修饰的变量可改变，val 修饰的变量不可改 [案例].(推荐使用val,线程安全，使用效率高)

object VarDemo01 {
def main(args: Array[String]): Unit = {
    var name: String = "smith"
    var age: Int = 10
    var gender: Char = '男'
    var isPass: Boolean = true
    var sal: Float = 8907.4f
    var num1 = 100 //就使用到了类型推断
    //在idea 中，直接可以通过工具看到变量的类型
    //类型确定后，就不能修改，说明Scala 是强数据类型语言
    //num1 = "jack"
//在声明/定义一个变量时，可以使用var 或者 val 来修饰， var 修饰的变量可改变，val 修饰的变量不可改
  //因为val 是线程安全的，因此效率高，scala推荐使用
   //即能够使用val ,就不要使用var
  //var 是可以变的。
    var lover = "小红"
    lover = "小黑"
    //val 是不可变的变量
    val girlFriend = "小白"
 //girlFriend = "小黄"
    }
}

4)val修饰的变量在编译后，等同于加上final， 
	通过反编译看下底层代码。
	
object VarDemo02 {
  //  private String name;
  //  private final String lover;

  var name = "jack" //正常
  val lover = "小红" //在底层是final
  def main(args: Array[String]): Unit = {
    println("ok")
  }
}

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

   object VarDemo03 {
   def main(args: Array[String]): Unit = {
   //创建一个对象
   //1. dog 是val 修饰的，即dog 是不可变，即dog的应用不可变
   //2. 但是 dog.name是 var 他的属性可变

        val dog = new Dog
        //dog = null [error]
        dog.name = "大黄狗"
    
        var dog2 = new Dog
    
        dog2 = null
        dog2.name = "小黄瓜"
    
        //变量声明时，需要初始值（显示初始化）。
    
        var job: String = "大数据工程师"
    
      }
    }
    
    class Dog {
      var name = "tom" //初始化 name 为tom
    }
   

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

2.3数据类型
2.3.1scala数据类型介绍

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

  object DataTypeDemo01 {
      def main(args: Array[String]): Unit = {
     //在scala中，一切皆为对象 ，比如(Int,Float,Char....)
        var num1:Int = 10
        println(num1.toString)
        println(100.toFloat)
        var sex = '男'
        println(sex.toString)
        }
        }

2)Scala数据类型分为两大类 AnyVal(值类型) 和 AnyRef(引用类型)， 注意：不管是AnyVal还是AnyRef 都是对象。[案例演示 Int , Char]
案例代码:
var num1 : Int = 10
println(“num1” + num1)
var char1 : Char = ‘a’
println("char1的code= " + char1.toInt

scala的数据类型一览图

对上面的数据类型的关系图的说明
1)Any是所有类的根类型,即所有类的父类(基类)
2)在scala中类分为两个大的类型分支(AnyVal [值类型，即可以理解成就是java的基本数据类型], AnyRef类型)
3)在AnyVal 虽然叫值类型，但是仍然是类(对象)
4)在scala中有两个特别的类型(Null ), 还有一个是Nothing
5)Null 类型只有一个实例 null, 他是bottom class ,是AnyRef的子类.
6)Nothing 类型是所有类的子类， 它的价值是在于因为它是所有类的子类，就可以将Nothing类型的对象返回给任意的变量或者方法，比如案例
def f1():Nothing= { //表示f1方法就是没有正常的返回值，专门用于返回异常
throw new Exception(“异常发生”)
}
7)在scala中仍然遵守 低精度的数据自动的转成 高精度的数据类型。
8)在scala中，Unit 类型比较特殊，这个类型也只有一个实例 ()

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

2.3.2scala数据类型列表

2.4整数类型

2.4.1整型的使用细节

1)Scala各整数类型有固定的表数范围和字段长度，不受具体OS的影响，以保证Scala程序的可移植性。
2)Scala的整型 常量/字面量 默认为 Int 型，声明Long型 常量/字面量 须后加‘l’’或‘L’ [反编译看]
3)Scala程序中变量常声明为Int型，除非不足以表示大数，才使用Long

2.5浮点类型
2.5.1基本介绍
Scala的浮点类型可以表示一个小数，比如 123.4f，7.8 ，0.12等等
2.5.2浮点型的分类

2.5.3浮点型使用细节
1)与整数类型类似，Scala 浮点类型也有固定的表数范围和字段长度，不受具体OS的影响。
Scala的浮点型常量默认为Double型，声明Float型常量，须后加‘f’或‘F’。

3)浮点型常量有两种表示形式
十进制数形式：如：5.12 512.0f .512 (必须有小数点）
科学计数法形式:如：5.12e2 => 5.12 乘以 10的2次方 5.12E-2 =》 表示5.12 除以 10的2次方
4) 通常情况下，应该使用Double型，因为它比Float型更精确(小数点后大致7位)
//测试数据 ：2.2345678912f , 2.2345678912 // 2.7 与 8.1/3 //符指尾

**2.6字符类型(Char)**

1)字符常量是用单引号(‘ ’)括起来的单个字符。例如：var c1 = 'a‘ var c2 = ‘中‘ var c3 = ‘9’
2) Scala 也允许使用转义字符‘\’来将其后的字符转变为特殊字符型常量。例如：var c3 = ‘\n’ // ‘\n’表示换行符
3)可以直接给Char赋一个整数，然后输出时，会按照对应的unicode 字符输出 [’\u0061’ 97]
4) Char类型是可以进行运算的，相当于一个整数，因为它都对应有Unicode码.

2.7布尔类型：Boolean
2.7.1基本介绍

布尔类型也叫Boolean类型，Booolean类型数据只允许取值true和false
boolean类型占1个字节。
boolean 类型适于逻辑运算，一般用于程序流程控制[后面详解]：

if条件控制语句；
while循环控制语句；
do-while循环控制语句；
for循环控制语句
2.8Unit类型、Null类型和Nothing类型
2.8.1基本介绍

2.8.2注意事项和细节说明
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是其他任意类型的子类，他还能跟要求返回值的方法兼容。

2.9值类型转换
2.9.1值类型隐式转换

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

自动类型转换细节说明
1)有多种类型的数据混合运算时，系统首先自动将所有数据转换成容量最大的那种数据类型，然后再进行计算。
2)当我们把精度(容量)大 的数据类型赋值给精度(容量)小 的数据类型时，就会报错，反之就会进行自动类型转换。
3)(byte, short) 和 char之间不会相互自动转换。
4)byte，short，char 他们三者可以计算，在计算时首先转换为Int类型。
5)自动提升原则： 表达式结果的类型自动提升为 操作数中最大的类型

2.9.2强制类型转换
介绍
自动类型转换的逆过程，将容量大的数据类型转换为容量小的数据类型。使用时要加上强制转函数，但可能造成精度降低或溢出,格外要注意。
案例演示
java : int num = (int)2.5
scala : var num : Int = 2.7.toInt //灵活

object DataTypeTrans {
  def main(args: Array[String]): Unit = {
    val b: Byte = 10
    println(b.toInt)
    val d: Double = 1.123
    println(d.toByte)//潇洒  =》 潇傻 //Crm
  }
}

强制类型转换细节说明

1)当进行数据的 从 大——>小，就需要使用到强制转换,注意有精度的损失
2)强转符号只针对于最近的操作数有效，往往会使用小括号提升优先级
3)Char类型可以保存 Int的常量值，但不能保存Int的变量值，需要强转
4)Byte和Short类型在进行运算时，当做Int类型处理。

2.9.3值类型和String类型的转换

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

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

String类型转基本数据类型
语法：通过基本类型的String的 toXxx方法即可
案例演示：

注意事项

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

思考就是要把 “12.5” 转成 Int ? // 错误，在转换中，不会使用截取

2.9.4标识符的命名规范
标识符概念

Scala 对各种变量、方法、函数等命名时使用的字符序列称为标识符
凡是自己可以起名字的地方都叫标识符

标识符的命名规则(记住)
Scala中的标识符声明，基本和Java是一致的，但是细节上会有所变化。

首字符为字母，后续字符任意字母和数字，美元符号，可后接下划线_
数字不可以开头。
首字符为操作符(比如+ - * / )，后续字符也需跟操作符 ,至少一个(反编译)
操作符(比如±*/)不能在标识符中间和最后.
用反引号....包括的任意字符串，即使是关键字(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
_ // error ,因为在scala _ 有很多其他的作用。
Abc // ok
+*- // ok
+a // error

标识符命名注意事项

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

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

2.9.5Scala关键字
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