当前位置：网站首页>scala 10种函数高级应用

scala 10种函数高级应用

2022-08-10 14:46:00 【S_ng】

包括：
1) 函数传名调用
2) 指定函数参数名调用
3) 可变参数的函数
4) 默认参数值函数
5) 递归函数
6) 高阶函数
7) 内嵌函数
8) 匿名函数
9) 偏应用函数
10) 函数柯里化
1) 函数传名调用
o 概念说明
         传值调用：先计算参数表达式的值，再应用到函数内部，
        把=>去掉即可，即按原始的方式
         传名调用：将未计算的参数表达式直接应用到函数内部，
        用=>来设置传名调用
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 方法--结束") } }

o 应用示例-传名 
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 应用示例
参数为函数的函数 
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
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; }

原网站

版权声明
本文为[S_ng]所创，转载请带上原文链接，感谢
https://blog.csdn.net/weixin_52464817/article/details/126255546

边栏推荐

猜你喜欢

随机推荐