scala方法与函数

定义方法

定义函数

方法和函数的区别

scala的方法函数操作

 

1.9 方法与函数

1.9.1 定义方法

定义方法的基本格式是：

def 方法名称（参数列表）：返回值类型 = 方法体

def add(x: Int, y: Int): Int = x + y
println(add(1, 2)) // 3
//也可以定义成
//def add(x: Int, y: Int) = x + y
//或者
//def add(x: Int, y: Int){x + y} //省略“=”时始终返回Unit，一定要用大括号把方法体括起来

带有多参数列表的方法:

def addThenMultiply(x: Int, y: Int)(multiplier: Int): Int = (x + y) * multiplier
println(addThenMultiply(1, 2)(3)) // 9

无参方法：不包括参数列表

def add=System.getProperty("user.name")

空参方法：

def add()=System.getProperty("user.name")

空参方法可以作为最终表达式出现，实际上是方法调用，只不过Scala规定空参方法的调用可以省略()。但是无参方法不允许使用调用，建议当成普通变量使用()。示例如下：

scala> def name:String = System.getProperty("user.name")
name: String
​
scala> name             //当普通变量使用，但每次引用变量都会执行相应表达式
res0: String = liyadong
​
scala> name()           //非法访问
:9: error: not enough arguments for method apply: (index: Int)Char in class StringOps.
Unspecified value parameter index.
              name()
                  ^
​
scala> def name():String = System.getProperty("user.name")
name: ()String
​
scala> name             //空参方法调用可以省略()
res2: String = liyadong
​
scala> name()
res3: String = liyadong

方法体是多行语句的表达式：

def getSquareString(input: Double): String = {  
  val square = input * input  
  square.toString
}

方法定义小结：

# 1. 方法的返回值类型可以不写，编译器可以自动推断出来，但是对于递归函数，必须指定返回类型
# 2. 方法的返回值默认是方法体中最后一行表达式 的值，当然也可以用return来执行返回值，但不推荐这么做。
# 3. 若使用return来指定函数的返回值，scala的类型推断将会失效，要显式指定返回值类型。
# 4. 方法也可以没有返回值（返回值是Unit）省略=即可

package com.qianfeng.scala
​
/**
 * 方法
 */
object Demo05_Func {
  def main(args: Array[String]): Unit = {
    //定义方法
    def add(a:Int,b:Int):Int = a+b
    //调用方法
    println(add(10,20))
​
    //定义多个参数列表
    def addMultiple(a:Int,b:Int)(c:Int) = (a+b) * c
​
    //定义无参数
    def add1 = System.getProperty("user.name")
​
    //定义空参数
    def add2() = System.getProperty("user.name")
​
    //调用
    println(addMultiple(10,20)(30))
    println(add1)
    //println(add1()) //无参数方法不能使用()调用
    println(add2())
    println(add2)
​
    def add3(r:Double) = {
      val res = r*r
      println(res)
      res
    }
    println(add3(3))
​
    //可变参数
​
    //定义函数
    val f1 = (a:Int,b:Int) => a+b
    val f2 = (_:Int) + (_:Int)
​
    //匿名函数
    //(a:Int) => a*100
​
    //空参函数
    val username = () => System.getProperty("user.name")
​
    //调用
    println(f1)
    println(f1(10,20))
    println(username)
    println(username())
​
    //方法转换成函数
    val f11 = add _   //在方法名称后面加空格 _
    val f12 = add(_,_)
    println(f11)
    println(f12)
    println(f11(10,20))
    println(f12(10,20))
  }
}

​

1.9.2 定义函数

函数可以看做是带有参数的表达式。其本质是一个完整的对象，Scala 中的函数其实就是继承了Function（Trait） 的类的对象。

函数定义的基本语法：

val 变量 = (函数参数列表)=>函数体

函数的定义方式：

val f1 = ((a: Int, b: Int) => a + b)
val f2 = (a: Int, b: Int) => a + b
val f3 = (_: Int) + (_: Int)
val f4: (Int, Int) => Int = (_ + _)

匿名函数：

(x: Int) => x + 1
var inc = (x:Int) => x+100
//变量inc现在是一种可以像函数那样使用的函数
var x = inc(7)-1
​
//还可以如下定义具有多个参数的函数：
var mul = (x: Int, y: Int) => x*y
​
//变量mul现在是可以像函数那样使用的函数 
println(mul(3, 4))
​
//也可以定义不带参数的函数
var userDir = () => { System.getProperty("user.dir") }
​
//变量userDir现在是可以像函数那样使用的函数 
println( userDir )

空参函数：

val getTheAnswer = () => 42
println(getTheAnswer()) // 42

1.9.3 方法和函数的区别

# 方法不能做为最终表达式出现，而函数可以
# 方法名是方法调用，而函数名只是代表函数对象本身
# 方法可以转换为函数，所以一般也不必严格区分
- 自动转换：在需要函数的地方，如果传递一个方法，Scala能够自动把方法转换为函数
- 手动转换

两种方式将方法转换成函数：

1、把方法作为参数传给另一个方法或者函数的时候，方法自动被转化成函数。

2、手动使用神奇的下划线_ 将方法被转化成函数：

scala> def m1(x:Int,y:Int) = x + y
m1: (x: Int, y: Int)Int
​
scala> val f1=m1 _      //方式一：方法被转化成函数
f1: (Int, Int) => Int = 
​
scala> val f1=m1(_,_)   //方式二：方法被转化成函数
f1: (Int, Int) => Int = 
​
scala> val f1=m1            //不允许将方法直接赋值给变量，方法不是值，而函数与其他数据类型一样
:12: error: missing argument list for method m1
Unapplied methods are only converted to functions when a function type is expected.
You can make this conversion explicit by writing `m1 _` or `m1(_,_)` instead of `m1`.
       val f1=m1

              ^

1.9.4  Scala的方法函数操作

定义一个方法或函数实现随机组合车牌号，仅考虑后5位全是数字的情况。

//根据输入前缀返回随机车牌号，如输入“京A”，返回“京A88888”
def generateCarNo(prefix:String):String={
  var carNo=prefix
  for(i<-1 to 5){
    val randNum=(Math.random()*10).toShort.toString
    carNo+=randNum
  }  
  carNo
}
​
//使用函数
val generator=(prefix:String)=>{
  var carNo=prefix
  for(i<-1 to 5){
    val randNum=(Math.random()*10).toShort.toString
    carNo+=randNum
  }
  carNo
}
​
//方法转换函数
val generator1=generateCarNo _ //注意空格
//或者
val generator2=generateCarNo(_)
​
//调用一个方法和三个函数
print(generateCarNo("京A"))
print(generator("京C"))
print(generator1("京D"))
print(generator2("京E"))

Guff_hys_python数据结构,大数据开发学习,python实训项目-CSDN博客