> Java程序员第一次写Scala函数的时候，一定会困惑一件事：为什么Scala的函数写起来这么奇怪？

```scala
// Java写法
public static int add(int a, int b) {
  return a + b;
}

// Scala写法
def add(a: Int, b: Int): Int = a + b
```

看起来差不多——参数、返回值、函数体。但真正用下去，你会发现越来越多奇怪的地方：为什么函数可以当参数传？为什么函数可以当返回值？为什么`_ + _`就是一个函数？为什么`map`方法接收的不是一个函数名，而是一个函数？

很多Java程序员学Scala函数的时候，记住了语法，但没理解本质。结果就是：写出来的Scala代码还是Java风格——全是`def`方法，没有函数式味道。

这篇文章不讲"函数怎么定义"这种入门废话，直接说干货：**Scala里方法和函数到底差在哪？为什么函数是一等公民？高阶函数到底是什么？**

![Scala函数定义知识体系](https://developer.qcloudimg.com/http-save/yehe-2482016/db9fabef1f9aeeaafa0a3404ff25e87d.jpg)

---

## 先从一个困惑说起

Java程序员都知道方法（method）——它是类的一部分，你调用它，它干活。

但Scala里多了一个概念叫"函数"（function）。函数和方法到底有什么区别？

```scala
// 这是一个方法（method）
def add(a: Int, b: Int): Int = a + b

// 这是一个函数（function value）
val addFunc = (a: Int, b: Int) => a + b
```

看起来都是"两个Int进去，一个Int出来"。但区别在哪？

区别在于：**方法是属于类的，函数是一个值。**

方法是类的成员——它绑定在某个类上，你通过对象调用它。函数是一个对象——它本身就是一个值，可以赋值给变量、可以作为参数传递、可以作为返回值。

```scala
// 方法：属于类，不能直接赋值给变量
// val f = add  // 这样写会报错吗？

// 函数：是值，可以随便传
val f = (a: Int, b: Int) => a + b
val g = f  // 函数可以赋值
List(1, 2, 3).map(f)  // 函数可以作为参数
```

这个区别看起来很小，但它是函数式编程的基石。**如果函数不能作为值传递，那map、flatMap、filter这些高阶函数就根本不存在。**

---

## 方法和函数的关系：它们是"可转换"的

Java程序员最困惑的点就在这：Scala里到底什么时候写方法，什么时候写函数？

答案是：**日常开发里，你写`def`定义的是方法，但在需要函数的地方，Scala会自动把方法"提升"成函数。**

```scala
// 定义一个方法
def add(a: Int, b: Int): Int = a + b

// 这里需要一个函数：(Int, Int) => Int
// Scala自动把add方法转成了函数
val list = List(1, 2, 3)
list.map(x => add(x, 1))  // 这里add是方法，但被当成函数用了
```

这个过程叫"eta展开"——Scala编译器自动把方法转换成函数值。所以你日常写代码的时候，不需要刻意区分"这是方法还是函数"——编译器会帮你处理。

但理解这个区别很重要：**当你需要把函数存起来、传出去的时候，它就必须是函数值，不能是方法。**

```scala
// 方法可以直接调用
add(1, 2)  // 3

// 但方法不能直接赋值给变量
// val f = add  // 这样写Scala会报错，因为add是方法不是函数

// 要把方法转成函数值，加个下划线
val f = add _  // eta展开：方法变成函数值
```

这个下划线`_`就是"把方法转成函数"的意思。很多人觉得这个语法奇怪——但它背后的设计意图是：**明确告诉编译器，我要的是这个方法的函数值，不是调用这个方法。**

---

## 函数的本质：它是一个接口

很多人以为函数是个很玄的东西——"函数式编程嘛，函数是一等公民"。但如果你从JVM的角度看，函数一点都不玄。

**Scala的函数，本质上就是一个接口。**

你定义一个函数`(Int, Int) => Int`，编译器背后给你生成的是：

```scala
// 你写的
val addFunc = (a: Int, b: Int) => a + b

// 编译器背后做的
val addFunc = new Function2[Int, Int, Int] {
  def apply(a: Int, b: Int): Int = a + b
}
```

看到了吗？所谓"函数值"，其实就是一个实现了`Function2`接口的匿名类对象。

这就是为什么函数可以当参数传——因为它是一个对象，一个实现了`FunctionN`接口的对象。

```scala
// 你写的
List(1, 2, 3).map(x => x + 1)

// 编译器背后
List(1, 2, 3).map(new Function1[Int, Int] {
  def apply(x: Int): Int = x + 1
})
```

从这个角度看，Scala的函数和Java的匿名内部类，本质上是同一个东西——只不过Scala给了你一个更简洁的语法糖。

**这就是Scala函数的真相：它不是什么魔法，它就是一个实现了FunctionN接口的对象。**

---

## 函数定义的几种方式

### 1. 方法定义：def

最常用的方式。定义一个方法，属于当前类/对象。

```scala
def add(a: Int, b: Int): Int = a + b

def greet(name: String): Unit = {
  println(s"Hello, $name")
}
```

特点：有名字、有参数类型、有返回类型（可以省略，编译器推断）、函数体用`=`连接。

### 2. 函数值定义：val + lambda

定义一个函数值，它是一个对象，可以到处传。

```scala
val addFunc = (a: Int, b: Int) => a + b

val greetFunc = (name: String) => println(s"Hello, $name")
```

特点：用`val`定义（因为它是值），参数和返回类型写在括号里，`=>`后面是函数体。

### 3. 匿名函数：_ 简写

当函数参数只有一个，而且只用一次的时候，可以用下划线简写。

```scala
List(1, 2, 3).map(_ + 1)  // 等价于 map(x => x + 1)

List("a", "b", "c").map(_.toUpperCase)  // 等价于 map(s => s.toUpperCase)
```

这个写法简洁，但要注意：**下划线代表"参数"，而且只能用一次。**如果函数体里同一个参数要用两次，就不能用下划线简写了。

```scala
// 不能这样写：_用了两次，编译器不知道你指的是哪个
// List(1, 2, 3).reduce(_ + _)  // 这个可以，两个不同的_

// 这个也可以：_出现两次，但reduce需要两个参数
List(1, 2, 3).reduce(_ + _)  // 等价于 (a, b) => a + b
```

### 4. 带隐式参数的函数

这个是Scala特有的，在大数据开发里经常用到。

```scala
def greet(name: String)(implicit prefix: String): Unit = {
  println(s"$prefix, $name")
}

// 调用的时候，第二个参数列表自动找implicit值
implicit val prefix: String = "你好"
greet("Alice")  // 自动传入prefix
```

这个语法看起来奇怪，但它是Scala做依赖注入的方式——Spark里的`SparkSession`就是靠implicit传的。

---

## 高阶函数：函数当参数传

理解了"函数是一个对象"之后，高阶函数就很好理解了。

**高阶函数，就是接收一个函数作为参数，或者返回一个函数的函数。**

```scala
// map就是一个高阶函数
// 它接收一个函数：T => U，然后对每个元素应用这个函数
def map[U](f: T => U): List[U] = ...

// 你用的时候
List(1, 2, 3).map(x => x * 2)
//              ^^^^^^^^^^^^
//              这就是传进去的函数
```

Java 8也有Lambda，也有Stream.map——那Scala的高阶函数和Java的有什么区别？

区别在于：**Scala的函数是从一开始就设计成一等公民的，Java的Lambda是后来加的。**

具体来说：

1. **Java的Lambda只能是函数式接口的实例**——你传个Lambda，背后必须有个`@FunctionalInterface`接口
2. **Scala的函数就是`FunctionN`接口**——它是统一的，不管几个参数，都是`Function1`、`Function2`...
3. **Scala支持函数作为返回值**——这个Java也有，但Scala用得更自然

```scala
// 函数作为返回值：柯里化
def multiplyBy(factor: Int): Int => Int = {
  (x: Int) => x * factor
}

val double = multiplyBy(2)  // 返回一个函数：Int => Int
double(5)  // 10

val triple = multiplyBy(3)
triple(5)  // 15
```

这个叫"函数工厂"——你给它一个参数，它给你返回一个函数。这种写法在Java里也能写，但Scala的语法让它自然得多。

---

## 写在最后

我写这篇文章的时候，特意没罗列函数有多少种写法——因为那些语法东西，查文档就有。

真正值得花时间理解的是：**Scala为什么要有函数这个概念？**

不是因为"函数式编程嘛，函数是一等公民"——这句话说了等于没说。而是因为：**当你需要对一组数据做变换的时候，你需要一个"可以传进去的操作"。**

Java里你怎么做？你定义一个接口，然后实现它，然后传进去——这就是匿名内部类。Scala给了你一个更简洁的方式：lambda表达式。但本质是一样的——都是传一个"操作"进去。

**函数的本质，就是一个可以传递的操作。**

理解了这个，你就理解了Scala函数的设计哲学。你不会再纠结"为什么Scala的函数写起来这么奇怪"——因为你知道，那不是奇怪，那是在JVM之上，给函数式编程搭的一层抽象。

Java 8加了Lambda，加了Stream——但Java的设计思路是"给对象加函数能力"，Scala的设计思路是"函数本身就是对象"。出发点不一样，写出来的代码感觉也不一样。

这就是为什么Spark用Scala写起来那么优雅——因为你可以把一个函数直接传给RDD，不需要定义接口，不需要实现匿名类，一行lambda就搞定了。

**函数不是魔法，它就是一个实现了FunctionN接口的对象。理解了这一点，你就理解了Scala函数的全部。**

Java程序员第一次写Scala函数的时候，一定会困惑一件事：为什么Scala的函数写起来这么奇怪？

深入理解Scala函数定义：从方法到函数的类型跨越

编程语言

Scala函数本质是接口实现的对象，可赋值传递。方法与函数区别在于是否绑定类，编译器自动eta展开转换。高阶函数支持函数作参数和返回值，实现灵活的数据变换。掌握这一核心，即可写出地道的函数式风格代码。

代码解释

大数据

编译器

Spark 

Java

2026上云采购 | AI焕新·智启新局

bigdata-class

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

EdgeOne AI 安全实战专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

深入理解Scala函数定义：从方法到函数的类型跨越-腾讯云开发者社区-腾讯云

深入理解Scala函数定义：从方法到函数的类型跨越

深入理解Scala函数定义：从方法到函数的类型跨越

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐