Scala详细文本教学04

前言

你们好我是啊晨，前些天偷懒了下
首先呢还是那句话，内容很多，分为几篇这是最后篇，选择阅读就好，很详细。
下面请：

一、Scala 方法

Scala 有方法与函数，二者在语义上的区别很小。Scala 方法是类的一部分，而函数是一个对象可以赋值给一个变量。
Scala 中的方法跟 Java 的类似，方法是组成类的一部分。
Scala 中使用 val 语句可以定义函数，def 语句定义方法。

class Test{
   
  def m(x: Int) = x + 3
  val f = (x: Int) => x + 3
}

注意：有些翻译上函数(function)与方法(method)是没有区别的。

1、方法声明

Scala 方法声明格式如下：

def methodName ([参数列表]): [return type]={
   方法体}

如果你不写等于号和方法主体，那么方法会被隐式声明为抽象(abstract)，包含它的类型于是也是一个抽象类型。

2、方法定义

方法定义由一个 def 关键字开始，紧接着是可选的参数列表，一个冒号 : 和方法的返回类型，一个等于号 = ，最后是方法的主体。
Scala 方法定义格式如下：

def methodName ([参数列表]) : [return type] = {
   
   method body
   return [expr]
}

以上代码中 return type 可以是任意合法的 Scala 数据类型。参数列表中的参数可以使用逗号分隔。
以下方法的功能是将两个传入的参数相加并求和：

object add{
   
   def addInt( a:Int, b:Int ) : Int = {
   
      var sum:Int = 0
      sum = a + b
      return sum
   }
}

如果方法没有返回值，可以返回为 Unit，这个类似于 Java 的 void, 实例如下：

object Hello{
   
   def printMe( ) : Unit = {
   
      println("Hello, Scala!")
   }
}

3、方法调用

Scala 提供了多种不同的方法调用方式：
以下是调用方法的标准格式：

methodName( 参数列表 )

如果方法使用了实例的对象来调用，我们可以使用类似java的格式 (使用 . 号)：

[instance.]mehtodName( 参数列表 )

以上实例演示了定义与调用方法的实例:

object Test {
   
   def main(args: Array[String]) {
   
        println( "Returned Value : " + addInt(5,7) );
   }
   def addInt( a:Int, b:Int ) : Int = {
   
      var sum:Int = 0
      sum = a + b
      return sum
   }
}

执行以上代码，输出结果为：

$ scalac Test.scala 
$ scala Test
Returned Value : 12

二、函数

Scala 也是一种函数式语言，所以函数是 Scala 语言的核心。以下一些函数概念有助于我们更好的理解 Scala 编程：

函数传名调用(Call-by-Name)	指定函数参数名
函数 - 可变参数	递归函数
默认参数值	高阶函数
内嵌函数	匿名函数
偏应用函数	函数柯里化(Function Currying)

1、方法和函数的区别

1、函数可作为一个参数传入到方法中，而方法不行。

object MethodAndFunctionDemo {
   
  //定义一个方法
  //方法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]): Unit = {
   
    //调用m1方法，并传入f1函数
    val r1 = m1(f1)
    println(r1)
    //调用m1方法，并传入f2函数
    val r2 = m1(f2)
    println(r2)
  }
}

运行结果：

8
12 

2、在Scala中无法直接操作方法，如果要直接操作方法，必须先将其转换成函数。有两种方法可以将方法转换成函数：

val f1 = m _

在方法名称m后面紧跟一个空格和下划线告诉编译器将方法m转换成函数，而不是要调用这个方法。 也可以显示地告诉编译器需要将方法转换成函数：

val f1: (Int) => Int = m

通常情况下编译器会自动将方法转换成函数，例如在一个应该传入函数参数的地方传入了一个方法，编译器会自动将传入的方法转换成函数。

object TestMap {
   

  def ttt(f:Int => Int):Unit = {
   
    val r = f(10)
    println(r)
  }

  val f0 = (x : Int) => x * x

  //定义了一个方法
  def m0(x:Int) : Int = {
   
    //传递进来的参数乘以10
    x * 10
  }

  //将方法转换成函数，利用了神奇的下滑线
  val f1 = m0 _

  def main(args: Array[String]): Unit = {
   
    ttt(f0)

    //通过m0 _将方法转化成函数
    ttt(m0 _);

    //如果直接传递的是方法名称，scala相当于是把方法转成了函数
    ttt(m0)

    //通过x => m0(x)的方式将方法转化成函数,这个函数是一个匿名函数，等价：(x:Int) => m0(x)
    ttt(x => m0(x))
  }
}

输出结果为：

100
100
100
100

3、函数必须要有参数列表，而方法可以没有参数列表

4、在函数出现的地方我们可以提供一个方法
在需要函数的地方，如果传递一个方法，会自动进行ETA展开（把方法转换为函数）

如果我们直接把一个方法赋值给变量会报错。如果我们指定变量的类型就是函数，那么就可以通过编译，如下：

当然我们也可以强制把一个方法转换给函数，这就用到了 scala 中的部分应用函数：

2、scala 匿名函数

Scala 中定义匿名函数的语法很简单，箭头左边是参数列表，右边是函数体。
使用匿名函数后，我们的代码变得更简洁了。
下面的表达式就定义了一个接受一个Int类型输入参数的匿名函数:

//var 函数名称 = （参数） => 函数体
var inc = (x:Int) => x+1
//var 函数名称 = （参数） => 函数体
//函数体中最后一个表达式是函数的返回值
var add4 = (x:Int,name:String) =>{
   
  x+name
  "woshililei"
}
//无参函数
val f4 =()  =>{
   
  1
}
//调用无参函数，后面括号不能丢
val res04 = f4()
//不加括号，表示调用函数的toString方法
val res05 = f4

上述定义的匿名函数，其实是下面这种写法的简写：

//第一个Int是入参类型，第二个Int是返回值类型
//Function1后面的数字是入参的个数
def add2 = new Function1[Int,Int]{
     
    def apply(x:Int):Int = x+1;  
}
//第一个Int是入参类型，第一个String是入参类型，第二个String是返回值类型
def add3 = new Function2[Int,String,String] {
   
  def apply(x:Int,y:String):String = x+y;
}
val f5 = new Function0[Int] {
   
  def apply(): Int ={
   
    12
  }
}

以上实例的 inc 现在可作为一个函数，使用方式如下：

var x = inc(7)-1

还有一种非常轻量级的方式来写函数类型。下面是上面定义的三个函数的类型：

Int => Int
(Int, Int) => String
() => String

这个语法是下面类型的简写：

Function1[Int, Int]
Function2[Int, Int, String]
Function0[String]

同样我们可以在匿名函数中定义多个参数：

var mul = (x: Int, y: Int) => x*y

mul 现在可作为一个函数，使用方式如下：

println(mul(3, 4))

我们也可以不给匿名函数设置参数，如下所示：

var userDir = () => {
    System