假设你有一个列表

scala> val x =List.range(10,20)
x: List[Int] = List(10, 11, 12, 13, 14, 15, 16, 17, 18, 19)

定义一个方法

scala> def m1(i:Int)=i+2
m1: (i: Int)Int

定义一个函数

scala> (i:Int)=>i+2
res0: Int => Int = <function1>

scala> x.map((x)=>x+2)
res2: List[Int] = List(12, 13, 14, 15, 16, 17, 18, 19, 20, 21)

接受参数的方法

scala> m1(2)
res3: Int = 4

用val定义函数

scala> val p =(i:Int)=>i+2
p: Int => Int = <function1>

函数的参数是可选的

 scala> p(2)
    res4: Int = 4

scala> p
res5: Int => Int = <function1>

方法的参数是强制的

scala> m1
<console>:9: error: missing arguments for method m1;
follow this method with `_' if you want to treat it as a partially applied function

查看下面的教程，它解释了通过其他示例传递其他差异，如diff与方法Vs函数的其他示例，使用函数作为变量，创建返回函数的函数

这里有一篇不错的文章，我的大部分描述都来自于它。 关于我的理解，只是一个简短的函数和方法的比较。希望能有所帮助:

功能: 它们基本上是一个物体。更准确地说，函数是具有apply方法的对象;因此，由于开销，它们比方法要慢一些。它类似于静态方法，因为它们独立于要调用的对象。 一个简单的函数示例如下所示:

val f1 = (x: Int) => x + x
f1(2)  // 4

The line above is nothing except assigning one object to another like object1 = object2. Actually the object2 in our example is an anonymous function and the left side gets the type of an object because of that. Therefore, now f1 is an object(Function). The anonymous function is actually an instance of Function1[Int, Int] that means a function with 1 parameter of type Int and return value of type Int. Calling f1 without the arguments will give us the signature of the anonymous function (Int => Int = )

方法: 它们不是对象，而是赋值给类的实例。，一个物体。与java中的方法或c++中的成员函数完全相同(正如Raffi Khatchadourian在对这个问题的评论中指出的那样)等等。 一个简单的方法示例如下所示:

def m1(x: Int) = x + x
m1(2)  // 4

上面这一行不是简单的值赋值，而是方法的定义。当您像第二行一样使用值2调用此方法时，x被替换为2，结果将被计算出来，并得到4作为输出。在这里，如果只是简单地写m1，就会得到一个错误，因为它是一个方法，需要输入值。通过使用_，你可以将一个方法分配给一个函数，如下所示:

val f2 = m1 _  // Int => Int = <function1>

函数不支持默认参数。做的方法。从方法转换到函数会丢失参数默认值。(Scala 2.8.1发布)

这是Rob Norris写的一篇很棒的文章，解释了两者的区别

Scala中的方法不是值，但函数是。您可以构造一个通过η扩展(由后面的下划线触发)委托给某个方法的函数。

定义如下:

方法是用def定义的东西，值是可以赋值给val的东西

简而言之(摘自博客):

定义方法时，我们发现不能将其赋值给val。

scala> def add1(n: Int): Int = n + 1
add1: (n: Int)Int

scala> val f = add1
<console>:8: error: missing arguments for method add1;
follow this method with `_' if you want to treat it as a partially applied function
       val f = add1

还要注意add1的类型，它看起来不正常;你不能声明一个(n: Int)Int类型的变量。方法不是值。

然而，通过添加η扩展后加算符(η读作“eta”)，我们可以将该方法转化为函数值。注意f的类型。

scala> val f = add1 _
f: Int => Int = <function1>

scala> f(3)
res0: Int = 4

_的效果相当于执行以下操作:我们构造一个Function1实例，委托给我们的方法。

scala> val g = new Function1[Int, Int] { def apply(n: Int): Int = add1(n) }
g: Int => Int = <function1>

scala> g(3)
res18: Int = 4

方法操作对象，而函数不操作。

Scala和c++都有函数，但在JAVA中，你必须用静态方法来模仿它们。

区别是细微的，但却是实质性的，它与所使用的类型系统有关(除了来自面向对象或函数范式的术语)。

当我们谈论函数时，我们谈论的是函数类型:它是一种类型，它的实例可以作为输入或输出传递给其他函数(至少在Scala中是这样)。

当我们谈论(类的)方法时，我们实际上是在谈论它所属的类所表示的类型:也就是说，方法只是更大类型的一个组件，不能单独传递。它必须与它所属类型的实例(即类的实例)一起传递。