第五章 函数与方法学习总结

第五章

1、方法定义

1.1标准定义

//标准定义：有返回值、有参数类型
def add5(x:Int,y:Int):Int={
  x+y
}

1.2简化定义

//只有一行可以进行简化
def add1(x:Int,y:Int):Int = x+y

//scala自动识别返回值类型
def add2(x:Int,y:Int) =x+y

//如果方法体内有return，必须将指定方法的返回类型
def add3(x:Int,y:Int): Int = {
  if(y==100) return 100
  x+y
}

//如果方法不需要参数，参数列表可以省略
def printHello1 = println("hello")

//如果方法不需要返回值，可以省略=或者{}，但是两个不能同时没有
def printHello2: Unit ={
  println("123")
}

1.3方法的参数

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

//1、带名参数，调用方法往方法内传参
add(y = 10, x = 100)

//2、默认传值，这样就不用往方法传参
def add1(x:Int=100,y:Int=20)={
  x+y
}

//2、默认传参的传参一定要写到最后，否则调用方法，第一个参数和默认传参冲突
def add2(x:Int,y:Int=20)={
  x+y
}

//3、可变形参,在x和y之后，可以传进来任意数量的参数
// 可变参数必须放在参数列表的最后面
// 可变参数不能与默认值参数一起使用
// 可变参数不能直接传递数组/集合,如果想要将数组/集合的元素传递给可变参数,必须通过 数组名:_* 的方式传递
def add3(x:Int,y:Int,z:Double*)={
  x+y+z.sum //这个就是x+y+传进来任意参数，调用sum方法进行求和
}
println(add3(1, 2, 34, 55.1,22.7))

1.4传参定义的方法

//4、小案例，获取如下的地址数组
// /user/hive/warehouse/user_log/2022-05-30
// /user/hive/warehouse/user_log/2022-05-29
// /user/hive/warehouse/user_log/2022-05-28
// /user/hive/warehouse/user_log/2022-05-27
// /user/hive/warehouse/user_log/2022-05-26
// /user/hive/warehouse/user_log/2022-05-25
// /user/hive/warehouse/user_log/2022-05-24

// 统计当前时间，前面7天用户注册数
// 方法的
def getPath (pathPrefix:String,n:Int)={

  //1、获取当前时间
  val currentDate = LocalDate.now()
  //2、通过当前时间，算出前七天的日期
  for(i <- 1 to n) yield {
    //日期减法
    val DateTime =currentDate.plusDays(-i)
    //格式化日期
    val timeString = DateTime.format(DateTimeFormatter.ofPattern("yyyy-MM-dd"))

    s"${pathPrefix}/${timeString}"
  }

}

2、函数

2.1函数定义（函数是对象，同一个作用域内不能出现同名变量）

//函数的本体
//左边是引用，右边是创建对象，类似于java的接口，匿名实现类
  val add2 = new Function2[Int,Int,Int] {
    override 
    def apply(v1: Int, v2: Int) = v1+v2
  }
	//引用调用方法
	add2.apply(1,2)

	//将add2的引用赋值给func，func也指向了add2方法
	val func = add2
	func.apply(1,2)

  	//自己写第一个函数
  	val add = (x:Int,y:Int) => {
    	x+y
  	}

2.2函数与方法的关系

2.2.1重载（ 方法存储在方法区中,函数是对象保存在堆中）

object $05_function_method_relationship {
  //在main方法中定义方法
  def main(args: Array[String]): Unit = {
    //方法如果定义在方法中,其实就是函数,函数之间不能同名，此时不可以重载
    def m1 (a: Int) = a+1
    //def m1 (a: Int) = a+1
  }
  //方法如果定义在class/object中可以重载
  def m1 (a: Int) = a+1
  def m1 (a: Int,b:Int) = a+1
}

2.2.2方法转换为函数（在方法内部才能实现）

def main(args: Array[String]): Unit = {
  //方法可以手动转成函数, 使用 方法名 _ 转换
  val m2_to_func = m2 _
  println(m1_to_func(1,9))
}

def m2 (a: Int,b:Int) = a+b

3、高阶函数：以函数作为参数/返回值的方法或者函数，称之为高阶函数

3.1高阶函数的本体

//高阶函数本体
def add( x:Int ,y:Int , func: (Int,Int)=>Int ) = {
  func(x,y)
}

def sayHello(msg:String, func: (String)=>Unit ) = {
    func(msg)
  }

3.2高阶函数的用法

//高阶函数本体
def add( x:Int ,y:Int , func: (Int,Int)=>Int ) = {
  func(x,y)
}

//1、原始用法--最好理解的
val func = (x:Int,y:Int) => x+y
println(add(10, 20, func))

//2、直接传进去一个函数
println(add(10, 20, (x:Int,y:Int) => x+y ))

//3、省略参数类型
println(add(10, 20, (x,y) => x+y ))

3.3高阶函数String相关（字符串获取变量值用这个，s"$a///${b}"）

   val func2 = (x:String) => println(s"say:${x}")
    say("123123",func2) //say:123123

    val func3 = (a:String,b:Int) => s"${a}///${b}"
    println(say2("我是str", 1, func3)) //我是str///1


  def say(a:String,func:(String)=>Unit)= {func(a)}
  def say2(a:String,b:Int,func:(String,Int)=>String) = {func(a,b)}

3.4匿名函数

def main(args: Array[String]): Unit = {
  
  //直接传入函数值，没有函数名
  println(add2(10,20,(x:Int,y:Int)=>x*y))
  
  def add2(a:Int,b:Int,func2:(Int,Int)=>Int) = {func2(a,b)}
}

4、柯里化（有多个参数列表的方法）

def sum(x:Int,y:Int)(z:Int)(a:Int):Int = x+y+z+a
println(sum2(10, 20)(30)(40))

5、闭包函数

def main(args: Array[String]): Unit = {

  val y = 10

  //TODO 闭包函数【函数体中使用了外部变量y】
  val func = (x:Int) => {
    x + y
  }
}

6、方法递归

def main(args: Array[String]): Unit = {


  //计算阶乘5！
  def m1(a:Long):Long={
    if (a==1){
      1
    }else{
      a * m1(a-1)
     }
  }

  println(m1(5))


}