Scala基础语法：方法与函数详解-------（3）

最新推荐文章于 2022-03-04 18:37:18 发布

西安人走哪都要吃泡馍

最新推荐文章于 2022-03-04 18:37:18 发布

阅读量575

点赞数

分类专栏： Scala 文章标签： scala 大数据

本文链接：https://blog.youkuaiyun.com/data_curd/article/details/105810085

版权

Scala 专栏收录该内容

6 篇文章

订阅专栏

本文详细介绍了Scala中方法的定义与使用，包括方法的格式、注意事项和参数变种。同时，探讨了函数的定义，强调了函数作为对象的特性，可以作为参数传递，并解释了如何将方法转化为函数。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

方法的定义和使用

格式

def 方法名(参数1:类型,参数2:类型...):返回类型 ={
	方法体
	}

注意事项

一定要识别关键字眼 def

如果方法体只有一行，其中**{}**可以省去不写

方法的返回类型可以不写，Scala编译器可以自动推导

递归方法除外，必须定义返回类型

//实现两个整数的相加

[root@node01 ~]# scala  //启动Scala
Welcome to Scala 2.11.8 (Java HotSpot(TM) 64-Bit Server VM, Java 1.8.0_65).
Type in expressions for evaluation. Or try :help.

scala> def aa(x:Int,y:Int):Int = {X+Y}     //定义方法时，要注意参数大小写一致性
<console>:11: error: not found: value X
       def aa(x:Int,y:Int):Int = {X+Y}
                                  ^
<console>:11: error: not found: value Y
       def aa(x:Int,y:Int):Int = {X+Y}
                                    ^

scala> def aa(x:Int,y:Int):Int = {x+y}   //正确写法
aa: (x: Int, y: Int)Int

scala> def aa(x:Int,y:Int)=x+y         //只有一行代码，可以省略{}，一般方法可以不用定义返回类型
aa: (x: Int, y: Int)Int

scala> aa(9,"aaaa")           //在使用方法时，要注意形参和实参的数据类型是否一致
<console>:13: error: type mismatch;
 found   : String("aaaa")
 required: Int
       aa(9,"aaaa")
            ^

scala> def aa(6,8)             // 使用方法时，不用写方法的关键字 def
<console>:1: error: identifier expected but integer literal found.
def aa(6,8)
       ^

scala> aa(6)                 //在使用方法时，要注意形参和实参的数据个数是否一致
<console>:13: error: not enough arguments for method aa: (x: Int, y: Int)Int.
Unspecified value parameter y.
       aa(6)
         ^

scala> aa(6,8)         //正确用法
res1: Int = 14

scala> aa(6,8,9)        //在使用方法时，要注意形参和实参的数据个数是否一致
<console>:13: error: too many arguments for method aa: (x: Int, y: Int)Int
       aa(6,8,9)
         ^

//实现一个正数的阶乘
scala> def bb(x:Int)={        
     | if(x<1) 1 else
     | bb(x-1)*x}         //在递归方法中，一定要写方法的返回类型名
<console>:13: error: recursive method bb needs result type
       bb(x-1)*x}
       ^

scala> def bb(x:Int):Int={
     | if(x<1) 1 else 
     | bb(x-1)*x}          //在递归方法中，一定要写方法的返回类型名
bb: (x: Int)Int

scala> bb(5)              //递归方法的正确用法
res3: Int = 120

方法的参数变种：

scala> def cc(x:Int=2,y:Int=5)=x+y    //初始化两个参数的值
cc: (x: Int, y: Int)Int

scala> cc()                           //如果没有实参，则就计算两个形参的初始值
res5: Int = 7

scala> cc(66,11)                       //传递实参后，就可以按照方法计算两个实参的值
res6: Int = 77

scala> cc(x=3)                       //传递一个实参，则另一个按照形参的初始值计算
res7: Int = 8

scala> cc(y=99)                      //传递一个实参，则另一个按照形参的初始值计算
res8: Int = 101

scala> def dd(x:Int*)=x.sum           //变长参数，可变参数  用   *   表示，
dd: (x: Int*)Int                   //  此方法是，dd的参数不限个数，但一定要是int类型，求dd参数之和

scala> dd(1,2,3,4,5,6)             //dd方法的实例
res9: Int = 21

函数的定义和使用

语法：

(参数1:类型,参数2:类型...) => {函数体}  //这事一个么有，名字的参数，也称为：匿名函数

val/var 函数名 = (参数1:类型,参数2:类型...) => {函数体}   //  给函数命名

注意事项

识别函数表达式关键字眼 =>

函数的本质都是对象，每个函数都是 FunctionN的实例，N表示函数的参数的个数

scala> val a1=(x:Int,y:Int)=>x+y      //定义方法的一般形式
a1: (Int, Int) => Int = <function2>      // function 后面呢个N字想着看来就是函数参数的个数

scala> val b1=(x:Int) => x*8              
b1: Int => Int = <function1>            // function 后面呢个N字想着看来就是函数参数的个数

scala> a1.                               //用tab键，找出函数的一个方法，这个可以从侧面看函数就是对象
apply   curried   toString   tupled


scala> val c1=(x:Int,y:Int,c:Int,d:Int)=>x+y+c+d
c1: (Int, Int, Int, Int) => Int = <function4>     // function 后面呢个N字想着看来就是函数参数的个数

既然函数是对象，那就意味着函数可以当成参数传递给方法

scala> def n1(m:(Int,Int)=>Int)= {m(2,3)}
n1: (m: (Int, Int) => Int)Int

  //n1是一个方法
  //n1的输入参数有一个
  //n1的参数类型是函数类型
  //这函数类型是把两个参数的值定了，就是说接下来只需写函数的执行方式，比如是+-*/等，只要输入两个参数，返回一个参数即可

scala> val m1=(x:Int)=>x+100     
m1: Int => Int = <function1>

scala> val m2=(x:Int,y:Int)=>x*y
m2: (Int, Int) => Int = <function2>

scala> n1(m1)         //函数参数个数不够
<console>:14: error: type mismatch;
 found   : Int => Int
 required: (Int, Int) => Int
       n1(m1)
          ^

scala> n1(m2)       //正确使用
res11: Int = 6

scala> m1(x:Int,y:Int)=>x+y)    //方法名写错了
<console>:1: error: ';' expected but '=>' found.
m1(x:Int,y:Int)=>x+y)
               ^

scala> n1(x:Int,y:Int)=>x+y)    //少写一个圆括号
<console>:1: error: ';' expected but '=>' found.
n1(x:Int,y:Int)=>x+y)
               ^

scala> n1((x:Int,y:Int)=>x+y)   //正确使用
res12: Int = 5

scala> n1((x:Int,y:Int)=>x*y)   //正确使用
res13: Int = 6

scala> n1((x:Int,y:Int)=>x-y)   //正确使用
res14: Int = -1

scala> val a1=Array(10,20,30)
a1: Array[Int] = Array(10, 20, 30)

scala> val a2=(x:Int)=>x*10
a2: Int => Int = <function1>
           //map方法就是把函数当成参数，用这个函数作用于集合的每一个元素，返回构成一个新的集合
scala> val a3=a1.map(a2) 
a3: Array[Int] = Array(100, 200, 300)

scala> val a4=(x:Int)=>x-5
a4: Int => Int = <function1>

scala> val a5=a1.map(a4)
a5: Array[Int] = Array(5, 15, 25)

方法转化为函数

关键字眼：下划线 _

scala> def y1(k:(Int,Int)=>Int)=k(9,10)  //方法有一个函数式参数要求输入两个int，输出一个int的类型
y1: (k: (Int, Int) => Int)Int

scala> def y2(x:Int,y:Int)=x+y     //一个接受两个参数返回一个参数的方法
y2: (x: Int, y: Int)Int

scala> val k1=y2 _                  //通过下划线，把y2方法转化为一个函数
k1: (Int, Int) => Int = <function2>

scala> val k1=y2_                   //下划线要和方法名之间有一个空格
<console>:11: error: not found: value y2_
       val k1=y2_
              ^

scala> y1(k1)                           //转换成功后，直接把函数当成参数传递给方法
res18: Int = 19


        //二种 简便写法

scala> def aaa(k:(Int,Int)=>Int)=k(9,10)
aaa: (k: (Int, Int) => Int)Int

scala> def bbb(x:Int,y:Int)=x*y
bbb: (x: Int, y: Int)Int

scala> aaa(bbb)    //当参数类型相匹配，既可以直接转换
res19: Int = 90

scala> aaa(bbb_)     //方法名要和下划线之间有空格
<console>:13: error: not found: value bbb_
       aaa(bbb_)
           ^

scala> aaa(bbb _)  //这样也可以直接转变
res21: Int = 90

scala> aaa(bbb   _)  //方法名跟下划线有很多空格也可以，就是不太美观
res22: Int = 90