0Pricing
Scala for Backend Engineering & Functional Programming · 课时

定义实例

隐式实例

定义实例 是 CoddyKit 上的免费 Scala for Backend Engineering & Functional Programming 课时。 这是第 2 节课，共 4 节。 你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。 这是 Scala for Backend Engineering & Functional Programming 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 Scala for Backend Engineering & Functional Programming 课程共包含 4 节课。

定义实例

实例告诉编译器，某个类型类应如何处理特定类型。在 Scala 中，实例通常会标记为 implicit（Scala 2），或使用 given 声明（Scala 3），这样编译器就能自动找到它们。

隐式 val 实例

对于简单的类型类，一个 implicit val 就足够了。当函数需要 Show[Int] 时，编译器会找到它。

trait Show[A] { def show(a: A): String }

object Main {
  implicit val intShow: Show[Int] = (a: Int) => s"Int=$a"

  def display[A](a: A)(implicit s: Show[A]): String = s.show(a)

  def main(args: Array[String]): Unit = {
    println(display(123))
  }
}

implicitly：召唤实例

implicitly[Show[Int]] 会要求编译器获取当前作用域中的实例。它适合用于测试实例是否存在，或直接访问实例。

trait Show[A] { def show(a: A): String }

object Main {
  implicit val intShow: Show[Int] = (a: Int) => s"<$a>"

  def main(args: Array[String]): Unit = {
    val s = implicitly[Show[Int]]
    println(s.show(8))
  }
}

为自定义类型创建实例

为您自己的样例类定义实例。数据类保持简洁，格式化逻辑则放在实例中。

trait Show[A] { def show(a: A): String }

case class Point(x: Int, y: Int)

object Main {
  implicit val pointShow: Show[Point] = (p: Point) => s"(${p.x}, ${p.y})"

  def display[A](a: A)(implicit s: Show[A]): String = s.show(a)

  def main(args: Array[String]): Unit = {
    println(display(Point(3, 4)))
  }
}

使用 implicit def 创建泛型实例

当一个实例依赖另一个实例时，请使用 implicit def。这里的 Show[List[A]] 就是根据 Show[A] 构建的。

trait Show[A] { def show(a: A): String }

object Main {
  implicit val intShow: Show[Int] = (a: Int) => a.toString

  implicit def listShow[A](implicit s: Show[A]): Show[List[A]] =
    (xs: List[A]) => xs.map(s.show).mkString("[", ", ", "]")

  def display[A](a: A)(implicit s: Show[A]): String = s.show(a)

  def main(args: Array[String]): Unit = {
    println(display(List(1, 2, 3)))
  }
}

伴生对象中的实例

将实例放在类型类的伴生对象中，就无需导入，编译器也能自动找到它们。这是存放默认实例的推荐位置。

trait Show[A] { def show(a: A): String }

object Show {
  implicit val intShow: Show[Int] = (a: Int) => s"i:$a"
  implicit val strShow: Show[String] = (a: String) => s"s:$a"
}

object Main {
  def display[A](a: A)(implicit s: Show[A]): String = s.show(a)

  def main(args: Array[String]): Unit = {
    println(display(5))
    println(display("hi"))
  }
}

隐式作用域与优先级

编译器会在多个位置搜索实例：首先搜索局部作用域和已导入的作用域，然后搜索相关类型的伴生对象。如果两个实例的特化程度相同，就会出现隐式值不明确错误。

上下文界定简写

语法 def f[A: Show](a: A) 是一种上下文界定，表示作用域中必须存在一个隐式的 Show[A]。在函数内部，可以使用 implicitly 获取它。

trait Show[A] { def show(a: A): String }

object Main {
  implicit val intShow: Show[Int] = (a: Int) => s"n=$a"

  def display[A: Show](a: A): String = implicitly[Show[A]].show(a)

  def main(args: Array[String]): Unit = {
    println(display(77))
  }
}

实例召唤辅助函数

库会在伴生对象中添加一个 apply 方法，作为方便的召唤器：Show[Int] 会返回该实例。它比 implicitly 更简洁。

trait Show[A] { def show(a: A): String }

object Show {
  def apply[A](implicit s: Show[A]): Show[A] = s
  implicit val intShow: Show[Int] = (a: Int) => s"=$a"
}

object Main {
  def main(args: Array[String]): Unit = {
    println(Show[Int].show(10))
  }
}

避免孤立实例

孤立实例是指既没有与类型类定义在一起，也没有与类型定义在一起的实例。它们虽然合法，但在不同导入之间可能导致行为不一致。建议优先将实例放在伴生对象中，以保持行为一致。

整合起来

一个完整的程序：包含伴生对象中的实例、派生出的列表实例，以及一个召唤器。

trait Show[A] { def show(a: A): String }

object Show {
  def apply[A](implicit s: Show[A]): Show[A] = s
  implicit val intShow: Show[Int] = _.toString
  implicit def listShow[A](implicit s: Show[A]): Show[List[A]] =
    (xs: List[A]) => xs.map(s.show).mkString(", ")
}

object Main {
  def main(args: Array[String]): Unit = {
    println(Show[List[Int]].show(List(4, 5, 6)))
  }
}

快速检查

测试您对定义实例的掌握程度。

回顾

您已经学会了定义实例：

  • 使用 implicit val 定义简单实例，使用 implicit def 定义派生实例。
  • 使用 implicitly 或伴生对象中的 apply 召唤实例。
  • 使用上下文界定 [A: Show] 作为简写。
  • 将实例放在伴生对象中，以避免孤立实例。

常见问题解答

「定义实例」课时是免费的吗？

是的 — 「定义实例」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Scala for Backend Engineering & Functional Programming 课程的其余内容，请升级到 CoddyKit PRO。 Scala for Backend Engineering & Functional Programming 课程共包含 4 节课。

「定义实例」这节课中我会学到什么？

隐式实例 你通过在浏览器中直接运行的动手代码来练习 Scala for Backend Engineering & Functional Programming，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 Scala for Backend Engineering & Functional Programming 需要有经验吗？

无需任何先前经验。CoddyKit 上的 Scala for Backend Engineering & Functional Programming 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。 这是第 2 节课，共 4 节。

「定义实例」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 Scala for Backend Engineering & Functional Programming 课中编写并运行代码吗？

能。每节 Scala for Backend Engineering & Functional Programming 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

  1. 类型类模式
  2. 定义实例
  3. 常见类型类
  4. 类型类派生
← 返回 Scala for Backend Engineering & Functional Programming