Scala基础入门2【方法与函数】

一、方法与函数

1. Scala的方法与函数的区别很小，方法是类的一部分，而函数在scala中是一个对象，可以赋值给一个或者多个变量。
2. 在Scala中用val语句定义函数，用def定义方法。

方法的定义与申明

方法的定义

方法的定义使用的是def关键字进行定义，使用：后面为返回值类型，使用=后面跟的是方法的主体
案例演示：

//小括号里面写的是传入的参数
def testMethod(i:Int):String={
    println("传入的数是："+i)
    var str=i+i+""
    return str
  }

方法的声明

如果你在抽象类中不写等于号和方法主体，那么方法将会被隐式声明为抽象方法。
案例演示：

abstract class TestClass{
  def Test01(i:Int):String
}

函数传名调用

• 传值调用：先计算参数表达式的值，再应用到函数内部
• 传名调用：将未计算的参数表达式直接应用到函数内部
  案例演示：

object MyFirst {
  def main(args: Array[String]): Unit = {
    test2(test1(1))
  }

  def test1(i:Int):Long={
    println("获取当前时间")
    var str=System.currentTimeMillis()
    return str
  }

  def test2(s: => Long)={
    println("当前在Test2方法中")
    println("传递的函数参数是："+ s)
    s
  }
}

这里用的是函数传名调用。test2中的s表示的就是test1函数。

指定函数参数名

函数在传参的时候可以用定义参数名的方式来传参，及时传过去的参数顺序不一致，只要有参数名就可以识别到。
案例演示：

object MyFirst {
  def main(args: Array[String]): Unit = {
    test1(b = 6,a = 8)
  }

  def test1(a:Int,b:Int)={
    println("指定参数名传参成功,两值相加为："+(a+b))
  }
}

可变参数

在传入参数是可能会存在不知道传入参数个数是多少的问题，这时定义参数就不太好定义，在java中我们用的是...代替后面要传入的参数，在scala中我们用的是*
案例演示：

object MyFirst {
  def main(args: Array[String]): Unit = {
    test("你好","scala","我是新手小白")
  }

  def test(str:String*)={
    for (elem <- str) {
      println(elem)
    }
  }
}

注：在相应类型后面添加*号，可以随便后面插入多少个同类型参数。当然括号中的str也会变成一个集合。

递归调用

递归调用就是函数自己调用自己，当然也要有一个出口，不能无限制循环调用。

object FunctionDemo {
  def main(args: Array[String]): Unit = {
    def maxValue(a: Int, b: Int): Int = if (a > b) a else b

    var value = maxValue(3, 6)
    println(value)

    def fun(i: Int): Int = if (i < 1) return 0 else if (i == 1) 1 else i * fun(i - 1)

    var result = fun(-1)
    println(fun(7))
  }
}

默认参数值

传参过程中也会有大小先后顺序
参数的先后顺序是第一选择是传递的参数，第二选择是隐式参数，最后一种选择就是参数默认值，在前两情况都没有的情况下第三种如果存在，参数就会选择第三种。
顺序：传递参数 > 隐式参数 > 参数默认值
案例演示：

object Test {
   def main(args: Array[String]) {
        println( "返回值 : " + addInt() );
   }
   def addInt( a:Int=5, b:Int=7 ) : Int = {
      var sum:Int = 0
      sum = a + b

      return sum
   }
}

高阶函数

高阶函数就是用函数去操作其他函数。

object Work01 {
  def main(args: Array[String]): Unit = {
    def f1(a:Int):(Int,Int)=>Int={
      def f2(b:Int,c:Int):Int={
        b*c
      }
      def f3(b:Int,c:Int):Int={
        b/c
      }
      if(a<=4){
        return f2
      }else{
        return f3
      }
    }
    var num:Int=f1(4)(4,6)
    var num1:Int=f1(5)(8,2)
    println(num)
    println(num1)
  }
}

注：这段代码表示传入的是整数类型，返回的是一个函数。

内嵌函数

内嵌函数又称为局部函数，就是在函数内部定义函数。
案例演示：

def outer()={
    def inner()={
      println("这是内嵌函数")
    }
  }

匿名函数（重点）

匿名函数是重点，他表示的意思顾名思义是这个函数可以没有名字。应用场景可能初学者会想不到，这有什么用呢？
在scala编程中一切皆对象，函数也是对象，那么作为对象就可以作为参数进行传递，在传参过程中，又该怎么定义函数呢，这时就需要匿名函数。
案例演示：

def main(args: Array[String]): Unit = {
    def fun10(a:Int,b:Int)(c:Int,d:Int):Int={
      a+b+c+d
    }
    implicit var tmp:Int = 100
    implicit var tmp1:String = "110"
    def fun12(a:Int)(b:Int)(c:Int)(d:Int)(implicit tmp:Int=100,tmp1:String):String={
      a+b+c+d+tmp+tmp1
    }
    def fun11(a:Int)(b:Int)(c:Int)(d:Int)(implicit tmp:Int):Int={
      a+b+c+d+tmp
    }
    var sum = fun12(1)(2)(3)(4)
    println(sum)
  }

函数柯里化

柯里化的是将原来接受两个参数的函数变成新的接受一个参数的函数的过程。新的函数返回一个以原有第二个参数为参数的函数。
案例演示：

//首先我们定义一个函数:
def add(x:Int,y:Int)=x+y

//再把这个函数变一下形：
def add(x:Int)(y:Int) = x + y