> Java里一个类有两种东西——实例成员和静态成员。

```java
public class User {
  private String name;          // 实例成员——每个对象一份

  public static int count = 0;  // 静态成员——类级别，所有对象共享

  public static User create(String name) {  // 静态工厂方法
    count++;
    return new User(name);
  }
}
```

实例成员属于对象，静态成员属于类——它们写在同一个类里，但本质上是两个世界的东西。

Scala没有`static`关键字。

那Scala怎么写静态成员？——伴生对象（Companion Object）。

```scala
class User(val name: String) {
  // 实例成员——写在类里
  def greet(): String = s"Hello, I'm $name"
}

object User {
  // 静态成员——写在伴生对象里
  var count: Int = 0

  def create(name: String): User = {
    count += 1
    new User(name)
  }
}
```

类和对象同名，写在同一个源文件里——类叫伴生类，对象叫伴生对象，它们互为伴生关系。

这篇文章不讲"伴生对象怎么写"这种入门废话，直接说干货：**伴生类和伴生对象底层是什么？它们为什么能互相访问私有成员？这种设计比Java的static好在哪？**

![Scala伴生类知识体系](https://developer.qcloudimg.com/http-save/yehe-2482016/f83d73b6a41e746adaad6b9ae636fd65.jpg)

---

## 先搞清楚：伴生关系的规则

要成为伴生关系，有两个硬性条件：

1. **类和对象必须同名**
2. **必须写在同一个源文件里**

```scala
// User.scala —— 类和对象在同一个文件，同名
class User(val name: String)
object User
```

少一个都不行——不同名不是伴生，不同文件也不是伴生。

为什么规则这么严格？因为伴生关系带来了一个特殊的权力：**互相访问对方的私有成员。**

```scala
class User(val name: String) {
  private val secret = "my-secret"
}

object User {
  def revealSecret(user: User): String =
    user.secret  // 可以访问——伴生对象能访问伴生类的私有成员
}
```

反过来也行——伴生类能访问伴生对象的私有成员。

Java里静态方法能访问实例的私有成员吗？——同一个类里可以。Scala把这个权力显式地通过伴生关系表达了出来。

---

## 伴生对象的底层：它是一个单例对象

Scala里你写`object User`，底层生成了什么？——一个单例对象，一个静态的`MODULE$`实例。

```scala
object User {
  var count: Int = 0
  def create(name: String): User = new User(name)
}
```

编译器大概生成这样的Java等价代码：

```java
public final class User$ {
  public static final User$ MODULE$;  // 单例实例
  private int count;

  static {
    MODULE$ = new User$();  // 类加载时初始化
  }

  public User create(String name) {
    return new User(name);
  }
}
```

看到了吗？伴生对象在底层就是一个普通的类，只不过它有一个静态的单例实例`MODULE$`。

你调用`User.create("zhangsan")`，底层其实是`User$.MODULE$.create("zhangsan")`。

**Scala没有static——它用"单例对象"来实现static的功能。**

这不是绕弯子——这是一个重要的设计选择：**Scala里一切皆对象，包括"类级别的东西"。**

Java的静态方法不是对象的方法——它属于类，不能被继承、不能多态、不能当参数传。Scala的伴生对象是一个真正的对象——它可以继承类、实现接口、被赋值给变量。

---

## 伴生对象最常见的用途

### 用途1：工厂方法

这是伴生对象最经典的用法——把构造逻辑封装在伴生对象的`apply`方法里。

```scala
class User(val name: String, val age: Int)

object User {
  def apply(name: String, age: Int): User = new User(name, age)
}

// 有了apply，你可以省略new
val user = User("zhangsan", 20)  // 等价于 User.apply("zhangsan", 20)
```

为什么`User("zhangsan", 20)`不用`new`？——因为它调用的是伴生对象的`apply`方法，不是构造器。伴生对象的`apply`天然就是工厂方法。

### 用途2：静态常量和工具方法

```scala
object MathUtils {
  val PI: Double = 3.141592653589793
  def square(x: Double): Double = x * x
}

MathUtils.square(5)  // 25.0
```

不需要实例化——直接用对象名调用。这就是Scala版的工具类。

### 用途3：unapply——提取器

伴生对象除了`apply`（构造），还有一个对偶方法`unapply`（解构）——这是模式匹配的基础。

```scala
class User(val name: String, val age: Int)

object User {
  def unapply(user: User): Option[(String, Int)] =
    Some((user.name, user.age))
}

val user = new User("zhangsan", 20)
user match {
  case User(name, age) => println(s"$name, $age")
}
```

`case User(name, age)`——这里调用的就是伴生对象的`unapply`，把对象拆成名字和年龄。

**apply负责"合"，unapply负责"拆"——它们是伴生对象的一对对偶方法。**

样例类（case class）自动帮你生成这两个方法——所以样例类天然支持模式匹配。

### 用途4：共享状态

```scala
class DatabaseConnection(val id: Int)

object DatabaseConnection {
  private var totalCreated = 0  // 所有连接共享

  def create(): DatabaseConnection = {
    totalCreated += 1
    new DatabaseConnection(totalCreated)
  }
}
```

伴生对象里的字段是所有实例共享的——等价于Java的静态字段。

---

## 伴生类 vs 伴生对象：职责怎么分

很多人搞不清什么该放类里，什么该放对象里。记住这条线：

| 伴生类（class） | 伴生对象（object） |
|----------------|-------------------|
| 实例成员 | 静态成员 |
| 每个对象一份 | 全局只有一份 |
| 依赖具体对象的状态 | 不依赖具体对象 |
| 字段、实例方法 | 工厂方法、常量、工具方法 |
| 构造器 | apply/unapply |

简单说：**和具体对象有关的放类里，和"怎么创建对象、对象共享什么"有关的放对象里。**

---

## 几个常见的坑

### 坑1：必须在同一个源文件

```scala
// User.scala
class User(val name: String)

// UserObject.scala —— 不同文件，即使同名也不是伴生
object User
```

不同文件，伴生关系不成立——私有成员访问会报错。

### 坑2：伴生对象不是静态类

很多Java转Scala的人把伴生对象当"静态类"用——但它是一个真正的单例对象，可以继承、可以多态。不要只把它当static的替代品。

### 坑3：apply和构造器的混淆

```scala
class User(val name: String)
object User {
  def apply(name: String): User = new User(name)
}

new User("a")  // 直接调构造器
User("a")      // 调伴生对象apply——工厂方法
```

两种写法都能创建对象——但语义不同。通常推荐用`User("a")`这种工厂方式，更灵活（可以返回子类、可以缓存）。

### 坑4：Scala 3的变化

Scala 3里伴生关系的规则基本一致，但语法更简洁。同时Scala 3也没有恢复static关键字——伴生对象依然是标准做法。

---

## 写在最后

我写这篇文章的时候，特意没罗列伴生对象有多少种写法——因为写法很简单。

真正值得理解的是：**Scala为什么要设计伴生对象，而不是直接保留static？**

因为static破坏了面向对象的纯粹性。

Java的静态方法不属于任何对象——它不能被继承、不能被重写、不能多态。你写一个静态方法，它就钉死在那个类上了。

Scala的伴生对象是一个真正的对象——它可以继承抽象类、实现特质、混入功能。它和伴生类是平等的，只不过一个管"实例"，一个管"类级别"。

**这就是Scala的设计哲学：在Scala的世界里，一切都是对象。类级别的东西也不例外——它由一个单例对象来承载。**

伴生类和伴生对象同名、同文件、互相可见——它们共同构成了一个完整的类型：类负责实例的行为，对象负责实例的创建和共享的状态。

当你写`User("zhangsan", 20)`的时候，你用的是对象的`apply`；当你写`case User(name, age)`的时候，你用的是对象的`unapply`；当你访问共享计数的时候，你用的是对象的字段。

类和对象，一实一虚，一静一动——它们合在一起，才是Scala里一个完整的"类"。

实例成员属于对象，静态成员属于类——它们写在同一个类里，但本质上是两个世界的东西。

深入理解Scala伴生类：类对象合一设计

人工智能

Scala伴生对象与类同名同文件实现静态成员，底层为单例对象（MODULE$），支持互访私有成员、工厂方法、apply/unapply及共享状态，比Java static更符合面向对象设计。

代码解释

编译器

Java

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

EdgeOne AI 安全实战专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

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

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

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

社区新版编辑器体验调研

深入理解Scala伴生类：类对象合一设计-腾讯云开发者社区-腾讯云

深入理解Scala伴生类：类对象合一设计

深入理解Scala伴生类：类对象合一设计

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐