Scala 流程空间，函数，异常处理

• 1，）首先留意一下下边的代码块，他是怎么运行的，貌似在c#中他是出错的，不应该出现这样的写法的，但在scala中侧不然：

 package com.dt.study
 
 /**
  * The package path is com.dt.study.
  * Created by tommy duan on 2015/11/16.
  */
 object HelloScala {
   var line = ""
   do {
     line = readLine()
     if (!line.isEmpty) println("Read line is:"+line)
   } while (line != "")
 
   def main(args: Array[String]): Unit = {
     println("Hello Scala!!!")
   }
 }

运行起来后，会等待输入文字，知道输入空位置，直接走入main函数。

• 2，）object 在scala中是一个对象，对象声明同类一样，是不需要public修饰的，默认就是public
• 3，）scala object对象内部的函数都是静态的：访问方式为 HelloScala.

HelloScalaClass

 package com.dt.study
 
 /**
  * The package path is com.dt.study.
  * Created by tommy duan on 2015/11/16.
  */
 class HelloScalaClass {
   def sayHello(line:String)={
     println(line)
   }
 }

HelloScalaObject

 package com.dt.study
 
 /**
  * The package path is com.dt.study.
  * Created by tommy duan on 2015/11/16.
  */
 object HelloScalaObject {
   var line=""
   def sayHello(line:String):Unit={
     println(line)
   }
 }

class 与 object调用

 package com.dt.study
 
 /**
  * The package path is com.dt.study.
  * Created by tommy duan on 2015/11/16.
  */
 object HelloScala {
   def main(args: Array[String]): Unit = {
     println("Hello Scala!!!")
 
     HelloScalaObject.sayHello("Hello scala object")
     var scalaCls=new HelloScalaClass();
     scalaCls.sayHello("Hello scala class")
   }
 }

同样object对象内部的属性对象也是静态的，且内部字段默认scala会给其实现get.set函数（但不考虑var类型，private类型）

• 4，）val 与var类型

 package com.dt.study
 
 /**
  * The package path is com.dt.study.
  * Created by tommy duan on 2015/11/16.
  */
 object HelloScala {
   def main(args: Array[String]): Unit = {
     println("Hello Scala!!!")
 
     var line=""
     line="hello"
     println(line)
 
     val lineVal="hello"
     println(lineVal)
     lineVal="test"
   }
 }

在idea编译器中17 lineVal="test" 会报错误，编译不通过。

原因，val是不可以变类型，一旦设置了值后，就不可以更改变量值；而var是可变变量，可以改变值。val像是java中被final修改的变量。

• scala类和对象中字段的隐藏get set函数实现

 package com.dt.study
 
 /**
  * The package path is com.dt.study.
  * Created by tommy duan on 2015/11/16.
  */
 object HelloScala {
   def main(args: Array[String]): Unit = {
     println("Hello Scala!!!")
 
     println(HelloScalaObject.line)
     HelloScalaObject.line="sss"
 
   }
 }

请留意：

11     println(HelloScalaObject.line)
12     HelloScalaObject.line="sss"

这两行代码，第11行代码隐含了几层含义：

1，）line是一个public变量；

2，）调用了HelloScalaObject对象的隐藏line var的get函数；

第12行除了上边1，）外还有一层含义：调用了HelloScalaObject对象的隐藏line var的set函数；

函数返回值问题

 package com.dtgroup.study
 
 object HelloStduy {
   def main(args: Array[String]): Unit = {
     println("Hello Scala")
 
     var files = (new java.io.File(".")).listFiles()
     for (file <- files) println(file)
 
     val filePath = "spark.txt"
     try {
       if (!filePath.isEmpty())
         throw new RuntimeException("An error thrown.")
     } catch {
       case e: Exception => println(e.getMessage())
     } finally {
 
     }
 
     println(returnWithSomething)
   }
 
   def returnWithSomething():String={
     var result=""
     var items=new Array[String]()
 
     for(i<-  to ) items(i)=i.toString    
 
     result=items.mkString(",")
     result
   }
 }

输出内容：

Hello Scala
.\.cache-main
.\.classpath
.\.project
.\.settings
.\bin
.\src
An error thrown.
0,1,2,3,4,5,6,7,8,9

我们先不看上边的结果为什么，单想象returnWithSomeThing这是个什么？

1，）它在scala中是一个函数，函数一般都是使用def来声明；

2，）在这里它是一个静态函数；

3，）它的返回值类型为String；

4，）该函数的最后一行默认就是返回值，这是规定，也是规范；

5，）def main(args: Array[String]): Unit ，它的返回值类型为Unit，在scala中Unit为空，表示不返回任何类型，同时这里的main函数也是可以不写返回Unit的，格式为：

def main(args: Array[String])={
   println("hello main")
}

6，）函数的调用，如果不需要参数可以省略掉();

7，）try{}catch{}finally{} catch中的处理可以使用case来区分不同的错误信息，针对不同的错误类型做出不同的日志记录等处理；

8，）def main(args: Array[String]): Unit中，参数是一个字符数组，参数个的格式就是这样传递的；

9，）参数传递支持多个参数，同时也支持多个参数返回。

传递多参数，返回多参数示例：

package com.dtgroup.study
 
object HelloStduy {
  def main(args: Array[String]): Unit = {
    println("Hello Scala")
    var result0 = returnWithSomething("", )
    println(result0._1)
    //    for (item <- result0._2) println(item)
    println(result0._2.mkString(","))
    var result1 = returnWithSomething("mmmmm", )
 
    println(result1._1)
    //    for(item <- result1._2) println(item)
    println(result1._2.mkString(","))
  }
 
  def returnWithSomething(arg0: String, arg1: Int*): (Int, Array[String]) = {
    var result0 =
    var result1 = new Array[String]()
 
    for (i <-  to ) result1(i) = (i + ).toString()
 
    try {
      result0 = arg0.toInt
    } catch {
      case e: Exception => {
        result0 =
        println("Fail convert to int")
      }
    } finally {
 
    }
 
    (result0, result1)
  }
}

输出结果：

Hello Scala
1111
1,2,3,4,5,6,7,8,9,10,11
Fail convert to int
2
1,2,3,4,5,6,7,8,9,10,11