Scala教程(二)基础语法

 Scala教程(二)基础语法

1 定义函数

1.1 函数语法

   def max(x:Int,y:Int):Int= {
       if(x <y){
         return y;
        }
       return x;
   }

定义函数：def关键字

函数名：max

括号()：参数列表

:Int 表示返回结果

最外层的大括号{}：表示函数体

1.2 匿名函数

不需要给每一个函数命名，正如你不需要给每个数字命名一样。以下是一个匿名函数：

     //函数进行运算后进行返回
     def addA(x:Int) = x +100;   

     //将函数函数，运行的结果赋值到add常量
     valadd = (x:Int)=> x+200;     

     println("functionresult ==> "+addA(2));
     println("val result==>"+add(2)); 

运行结果：

   function result ==> 102

   val result ==>202

 

1.3 递归函数    

     // 递归调用
     def fac(n:Int) :Int = if(n <=0) 1 else n * fac(n-1);
     println(fac(5));

运行结果：120

1.4 函数默认参数 

   //默认参数
   defcombine(content:String,left:String="[",right:String="]")= left +    content +right;
   println("combine result ==>"+combine("Ilove Scala!")); 

输出结果：combine result ==>[I love Scala!]

1.5 传递多参数

    def connected(args : Int*) = {
    	var result = 0;
    	for(arg <-args){ 
      		result +=arg;
    	}
    	result;
    }
    println(connected(1,2,3,4,5));

1.6 lazy关键字

使用lazy修饰一个val成员时，其赋值情况是在需要时才赋值的(byneed)因为Scala中成员与方法是等价的（除了private[this]成员）

    def readFile() :Unit = {
          lazy val file =Source.fromFile("E:\\Scala.txt");
          println("==========scala=========");
          for(line <- file.getLines()){
    	      println(line);
          }
     }
     readFile();

 

如果文件不存在，赋值时不会报错，在需要执行时才会报错。

 

2 控制程序流程

2.1 if-else逻辑判断

if-else语句或许是控制程序流程最基本的形式。其中的else是可选的，所以可按下述两种形式来使用if：

def max(x:Int,y:Int):Int = {
        if(x < y){
          return y;
        }
        return x;
   }   

2.2 while循环

先判断条件括号()中条件，满足条件会重复执行，否则退出循环：   

  	def While() {
    	    var x = 100;
    	    var y = 298;
    	    while (x != 0) {
    		val temp = x;
	    	x = y % x;
      		y = temp;
    	    }
		y
        }

2.3 do-while循环

与while循环所不同的是，它先执行一次循环语句，然后再去判断：

    def doWhile(){
        // 定义变量 
        var line = "";
        do {
            println("doWhile：请输入信息，退出程序请输入：\"\"");
            line = readLine();
            println("输入的内容：" + line);
        } while(line != "");
    }

 

2.4 for循环

for循环是开界的，它的一般形式为： for(; <条件表达式>; )语句；初始化总是一个赋值语句,它用来给循环控制变量赋初值；条件表达式是一个关系表达式,它决定什么时候退出循环：

        def forx(){
      	    for(i <-1.to(10)){
                println("num is ="+i);
      	    }
        }

  输出结果：

      num is =1

      num is =2

      num is =3

      num is =4

      num is =5

     // for循环嵌套
     def doubleforx(){
            for(i<- 1.to(2);j<-1.to(2)){
                print((i*100+j)+" ");
            }
      }

      // for循环嵌套;加条件
      def doubleforx(){
            for(i<- 1.to(2);j<-1.to(2);if(i!=j)){
                print((i*100+j)+" ");
            }
      } 

3 异常处理

Scala的异常的工作像许多其他语言，如Java异常。而不是正常方式返回的值，方法可以通过抛出一个异常终止。然而，Scala实际上并没有检查异常。当要处理异常，那么可使用try{...}catch{...}块，就像在Java中除了catch块采用匹配识别和处理异常。

3.1 抛出异常

thrownew IllegalArgumentException

 

3.2 捕获异常

   Scala中try/catch在一个单独的块捕捉任何异常，然后使用case块进行模式匹配，如下所示：

  def exception(){
    try {
         val f = new FileReader("input.txt")
      } catch {
         case ex: FileNotFoundException =>{
            println("Missing file exception")
         }
         case ex: IOException => {
            println("IO Exception")
         }
      }
  }

当上述代码被编译和执行时，它产生了以下结果：

Missingfile exception 

这种try-catch表达的行为在其他语言处理异常是一样的。body是执行体，如果它抛出一个异常，每个catch子句都依次尝试捕获。

 

3.3 finally子句

   对于一些代码，可能会希望无论try块中的异常是否抛出，它们都能够得到执行。为了达到这个效果，可以在异常处理程序后面加上finally子句。   

  def finallyx(){
      try {
         val f = new FileReader("input.txt")
      } catch {
         case ex: FileNotFoundException => {
            println("Missing file exception")
         }
         case ex: IOException => {
            println("IO Exception")
         }
      } finally {
         println("Exiting finally...")
      }
  }

当上述代码被编译和执行时，它产生了以下结果：

Missingfile exception

Exitingfinally...

                                        --谢谢大家对我的关注。

                                                                                                                                                                                      ——厚积薄发(yuanxw)