Scala的方法的定义

定义方法

定义方法的基本格式是：       

def 方法名称（参数列表）：返回值类型 = 方法体   

参数传递

  //定义我的第一给方法
    def myFirstMethod():Unit= {
        println("hello world")
    }

多参数列表的方法:

def calculate(a: Int,b:Int):Int= a+b
def calculate(a: Int,b:Int,c:Int):Int= a+b+c

定义方法不写等号

//此时不会通过右侧方法的结果，来自动的推导返回值类型  隐式加了  Unit =
def myTest() {
        println("我的scala方法")
    }

scala写参数的默认值

/**
     *定义方法时候，scala允许某写参数是有默认值的，在调用时可以不进行设置
     * @param x 计算的参数x
     * @param y 计算的参数y
     * @param z 计算的参数在，是一个默认值的参数
     */
    def calculate(x:Int,y:Int,z:Int=10):Int ={
        println(s"x=$x,y=$y,z=$z")
        x+y+z
    }

    println(calculate(10, 20,20))

//有默认值的参数，在进行方法调用时按顺序赋值，看起来x默认值没有意义
    def calculate2(x:Int =5,y:Int,z:Int=10):Int ={
        println(s"x=$x,y=$y,z=$z")
        x+y+z
    }

//带名参数
        println(calculate2(y = 20))

scala方法的递归

//递归斐波那契数列
    def getFebonacci(index:Int):Int = {
        if (index == 1 || index==2){
            return 1
        }
        getFebonacci(index - 1 )+getFebonacci(index - 2)
    }

scala方法的不定长度参数

//不定长度参数
    def getSum(number:Int*):Int={
        var sum = 0
        for (n <- number){
            sum += n
        }
        sum
    }

    println(getSum(1, 2,3, 4, 5, 6, 7, 8, 9))

 //拓展
        /*在java中，变长参数可以直接传递一个参数。但是scala不允许的*/
        val array = Array(1,2,3,4,5,6,7,8,9)
        //_* 展开数组
        println(getSum(array:_*))

按值传递：参数是被传递到方法中时，已经求出具体值了  上面的就是

 Scala的方法按名传递、

def doVeryThing(a: =>Unit): Unit ={
    a   //最后输出为2
}

doVeryThing{   //相当里面的所有赋值给a
    val c = 2
        if (c == 2){
        println(c)
        }
}

按名传递：

//按名传递：call-by-name
def square(x: =>Int): Int = { //注意x:后的空格
    println(x)    //计算1+2
    x * x         //计算(1+2)*(1+2)
}
square({1+2})   //调用时不计算