scala之十种函数高级应用

函数高级应用

主要包含10种函数高级应用，
包括 
1) 函数传名调用
2) 指定函数参数名调用
3) 可变参数的函数
4) 默认参数值函数
5) 递归函数
6) 高阶函数
7) 内嵌函数
8) 匿名函数
9) 偏应用函数
10) 函数柯里化

1. 函数传名调用
   o概念说明
   传值调用：先计算参数表达式的值，再应用到函数内部，把=>去掉即可，即按原始的方式
   传名调用：将未计算的参数表达式直接应用到函数内部，用=>来设置传名调用
   应用示例-传值

   object TestCallByValue {
     def main(args: Array[String]) {
       delayedCalculator(transmitMe());
     }
     def transmitMe(): String = {
       println("我在transmitMe方法中!")
       return "transmitMe返回值";
     }
     def delayedCalculator(t: String): Unit = {
       println("在 delayedCalculator方法--开始")
       println("正式调用传过来的函数： " + t)
       println("在 delayedCalculator方法--结束")
     }
   }
   

   应用示例-传名

   object TestCallByName {
     def main(args: Array[String]) {
       delayedCalculator(transmitMe());
     }
     def transmitMe(): String = {
       println("我在transmitMe方法中!")
       return "transmitMe返回值";
     }
     def delayedCalculator(t: => String): Unit = {
       println("在 delayedCalculator方法--开始")
       println("正式调用传过来的函数： " + t)
       println("在 delayedCalculator方法--结束")
     }
   }
   

   2)指定函数参数名调用

   object TestCallByParaName {
   	  def main(args: Array[String]) {
   	    printBabyNames(second = "张二", first = "张一");
   	  }
   	  def printBabyNames(first: String, second: String): Unit = {
   	    println("第一个孩子叫=" + first);
   	    println("第二个孩子叫=" + second);
   	  }
   	}
   

   3)可变(不定长)参数的函数

   object TestNonFixParas {
   	  def main(args: Array[String]) {
   	    printAllParasValue("one", "two", "three", "four");
   	  }
   	  def printAllParasValue(paras: String*): Unit = {
   	    for (temp <- paras) {
   	      println(temp);
   	    }
   	  }
   	}
   

   4)默认参数值函数

   object TestDefaultParaFunction {
   	  def main(args: Array[String]) {
   	    println("完全使用默认值的返回值 : " + salaryMoney());
   	    println("部分使用默认值的返回值 : " + salaryMoney(10));
   	    println("部分使用默认值的返回值 : " + salaryMoney(10,10000));
   	  }
   	  def salaryMoney(a: Int = 5, unit: Int = 1000): Int = {
   	    return a * unit
   	  }
   	}
   

   5)递归函数

   object TestRecusive {
   	  def main(args: Array[String]) {
   	    var n=4
   	    println(n+"的阶乘为="+myFactorial(n))
   	  }
   	  def myFactorial(n: Int): Int = {
   	    if (n <= 1)
   	      return 1
   	    else
   	      return n * myFactorial(n - 1)
   	  }
   	}
   

   6)高阶函数
   o概念说明
   第一种：将一个函数当做另外一个函数的参数，即参数为函数的函数
   第二种：返回值是函数的函数，即高阶函数可以产生函数
   o应用示例
   参数为函数的函数

   object TestHighFunctionByTransmitFunctionPara {
     def main(args: Array[String]) {
       delayedCalculator(transmitMe());
     }
     def transmitMe(): String = {
       println("我在transmitMe方法中!")
       return "transmitMe返回值";
     }
     def delayedCalculator(t: => String): Unit = {
       println("在 delayedCalculator方法--开始")
       println("正式调用传过来的函数： " + t)
       println("在 delayedCalculator方法--结束")
     }
   }
   

   返回值是函数的函数

   object TestHighFunctionByRetFunction {
     def main(args: Array[String]) {
       var mySalaryFun=multiplyBy(1000);
       println(mySalaryFun(10));
     }
     def multiplyBy(salaryUnit:Int)=(x:Int)=>salaryUnit*x
   }
   

   7)内嵌函数
   o概念介绍
   函数内定义函数，定义在函数内的函数称之为局部函数，亦称内嵌函数
   o应用示例

   object TestEmbedFunction {
     def main(args: Array[String]) {
       var msg="HelloWorld";
       printMessage(msg);
     }
     def printMessage(msg: String): Unit = {
       def printMessageInner(msg: String): Unit = {
         println(msg);
       }
       printMessageInner(msg);
     }
   }
   

   8)匿名函数
   o概念介绍
   没有函数名称的函数
   使代码更简洁，用=>来表示，左侧是参数列表，右侧是函数体
   o应用示例
   匿名用法（使值自增+1的函数实现）

   函数定义：
   var inc = (x:Int) => x+1
   函数使用：
   var x = inc(8)+1
   

   正常写法（使值自增+1的函数实现）

   正常定义：
   def incFunction(x: Int): Int = {
       return x + 1;
   }
   函数使用：
   var x=incFunction(8)+1
   

   9)偏应用函数
   o概念说明
   不需要提供函数需要的所有参数，只需要提供部分，或不提供所需参数
   实现方法：绑定函数的一部分参数，非绑定部分用"_"代替，从而形成偏应用函数去使用
   o应用示例:
   传统方法实现（向某人问好）

   import java.util.Date
   object TestPartialParasFunction {
     def main(args: Array[String]) {
       val name="张三"
       sayHello(name, "上午好")
       Thread.sleep(1000)
       sayHello(name, "中午好")
       Thread.sleep(1000)
       sayHello(name, "晚上好")
     }
     def sayHello(name: String, message: String) = {
       println(name + "----" + message)
     }
   }
   

   偏应用函数实现（向某人问好）

   def main(args: Array[String]) {
       val name="张三"
       val partialSay=sayHello(name,_:String);
       partialSay("上午好")
       Thread.sleep(1000)
       partialSay("中午好")
       Thread.sleep(1000)
       partialSay("晚上好")
     }
     def sayHello(name: String, message: String) = {
       println(name + "----" + message)
     }
   

   10. 函数柯里化
       o概念说明
       将原来接受两个参数的函数变成新的接受一个参数的函数的过程。新的函数返回一个以原有第二个参数为参数的函数。
       提高了使用方法的灵活性
       o应用举例
       传统实现add方法定义:

       def add(x: Int, y: Int) = x + y;
       

       传统实现add方法使用

       def main(args: Array[String]) {
           println(add(3,4));
         }
       def add(x: Int, y: Int) = x + y;
       

       柯里化实现add方法定义

       def add(x:Int)(y:Int) = x + y
       

       柯里化实现add方法使用

       object TestCurryingFunction {
         def main(args: Array[String]) {
           //对应柯里化形式1的使用
           var curryingAdd1 = add1(3)
           //对应柯里化形式2的使用
           var curryingAdd2 = add2(3)(_)
          
           println(curryingAdd1(4));
           println(curryingAdd1(4));
         }
         //柯里化形式1
         def add1(x: Int) = (y: Int) => x + y;
         //柯里化形式2
         def add2(x: Int)(y: Int) = x + y;
       }