标签:print cto with 语法 new cal string 类型 覆盖
阶乘
package com.ronnie.scala.function
object RecursiveDemo {
/**
* 阶乘
* @param num
* @return
*/
def factorial(num :Int):Int = {
if (0 == num){
0
}else if (1 == num){
1
} else {
num * factorial(num - 1)
}
}
/**
* 斐波那契数列求和
* @param num
* @return
*/
def fibonacciSum(num :Int):Int = {
if (0 == num){
0
} else if (1 == num){
1
} else if (2 == num) {
1
} else {
num + fibonacciSum(num - 1)
}
}
def main(args: Array[String]): Unit = {
println(factorial(3))
println(fibonacciSum(3))
}
}
默认值的函数中,如果传入的参数个数与函数定义相同,则传入的数值会覆盖默认值
如果不想覆盖默认值,传入的参数个数小于定义的函数的参数,则需要指定参数名称。
/**
* 包含默认参数值的函数
* 注意:
* 1.默认值的函数中,如果传入的参数个数与函数定义相同,则传入的数值会覆盖默认值
* 2.如果不想覆盖默认值,传入的参数个数小于定义的函数的参数,则需要指定参数名称
*/
def fun3(a : Int = 0, b : Int) = {
println(a + b)
}
fun3(b=1)
/**
* 可变参数个数的函数
* 注意:多个参数逗号分开
*/
def fun4(elements : Int*)={
var sum = 0;
for (elem <- elements){
sum += elem
}
sum
}
println(fun4(1,2,3,4,5,6))
可以将匿名函数返回给 val 定义的值
匿名函数不能显式声明函数的返回类型
/**
* 匿名函数
* 1.有参数匿名函数
* 2.无参数匿名函数
* 3.有返回值的匿名函数
* 注意:
* 可以将匿名函数返回给定义的一个变量
*/
// 有参匿名函数
val v1 = (a : Int) => {
println(a)
}
v1(1)
// 无参数匿名函数
val v2 = () =>{
println("This is just a simple test.")
}
v2()
// 有返回值的匿名函数
val v3 = (a:Int, b:Int) =>{
a - b
}
println(v3(7,4))
}
def fun5(num: Int)={
def fun6(a:Int, b:Int):Int={
if (a % 16384 == 1){
b
} else {
fun6(a - 1, a % b)
}
}
fun6(num, 3)
}
println(fun5(39327))
}
是一种表达式, 不需要提供函数需要的所有参数, 只需要提供部分, 或不提供所需函数
/**
* 偏应用函数
*/
def log(date : Date, s : String) = {
println("date is " + date + ",log is " + s)
}
val date = new Date()
log(date, "log01")
log(date, "log02")
log(date, "log03")
// 要调用log, 以上变化的是第二个参数, 可以用偏应用函数处理
val logWithDate = log(date,_:String)
logWithDate("log011")
logWithDate("log022")
logWithDate("log033")
package com.ronnie.scala.function
object HighOrderFunction {
def f(x1 :Int, x2: Int, y1: Int, y2: Int): Int = {
if (x1 == x2){
-10086
}
(y1 - y2) / (x1 - x2)
}
// 函数的参数是函数
def hof01(f: (Int,Int,Int,Int) => Int, a:Int = -1) :Int = {
f(3, 1, 4, 7) + a
}
// 函数的返回时函数
def hof02(a : Int, b : Int) : (Int, Int) => Int = {
def f2 (c : Int, d : Int): Int = {
if (d == c){
-10086
} else {
(b - a) / (d - c)
}
}
f2
}
// 函数的参数是函数, 函数的返回时函数
def hof03(f: (Int, Int, Int, Int) => Int) : (Int, Int, Int, Int) => Int = {
f
}
def main(args: Array[String]): Unit = {
println(hof01(f))
println(hof02(-4, 3)(7, 7))
println(hof02(-4, 3)(7, 1))
println(hof03((a, b, c, d) => {(b - a)/(d - c)})(-4, 3, 7, 1))
// 括号中带括号不支持 println(hof03((_-_)/(_-_))(-4, 3, 7, 1))
println(curring(-4, 3)(8, 8))
println(curring(-4, 3)(8, 1))
}
// 函数柯里化
def curring(a : Int, b : Int)(c : Int, d : Int) = {
if (c == d){
-10086
} else {
(b - a)/(d - c)
}
}
标签:print cto with 语法 new cal string 类型 覆盖
原文地址:https://www.cnblogs.com/ronnieyuan/p/11704978.html