Scala之高阶函数
嵌套函数两层嵌套三层嵌套形参是函数，返回是函数
函数柯里化模式匹配样例类隐式参数
嵌套函数
两层嵌套
需求：输入一个字符串，判断这个字符串的长度跟5的大小分别输出两个数不同的结果
object Test1
{
def main
(args
: Array
[String]): Unit = {
def fun
(s
:String):(Int,Int)=>Int={
def suanfa
(a
:Int,b
:Int):Int={
if(s
.length
>5)a
+b
else if(s
.length
==5) a
-b
else a
*b
}
suanfa
}
println
(fun
("hahahf")(5,3))
}
}
三层嵌套
需求：输入一个数判断与3求余的关系，若等于零则输入两个数求和再判断和与4000的大小最后输入一个人名输出一句话，反之输入两个数求差判断与1000的大小再输入一个人名输出一句话。
object Test2
{
def main
(args
: Array
[String]): Unit = {
def fun
(num
:Int):(Int,Int)=>String=>Unit={
if(num
%3==0){
def fun2
(a
:Int,b
:Int):String=>Unit={
if(a
+b
>4000){
def fun3
(s
:String):Unit={
println
(s
+"恭喜你收入多多")
}
fun3
}else{
def fun3
(s
:String):Unit={
println
(s
+"还需多多努力呀")
}
fun3
}
}
fun2
}else{
def fun2
(a
:Int,b
:Int):String=>Unit={
if(a
-b
>1000){
def fun3
(s
:String):Unit={
println
(s
+"你真是勤俭持家！！！")
}
fun3
}else{
def fun3
(s
:String):Unit={
println
(s
+"要省着点用哦")
}
fun3
}
}
fun2
}
}
fun
(2)(5000,3000)("马甲")
object Test2
{
def main
(args
: Array
[String]): Unit = {
def fun1
(num
: Int): (Int, Int) => String => Unit = {
def fun2
(a
: Int, b
: Int): String => Unit = {
def fun3
(str
: String): Unit = {
if (num
% 3 == 0) {
if (a
+ b
> 3000) println
(str
+ "大于3000")
else println
(str
+ "小于3000")
}
else {
if (a
- b
> 1000) println
(str
+ "大于1000")
else println
(str
+ "小于1000")
}
}
fun3
}
fun2
}
fun1
(6)(5000,3000)("zhu")
}
}
形参是函数，返回是函数
**需求：**输入参数是函数和String值，判断这个值与3求余的关系并输出一个加减函数
object Test3
{
def main
(args
: Array
[String]): Unit = {
def fun
(f
:String=>Int,str
:String):(Int,Int)=>Int={
val num
=f
(str
)
if(num
%3==0){
def fun1
(a
:Int,b
:Int):Int={
a
+b
}
fun1
}else{
_
-_
}
}
println
(fun
((x
:String)=>{
if(x
.length
>5) 6
else 1
}
,"hahah")(3,3))
}
}
函数柯里化
柯里化是指这样一个函数，他接收函数A作为参数，运行后能够返回一个新的函数。并且这个新的函数能够处理函数A的剩余参数。
object Test4
{
def main
(args
: Array
[String]): Unit = {
def fun
(a
:Int,b
:Int,c
:Int,d
:Int):Int={
a
+b
+c
+d
}
def fun1
(a
:Int,b
:Int,c
:Int)(d
:Int):Int={
a
+b
+c
+d
}
def fun2
(a
:Int,b
:Int)(c
:Int,d
:Int):Int={
a
+b
+c
+d
}
def fun3
(a
:Int)(b
:Int)(c
:Int)(d
:Int):Int={
a
+b
+c
+d
}
def fun4
(a
:Int)(b
:Int,c
:Int,d
:Int):Int={
a
+b
+c
+d
}
println
(fun
(1,2,3,4))
println
(fun1
(1,2,3)(4))
println
(fun2
(1,2)(3,4))
println
(fun3
(1)(2)(3)(4))
}
}
模式匹配
需求：输入一个数字转成对应英文和判断输入的类型
object demoMatch
{
def method1
(x
:Int):String={
if(x
==1) "one"
else if(x
==2) "two"
else "many"
}
def match1
(x
:Int):String=x
match{
case 1=>"one"
case 2=>"two"
case _
=>"many"
}
def match2
(x
:Any):Unit=x
match{
case 1=>println
("输入的值为"+x
)
case x
:Int=>println
("输入的值为Int类型，值为："+x
)
case x
:String=>println
("输入的值为String类型，值为："+x
)
case x
:Double=>println
("输入的值为Double类型，值为："+x
)
case _
=>println
("我也不知道是啥")
}
def main
(args
: Array
[String]): Unit = {
println
(method1
(3))
println
(match1
(4))
match2
('a')
}
}
样例类
定义样例类需要放在main方法外甚至object单例对象外，不要放在main方法里。因为样例类需要放在方法的作用域之外(即Java的成员变量位置之外)。def main(args:Array[String]):Unit里面就是其方法的作用域。
首先需要case class 定义一个对象，含有属性和类型。
然后输入参数类型即为这个对象，本身就是一个类
然后运用模式匹配解决问题
对于样例类，只要值相同就是同一个对象，所以==和.equals是一样的
Scala中在class关键字前加上case关键字 这个类就成为了样例类，样例类和普通类区别：
不需要new可以直接生成对象默认实现序列化接口默认自动覆盖 toString()、equals()、hashCode()
object demoCaseClass
{
case class Student
(name
: String, age
: Int)
def match1
(studnet
: Student
): Unit = studnet
match {
case Student
("Zhu", 22) => println
("Hello," + studnet
.name
)
case Student
("Tang", 21) => println
("Welcome," + studnet
.name
)
case stu
: Student
=> println
("您的名字为：" + stu
.name
)
}
def main
(args
: Array
[String]): Unit = {
val stu1
=Student
("zhu",22)
match1
(stu1
)
val stu2
=Student
("Zhu",22)
if(stu1
.equals
(stu2
)) println
("是同一个学生")
else println
("不是哦")
if(stu1
==stu2
) println
("真的是一个人")
else println
("要我怎么说你才信他们是双胞胎")
}
}
隐式参数
隐式参数需要定义在object内，不能定义在纯类中。且同一个类型只能有一个隐式参数只能放在最后一个函数存在多个隐式函数的话，把它们放在一起，前面只有一个implicit优先级：传参 >隐式参数 >默认给隐式参数一个默认值目的是为了防止调用时既没有传参也没有定义隐式参数或失效而引起的找不到值的错误。
object demoImplicit
{
def main
(args
: Array
[String]): Unit = {
def fun1
(a
:Int,b
:Int)(c
:Int):Int={
a
+b
+c
}
implicit var a
:Int=10
implicit var str
:String="hello"
def fun2
(a
:Int,b
:Int)(implicit c
:Int=5):Int={
a
+b
+c
}
def fun3
(a
:Int,b
:Int)(implicit c
:Int=5,str
:String):Int={
println
(str
)
a
+b
+c
}
println
("fun3结果为："+fun3
(30,20))
println
("fun3结果为："+fun3
(30,30)(20,"heheda"))
println
("fun1结果"+fun1
(10,10)(20))
println
("fun2结果"+fun2
(10,10)(20))
println
("fun2接果"+fun2
(10,10)())
println
("fun2结果"+fun2
(10,10))
}
}
