scala方法和函数

1 方法

定义方法
定义方法的关键字: def
定义方法的通用格式: def 方法名 (参数列表):方法返回值类型={方法体}
如果方法体中有多行代码， 则可以使用代码块的方式包裹多行代码， 代码块中最后一行的返回值就是整个方法的返回值。 与Java中不同， 不是使用return返回值的。
省略方法的返回值类型： scala会自动根据最后一行语句返回的值推断出方法的返回值类型 def m1(num:Int)={num*2}
定义没有返回值的方法
def m1(num:Int):Unit={print(num)}或def m1(num:Int){print(num)}

递归方法必须返回值的类型必须写明， 不能省略掉

带名参数

在调用函数时， 也可以不按照函数定义的参数顺序来传递参数， 而是使用带名参数的方式来传递。
sayHello(name = "xiaohong", sex = "nan", age = 12)
还可以混合使用未命名参数和带名参数， 但是未命名参数必须排在带名参数前面。
sayHello("xiaoming","nv",age = 12)

变长参数

在Scala中， 有时我们需要将方法定义为参数个数可变的形式， 则此时可以使用变长参数定义方法。
 

  //方法的返回值不需要return关键字，方法的最后一条语句的返回值作为整个方法的返回值
  //如果方法有返回值，那么最后一条语句的返回值类型要与方法定义的返回值类型保持一致
  def add(x: Int, y: Int): Int = {
    x + y
  }

  //可以省略方法的返回值类型，scala会自动根据最后一条语句的返回值类型推断出方法的返回值类型
  def add2(x: Int, y: Int) = {
    x + y
  }

  //如果方法没有返回值，可以使用Unit关键字，返回为“（）”，类似与java中的void
  def add3(x: Int, y: Int): Unit = {
    x + y
  }
  //方法没有返回值，参数列表后面直接加方法体，这种方法称为“过程”
  def add3_2(x: Int, y: Int) {
    x + y
  }

  //先定义方法的参数列表类型，具体的参数名称在方法体中
  def add4: (Int, Int, Int) => Int = {
    (x, y, z) =>
      {
        x + y + z
      }
  }
  //柯理化
  def add5(x: Int)(y: Int) = {
    x + y
  }
  def add6(x: Int) = (y: Int) => {
    x + y
  }

  //如果一个方法的参数列表为空，在调用该方法的时候，可以加括号，也可以不加
  def add7() {
    println("hello world")
  }
  //如果一个方法,没有参数列表，调用的时候，不能带括号
  def add8 {
    println("hello world")
  }

  //递归方法必须要写明方法的返回值类型，否则报错
  def add9(x: Int): Int = {
    if (x < 0) 0 else add9(x - 1)
  }

  //当参数个数不固定的时候，使用可变参数，可变参数要求在定义的时候，放在末尾
  def add10(name: String, num: Int*): Unit = {
    var sum = 0
    for (i <- num) {
      sum += i
    }
    println(name + ":" + sum)
  }

  //默认参数，在定义方法时，不希望给出具体的参数，而是使用方法自带的参数
  //方法参数的赋值是从左往右的，默认参数放在后面
  def add11(age: Int, sex: String, name: String = "lisi") = {
    println(name + ":" + age + "-" + sex)
  }

2 函数

在函数式编程中， 函数是头等公民， 函数可以像其他任意数据类型一样被传递和操作， 在官方并没有明确的给出二者的区别

定义函数

定义函数的关键字:val
定义函数的通用格式: val 函数名=(参数列表)=>{函数体}
*例如： val func=(x:Int,y:Int)=>{x+y}
scala方法转换成函数
在scala中方法可以转换成函数， 提供了两种方法进行转换
一种是： 下划线
一种是： scala自动隐式的转换

/**
?* 定义函数的关键字是：val
?* 函数的定义格式: val 函数名 = (参数列表)=>{函数体}
?* 不带函数名的函数，称为匿名函数
?*/    

//通用定义
    val f1 = (x: Int, y: Int) => {
      x + y
    }
    
    //先定义函数的参数列表类型，然后在函数体中定义参数
    val f2:(Int,Int,Int) => Int = {
      (x,y,z) => {
        x+y+z
      } 
    }
  

3 方法转换为函数

  def m1(x: Int, y: Int): Int = {
    x + y
  }

  //面向函数时编程，函数可以作为参数进行传递
  /**
   * m2方法传入三个函数
   * f 是一个函数，接收两个参数，返回值类型为Int，传入的该函数，参数必须符合函数的签名
   * x 普通参数
   * y 普通参数
   */
  def m2(f: (Int, Int) => Int, x: Int, y: Int) = {
    f(x, y)
  }

  def main(args: Array[String]): Unit = {
    //方法名 _
    val f1 = m1 _
    //    println(f1)
    //隐式转换
    val v2 = m2(m1, 1, 2)
    //    println(v2)
    val v2_1 = m2(f1, 1, 2)
    //    println(v2_1)
    
    
    val arr = Array(1,2,3,4,5)
    
    val f = (x:Int) => {
      println(x)
    }
//    arr.foreach(f)
//    arr.foreach((x:Int) => {println(x)})
//    arr.foreach((x:Int) => println(x))
//    arr.foreach(x => println(x))
    //函数左右两边都只有一个变量，可以使用“_”代替
//    arr.foreach(println(_))
    
//    arr.filter(x => x>3).foreach(y => println(y))
//    arr.filter(_>3).foreach(println(_))

  }