【scala】 scala 条件控制 和异常处理(二)

1.scala 变量定义 ,var val 区别。

var 定义可变变量

val 定义不可变变量，scala 推荐使用。相当于Java的final 变量.

scala中包含的基本数据类型详情如下表所示：

序号	基本类型	增强类型	大小	取值范围
1	Byte	RichByte	8-bit	-128 ~ 127
2	Char	RichChar	16-bit	0 ~ 65535
3	Short	RichShort	16-bit	-32768 ~ 32767
4	Int	RichInt	32-bit	-2^31 ~ 2^31 -1
5	Long	RichLong	64-bit	-2^63 ~ 2^63 -1
6	Float	RichFloat	32-bit
7	Double	RichDoube	64-bit

2.scala 条件控制 if else if  else 

3. for 增强和 yield类型推导

  to  ,until 遍历集合的区别

4.scala 异常处理

try catch {case ex: Exception=> e}finally{}

5. 可变参数方法定义  

参数类型*  *定义多个参数

6. def 方法定义的注意

def  方法名(参数)：返回值={方法体}

返回值省略，默认 Any ，Any相当于java中的Object

object Control {

  def main(args:Array[String]): Unit ={
    val a=5
    // scala 尽量不用return,最后一个表达式的值 作为值返回
    val b = if(a<7){val c=a+1;c+3} else if (a==5) 5 else 3
    println(b)
    //数组初始化
    val c:Array[String]=Array("a","b","d")
    //变量定义, 变量名:变量类型
    val d:String = forAry(c)
    println(d)
    //求和
    val result= sum(23,32,32,32,32)
    println(" sum result :"+result)
    // 将整个区间作为参数序列来处理 :_*
    val newResult = sum(1 to 10:_*)
    println("sum newResult: "+newResult)
    //数组格式化输出 toBuffer
    println(yieldAry().toBuffer)
    println("--------------------")
    filter()
    //异常
    exception()
  }

  /**
    * 遍历数组
    * @param ary
    * @return
    */
  def forAry(ary:Array[String]):String={
       val newBuilder=new StringBuilder
      // to 是 i到 区间，包含开始和结尾
       for(i<-10 to ary.length-1){
         newBuilder.append(ary.apply(i))
       }
    // unit 是 0 到 length-1 之间
     for(i<-0 until ary.length){
      newBuilder.append(ary.apply(i))
    }

    //普通遍历
    for(a<-ary) println( a)
     newBuilder.toString()
  }

  /**
    * yield 关键字 推导生成新的数组
    * @return  Array[Int]
    */
  def yieldAry():Array[Int]={
     val ary :Array[Int]= Array(1,32,3,31,43)
       //until  从 0 到 ary.length-1 之间的下标
     for(i<-0 until ary.length){
        val d:Int=ary.apply(i)
        val e= d.*(122);
       // println(e)
     }
     //yield 类型推导为Array
     for(arg<-ary) yield arg *2

  }

  /**
    * 可变长参数定义 *
    * @param args
    * @return
    */
  def sum(args:Int*):Long={
    var result : Long=0
    //for 循环遍历
    for(arg<-args){
      result += arg
    }
    return result
  }

  /**
    * 数组过滤
     */
  def filter(): Unit ={
    //定義一個數組
    val ary =Array(12,2,12,43,2,12,1)
      //去重 过滤
    //保留符合条件的元素 _.%(2)==0 保留偶数,
    // map(_*2) 是各个元素乘以 2
    val a = ary.distinct.filter(_.%(2)==0).map(_*2)
    println(a.toBuffer)
    println(a.sum)//元素求和
  }

  /**
    * 异常处理
    */
  def exception():Unit={
    //定义一个定长的数组
    val ary = new Array[String](2)
    ary(0)="1234e"
    var it = -2
    try{
       it = ary(0).toInt
    }
   catch {
     case ex: FileNotFoundException => it = 0
     case ex: NumberFormatException => it = 12
     case ex:Exception => it = -3
   }finally {
      println(it)
    }
  }



}