scal的函数定义（day01）

函数定义、函数作为参数、函数调用：

  //定义函数
  /*def 是函数，sum是函数名，a是变量，b是变量，返回值Int*/
  def sun(a:Int,b:Int):Int={return a+b}
  //函数的写法，提前返回值的时候可以用return
  def abs(a:Int,b:Int):Int={
    if(a>b){
      return a;
    }
    return -a;
  }
  //函数写法,直接返回，省略函数返回值
  def sum(a:Int,b:Int)={a+b}
  //函数写法,省略return和函数返回值
  def max(a:Int,b:Int)={
    if(a>b){
      a
    }else{
      b
    }
  }
  //求阶乘的列子,函数少了一个花括号{}
  def fac(n:Int):Int=if(n==0) 1 else n * fac(n-1)

  //
  def str(a:Int,b:Int) = a+b

  def ss(a:Int)(b:Int) = a+b

  //函数的执行体我们还没有想好，也可以定义,空的执行体，抽象方法
  def htt(a:Int,b:Int) = ???
  //（返回一个Nothing）
  def htt1(a:Int,b:Int):Int = ???
  //返回提是一个Int

  //参数列表
  def dg(a:Int)(b:Int,c:Int)=a+b+c

  //其他情况
  //Uint表示没有值，相当于java里面的void
  def process(a:Int):Unit={
      println(a)
  }
  //另外一种,省略掉Unit表示没有返回值
  def pres(a:Int){
     println(a)
  }
  //无参数的函数，相当于普通变量
  def start()={2}
  //去掉（），相当于定义一个普通变量
  def startt={2}
  //在定义一下
  def starttt={
  println("this is start")
  2
  }

匿名函数：

//函数的另外一种表达
  def constr(callback: (Int) => Uint) {
    var i=0;
    while(i<5){
      callbakc(i)
      Thread.sleep(1000)
      i+=1;
    }
  }
  def timeFile(i:Int): Unit ={
    println("kaishi"+i)
  }

第一种方法：
def main(args:Array[String]):Unit= {
constr（timeFile）
}

第二种方法：
def main(args:Array[String]):Unit= {
val d=(i:Int)=>{
    println("dudu"+i)
}
    constr(d);
}
第三种方法：（匿名函数）
def constr((i:Int)=>{
     println("dudu"+i)
})

第四种方法：
val g=timeFile _;
//告诉编译器我们传递的事函数本身，不是函数执行的结果（_）
constr(g);

嵌套函数：

//嵌套函数定义
  def sumDouble(n:Int):Int={
    def dbl(v:Int) =2 * n
    if(n>0){
      dbl(n)+sumDouble(n-1)
    }else{
      0
    }
  }

调用：
def main(args:Array[String]):Unit= {
sumDouble(2)
}