知识点:

1. 数据类型
2. 声明变量
3. 算术操作符
4. 块表达式
5. if表达式
6. 循环
7. lazy
8. 异常

---

import scala.collection.immutable

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

    /*
    数据类型:
    Scala和Java一样，有7种数值类型
    Byte、Char、Short、Int、Long、Float和Double（无包装类型）和一个Boolean类型
    与java不同的是,scala不刻意区分基本类型和引用类型,其数据类型都是类
    在scala中是不需要包装类型的,在基本类型和包装类型之间的转换是scala编译器的工作
     */
    val res1:Range.Inclusive = 1.to(10)  //int值1首先被转化成RichInt, 然后再调用 to() 方法
    val res2: Int = 9.9.toInt  //scala不需要像java一样强制类型转换,调用的是方法


    /*
    声明变量:
    1. 使用val定义的变量值是不可变的,相当于java里final修饰的变量,使用var定义的变量是可变的
    2. 在scala中,鼓励使用val定义变量,因为多数变量的值不需要改变
    3. 使用lazy定义变量后,只有在调用该变量时才会实例化这个变量的值,而且惰性变量只能是不可变变量
    4. 在scala中,系统会自动推断数据类型,不需要强制给出变量值的数据类型
    5. 可以同时声明多个变量值
     */
    val a = 1
    val b:Int = 2
    var c = 3
    lazy val d:String = "lazy"
    val e:String = null
    val (arr1,arr2) = ("a","b")


    /*
    算术操作符:
    scala中的算术操作符本质上就是方法,只不过是方法的简写罢了
    a + b   是   a.+(b)  的简写, 其中 + 是方法名称
     */
    1.+(2)  //简写为  1+2
    1.+=(1)  //就是java中的   1++
    "abc" toUpperCase  //方法的简写,并且如果方法中不需要传递参数,可以将()省略


    /*
    块表达式:
    在scala中,{ }块包含一系列表达式,块最后一个表达式的值就是块的值
    所以,块表达式就是经过一系列步骤计算后给出的一个值,这个值也可以是Unit
    注: 1. Unit类型等同于java中的void, 这个类型只有一个值, 写作()
        2. 每个表达式都会返回一个值, 比如赋值表达式 val a = 1 的返回值是 Unit类型,为 (), () 表示 无用值 的占位符, 就是 "无值" 的值;
     */
    val block1:Int = { println("我是块表达式的处理过程"); 1 + 2 }
    val block2:Unit = { val setValue = "赋值操作的返回值是Unit类型" }



    /*
    条件表达式:
    在scala中,条件语句是将多个{}块表达式组合起来的控制结构,所以if/else 表达式是有值的, 本质上就是块表达式是有值的;
    语法结构:   if (判断条件) {逻辑语句} else {逻辑语句}
     */
    val judge1:Int = if(0==0)1 else 2
    val judge2:Any = if(0==0) "a"  else 1  //所有数据类型的超类为 Any 类型
    val judge3:Unit = if(0==0) 1  //为了解决没有else的if语句, 在scala中引入 Unit 类型,写作 () ;不带else的 if 语句等同于: if (0==0) 1 else ()
    val judge4:Unit = if(0==0) 1 else ()


    /*
    循环:
    scala拥有与java相同的 while和do 循环,但是for 循环做了改变
    scala中没有提供break或continue关键字来控制循环,在scala中可以考虑使用Boolean变量来达到相同的目的
     */
    var flag = 11
    while ( flag > 0 ){
      println(s"while循环和java的写法相同 ${flag}")
    }
    for ( i <- 0 to flag if i%2 == 0){
      println(s"for循环的写法是<-,并且提供if守卫 ${i}")
    }
    val ints: immutable.IndexedSeq[Int] = for (j <- 0 to flag if j%2 == 0) yield j
    //如果for循环体以yield开始,则循环会构造出包含所有结果集的集合
    val loopFlag = 5
    for( i <- 0 to 10 if true){
      if (loopFlag > i){
        println("for循环的守卫和loopFlag变量都可以控制 循环的运行")
      }
    }

    /*
    lazy:
    当val被声明为lazy时, 此对象的初始化会被延迟创建,直到首次使用此对象时才被创建,被使用;
    懒值对于开销较大的初始化语句来说, 是有必要的;
    懒值并不是非没有额外开销,我们每次访问懒值时,都会一个方法被调用,而这个方法将会以线程安全的方式检查该值是否被初始化;
     */
    lazy val name = "我是一个开销较大的对象, 尽量使用lazy"


    /*
    异常:
    scala的异常和java的工作机制一样,通过try-catch的方式处理异常,如果不能恢复程序,则程序退出;
    不过,scala不需要声明函数或方式时可能会抛出的异常,所以scala的异常处理代码看起来更加的简洁;
     */
    try{
      println("try块 是程序正常执行的区域")
      1/0
    }catch {
      case ex:IOException => println("变量ex 就是 io异常对象")
      case _:Exception => println("程序一旦出错, 在catch区域进行修正")
    }finally {
      println("不论有没有发生异常, finally块 的代码都会执行, 用于释放资源")
    }

  }
}