版权声明：本文为博主原创文章，未经博主允许不得转载!!

欢迎访问:https://blog.csdn/qq_21439395/article/details/80962507

交流QQ: 824203453

 

方法和函数

方法：一段业务逻辑的综合。

1.1.  定义方法

java中的方法：

publicint add(int a,int b){

returna + b;

}

scala中的方法：

 

def methodName([list of parameters]) : [return type] = {}

/**
  * 方法的定义及调用
  *
  * 定义方法的格式为:
  * def methodName ([list of parameters]) : [return type] = {}
  * 如果不使用等号和方法体，则隐式声明抽象(abstract)方法。
  */
  object ScalaMethod extends App{
  
    // 定义个sum方法, 该方法有2个参数, 参数类型为整型, 方法的返回值为整型
    def sum(a:Int, b: Int): Int = {
        a + b
    }
   // 定义有可变参数的方法,
   def sumAll(b: Int*): Int = {
    var v = 0
    for (i<- b){
       v += i
     }
    v  // 返回值
   }
    // 调用
    val result1 = sum(1, 5)
    println(result1)
println(sumAll(1,11,13))
  
    // 该方法没有任何参数, 也没有返回值
    def sayHello1 = println("Say BB1")
    def sayHello2() = println("Say BB2")
    sayHello1 // 如果方法没有() 调用时不能加()
    sayHello2 // 可是省略(), 也可以不省略
  }

 

 

 

如果有return关键字，必须要有返回值类型，否则报错如下：

 

方法总结：

1， 定义方法的关键字，def   

格式： def  方法的名称（参数列表）：返回值类型 = {方法体内容}

2， 方法的返回值，最后一行的内容，如果是循环，那么返回值是Unit

3， 如果空参方法，定义的时候有（），调用的时候可以省略（），但是如果定义的时候没有（），调用方法的时候，不能加（）

4， 方法的返回值类型，可以省略，但是特殊情况下，必须加上：

4.1,方法有return关键字

4.2，递归调用的方法。

5，方法不能最为最终的表达式存在，（空参的方法调用除外）

1.2.     定义函数

和方法类似，基本能实现相同的功能

val| var   函数名称=（函数的参数列表） =>  函数体

 

 

函数可以作为最终的表达式存在，返回的内容就是函数的签名

签名（函数的名称，函数的参数，函数的返回值类型）

这种定义方式不需要指定返回值类型，编译器会自动推断

 

第二种定义方式：

复杂全面的定义

val |var  函数名称：（输入参数类型）=> 返回值类型 = （参数的引用）=> 函数体

定义一个无参的函数

不同于方法，没有参数的函数定义，也必须加()

valf2:()=>Unit =() => println(123)  valf2 =() => println(123)  返回值类型为Unit

valf2:()=>Int =() => 123   val f2=()=> 123  返回值类型为Int

 

 

 

1.3.     方法和函数的区别

在函数式编程语言中，函数是“头等公民”，它可以像任何其他数据类型一样被传递和操作

函数可以当成值来进行传递，方法的参数和返回值都可以是函数。

函数和变量，类，对象， 是一个级别的。

区别和联系：

1， 方法用def关键字定义，函数的标识 =>

2， 方法不能作为最终的表达式存在，但是函数可以，返回函数的签名信息

3， 方法和函数调用的时候都需要显示的传入参数

4， 函数可以作为方法的参数，和返回值类型。

 

案例：首先定义一个方法，再定义一个函数，然后将函数传递到方法里面

 

object MethodAndFunctionTest {
  //定义一个方法
  //方法m2参数要求是一个函数，函数的参数必须是两个Int类型
  //返回值类型也是Int类型
  def m1(f: (Int, Int) => Int) : Int = {
    f(2, 6)
  }
  
  //定义一个函数f1，参数是两个Int类型，返回值是一个Int类型
  val f1 = (x: Int, y: Int) => x + y
  //再定义一个函数f2
  val f2 = (m: Int, n: Int) => m * n
  
  //main方法
  def main(args: Array[String]) {
  
    //调用m1方法，并传入f1函数
    val r1 = m1(f1)
    println(r1)
  
    //调用m1方法，并传入f2函数
    val r2 = m1(f2)
    println(r2)
  }
}

// 定义一个普通方法
def max(x:Int,y:Int) = if(x>y)x else y

// 定义一个方法，参数是一个函数，参数只需要函数签名，在调用的时候具体再传入函数体
def max1(f:(Int,Int)=>Int) = f(20,10)
def max2(f:(Int,Int) => Int,x:Int,y:Int)= f(x,y)

// 定义一个方法，方法返回值是函数
def max3()= (x:Int,y:Int)=> if (x>y) x else y
def main(args: Array[String]): Unit = {

  println(max(10,20))
  println(max1((x:Int,y:Int)=>if(x>y) x else y))
  println(max2((x:Int,y:Int)=>if(x>y) x else y,10,20))
  println(max3()(10,20))
}

 

 

 

1.4.     将方法转换成函数（神奇的下划线）

 

1.5.  方法和函数的总结（重点）：

1，方法的定义 使用def 关键字    函数的定义 使用   =>

函数有两种定义方式 

val  f = (x:Int,y:Int) => x + y

val  f:(Int,Int) => Int = (x,y) =>  if(x>y) x else y

2，方法不能作为最终的表达式存在，但是函数可以作为最终的表达式存在，返回函数签名

函数签名：函数的名称，参数类型，返回值类型   函数的别名（函数参数个数）

3，方法和函数的调用，方法和函数可以相互调用。

方法名称（参数列表）   函数名称（参数列表）

无参的方法可以省略（），无参的函数不能省略括号

4，函数是一等公民，可以作为方法的参数和返回值类型。

       函数作为方法的参数： 定义方法的时候，函数参数规范（函数的名称，参数类型，返回值类型），然后在调用方法的时候，传递的是一个已存在的函数，或者是一个匿名函数。都要求传入的函数，必须满足定义的规范，使用匿名函数的时候，可以省略参数类型（（x,y）=>x*y）

       函数最为方法的返回值类型，当调用方法的时候，返回函数，传入参数进行函数的调用。

5， 方法可以转化为函数，通过在方法名称 _ ,另外当方法的参数是一个函数的时候，满足条件的方法会被自动转换为函数，进行传递。

def method1(f: (Int, Int) => Int): Int = {

     |     // 可以调用函数

     |     f(1, 100)

     |   }

def max(x:Int,y:Int) =  x * y

method1(max _)

method1(max)   // 方法自动转换为函数

 

方法和函数应该怎么使用？

一般情况下，优先使用函数

实际上，还是定义方法使用的更多，函数会作为方法的参数。

最最常用的：调用方法的时候传递函数。

 

def methodName([list of parameters]) : [return type] = {}

 

版权声明：本文为博主原创文章，未经博主允许不得转载!!

欢迎访问:https://blog.csdn/qq_21439395/article/details/80962507

交流QQ: 824203453