怎么避免写Java风格的Scala代码？

好的，咱们聊聊怎么才能写出地道的 Scala 代码，而不是一不小心就“画虎不成反类犬”，写出 Java 风味的 Scala。这事儿说起来，其实就是要把 Scala 语言本身的一些设计哲学和强大特性用对地方，而不是把它当成一个加了糖的 Java。

首先，得明白一个根本：Scala 是函数式和面向对象的混合体，而且函数式编程是其核心魅力所在。 如果你还在用 Java 的那种思维方式去组织代码，那基本就离地道 Scala 越来越远了。

1. 拥抱不可变性 (Immutability)！

这是最最最关键的一点。Java 里，我们习惯了用 `public void doSomething()` 这样的方法，里头 lots of state changes，各种修改对象内部状态。在 Scala 里，尽量避免使用 `var`，转而拥抱 `val`。

Java 风格：
```java
public class Counter {
private int count = 0;

public void increment() {
this.count++; // 可变状态
}

public int getCount() {
return this.count;
}
}
```
Scala 里常见的误区 (依然是 Java 风格)：
```scala
class Counter {
var count: Int = 0 // 使用 var 了，这就很 Java

def increment(): Unit = {
count += 1 // 修改可变状态
}

def getCount: Int = count
}
```
看到 `var` 了吗？看到 `+=` 了吗？这就是 Java 的思维。

地道 Scala 风格：
```scala
// 使用 case class 来表示数据，默认是不可变的
case class Counter(count: Int)

// 提供一个方法来返回一个新的 Counter 实例，而不是修改原有的
object Counter {
def apply(): Counter = Counter(0) // 方便创建初始实例
}

implicit class CounterOps(counter: Counter) { // 使用隐式类包装方法
def increment: Counter = Counter(counter.count + 1) // 返回新的实例
}

// 使用方法：
val initialCounter = Counter()
val incrementedCounter = initialCounter.increment // 得到一个新的 Counter，initialCounter 不变
```
你看，`Counter(counter.count + 1)` 这行代码，它不是在修改 `counter` 对象，而是创建了一个全新的 `Counter` 对象。`initialCounter` 永远都是 `Counter(0)`，而 `incrementedCounter` 是 `Counter(1)`。这种数据流的转变，在函数式编程里叫做值转换 (value transformation)。

为什么不可变性这么重要？

并发安全： 没有可变状态，多线程环境下的共享数据问题就少一大半。你不需要担心某个线程在修改数据的时候，另一个线程读取到了一个中间状态。
更容易推理： 一个 `val` 的值从创建开始就不会改变，你写代码的时候，看到这个变量，就能确定它的值，不用担心它在程序的其他地方被悄悄改了。
函数式编程基石： 函数式编程的核心就是“输入一个值，输出一个值”，纯函数不依赖外部状态，也不改变外部状态。不可变性让这一点更容易实现。

2. 用表达式 (Expressions) 而非语句 (Statements) 来构建逻辑。

Java 里有很多语句，比如 `ifelse` 是一个控制流语句，它不返回值。`for` 循环也是语句。你需要在它们外面写 `System.out.println()` 来输出结果。

Scala 里，一切皆表达式。

Java 风格的 Scala 错误用法：
```scala
// 只是为了打印，没有返回值
if (x > 10) {
println("Greater than 10")
} else {
println("Less than or equal to 10")
}

// 只是为了修改变量
for (i < 1 to 5) {
println(i)
}
```
地道 Scala 风格：
```scala
// ifelse 是表达式，可以直接赋给一个变量
val message = if (x > 10) "Greater than 10" else "Less than or equal to 10"
println(message)

// for 循环也可以是表达式 (通过 yield)
val numbers = for {
i < 1 to 5
// 可以加 guard (过滤)
// if i % 2 == 0
} yield i 2 // yield 出来的结果会组成一个新的集合

println(numbers) // 输出 Vector(2, 4, 6, 8, 10)
```
看到 `yield` 了吗？它把 `for` 循环变成了一个生成器，产生一个新的集合。这又回到了不可变性和值转换的思路。

3. 深入理解集合库 (Collections Library)。

Scala 的集合库是它的另一大杀器。它提供了大量函数式风格的操作，比如 `map`, `filter`, `fold`, `flatMap` 等等。而 Java 的集合操作，通常需要你手动迭代，写很多样板代码。

Java 风格的 Scala 操作：
```scala
val numbers = List(1, 2, 3, 4, 5)
val doubled = new java.util.ArrayList[Int]() // 显式创建一个可变集合

for (n < numbers) {
doubled.add(n 2) // 手动添加元素
}
println(doubled)
```
你看到了 `java.util.ArrayList`，看到了 `add()` 方法。这就是在用 Java 的方式操作集合。

地道 Scala 风格：
```scala
val numbers = List(1, 2, 3, 4, 5)

// 使用 map 来转换集合中的每个元素
val doubled = numbers.map(_ 2) // _ 是占位符，代表当前元素
println(doubled) // 输出 List(2, 4, 6, 8, 10)

// 使用 filter 来过滤集合中的元素
val evenNumbers = numbers.filter(_ % 2 == 0)
println(evenNumbers) // 输出 List(2, 4)

// 组合操作
val sumOfDoubledEvens = numbers.filter(_ % 2 == 0).map(_ 2).sum
println(sumOfDoubledEvens) // 输出 12 ( (22) + (42) )
```
`map` 和 `filter` 都返回新的集合，它们不会修改原始的 `numbers` 列表。这让你能够链式调用，将多个操作组合起来，非常简洁高效。

4. 善用模式匹配 (Pattern Matching)。

Java 里处理不同情况，你会用 `ifelse ifelse` 或 `switch`。Scala 的模式匹配比这强大得多，它不仅可以匹配值，还可以匹配类型、结构，甚至解构对象。

Java 风格的 Scala：
```scala
def processInput(input: Any): String = {
if (input.isInstanceOf[Int]) {
val num = input.asInstanceOf[Int] // 强制类型转换
if (num > 0) "Positive" else "Nonpositive"
} else if (input.isInstanceOf[String]) {
val str = input.asInstanceOf[String]
s"String: $str"
} else {
"Unknown type"
}
}
```
看到 `isInstanceOf` 和 `asInstanceOf` 了吗？这都是 Java 里处理不确定类型的常用方法，但在 Scala 里显得很繁琐且不安全。

地道 Scala 风格：
```scala
def processInput(input: Any): String = input match {
case n: Int if n > 0 => "Positive"
case n: Int if n <= 0 => "Nonpositive"
case s: String => s"String: $s"
case _ => "Unknown type" // _ 是通配符，匹配任何其他情况
}

println(processInput(5)) // 输出 Positive
println(processInput(3)) // 输出 Nonpositive
println(processInput("Scala")) // 输出 String: Scala
println(processInput(true)) // 输出 Unknown type
```
模式匹配 (`match`) 是一种非常强大的表达式。它清晰地表达了你对不同输入情况的处理逻辑，而且编译器会检查你是否穷尽了所有可能的情况（如果不是用 `_` 通配符的话），能帮你避免很多运行时错误。

5. 利用 Option 类型处理可能缺失的值。

Java 里处理一个方法可能返回 `null` 的情况，通常是 `if (result != null)` 这样的检查。Scala 提供了 `Option[T]` 类型来更安全、更声明式地处理这种情况。`Option[T]` 有两个子类：`Some[T]`（表示有值）和 `None`（表示没有值）。

Java 风格的 Scala：
```scala
def findUser(id: Int): User = {
// 假设数据库查询可能找不到
if (id == 1) User(1, "Alice") else null // 返回 null
}

val user = findUser(2)
if (user != null) {
println(user.name)
} else {
println("User not found")
}
```
`null` 是 Java 编程中的一个常见陷阱。

地道 Scala 风格：
```scala
// 假设 User case class 已定义
case class User(id: Int, name: String)

def findUser(id: Int): Option[User] = { // 返回 Option[User]
if (id == 1) Some(User(1, "Alice")) else None
}

// 安全地处理 Option
val userOption = findUser(2)

// 方法一：使用模式匹配
userOption match {
case Some(user) => println(s"Found user: ${user.name}")
case None => println("User not found")
}

// 方法二：使用 getOrElse
val userName = findUser(1).map(_.name).getOrElse("Unknown User")
println(s"User name: $userName") // 输出 User name: Alice

val anotherUserName = findUser(3).map(_.name).getOrElse("Unknown User")
println(s"User name: $anotherUserName") // 输出 User name: Unknown User
```
`Option` 类型强制你思考“有没有值”的情况，避免了 Java 里因 `NullPointerException` 而产生的许多意外。`map` 操作在 `Option` 上很优雅，它只在有值时应用函数，否则直接返回 `None`。

6. 理解隐式转换和隐式参数 (Implicits)。

这是 Scala 最强大也最容易被误用的特性之一。Java 没有类似的概念。如果你把隐式转换用在不恰当的地方，比如模仿 Java 的静态方法调用，那会很糟糕。

Java 风格的 Scala 使用隐式：
假设你想为一个 `String` 添加一个 `shout()` 方法：
```scala
// 错误示范：模仿 Java 的静态方法，或者直接在 String 类里加
// (当然你不能直接修改 String 类)

// 更好的方法是定义一个工具类
object StringUtils {
def shout(s: String): String = s.toUpperCase + "!!!"
}
// 之后调用是 StringUtils.shout(myString)

// 如果你非要用隐式，但方式不对：
implicit class ShoutHelper(s: String) {
def shout(): String = s.toUpperCase + "!!!"
}
// 这样写是没问题的，但如果你觉得这是 Java 的装饰器模式，那理解就浅了。
```
Scala 的 `implicit class` 是用来为现有类型添加方法的，它更像是一种语法糖，让你用起来更自然。核心是它创建了一个新的类型实例（`ShoutHelper`），然后调用其方法。

真正地道的使用隐式，更多是在函数式编程的上下文里：

作为函数参数的默认值：
```scala
def greet(name: String)(implicit greeting: String): String = s"$greeting, $name!"

implicit val defaultGreeting: String = "Hello"
println(greet("Alice")) // 编译器会自动找到并传入 defaultGreeting
```
这让你能够以一种非常灵活的方式传递上下文信息。

类型类模式 (Type Classes)： 这是 Scala 函数式编程的核心之一。例如，实现一个序列化或显示接口，可以为任何类型提供能力。
```scala
trait Show[A] {
def show(a: A): String
}

object ShowInstances {
implicit val intShow: Show[Int] = new Show[Int] {
def show(a: Int): String = a.toString
}
implicit val stringShow: Show[String] = new Show[String] {
def show(a: String): String = s""$a""
}
}

def display[A](value: A)(implicit s: Show[A]): Unit = {
println(s.show(value))
}

import ShowInstances._ // 导入隐式实例
display(123) // 输出 123
display("hello") // 输出 "hello"
```
`display` 函数不需要知道 `A` 具体是什么类型，只要有一个 `Show[A]` 的隐式实例存在，它就能工作。这是一种非常强大的代码泛化和扩展方式。

总结一下，避免写 Java 风格的 Scala，就是要牢牢记住：

拥抱不可变性 (val > var)。
将一切视为表达式，包括控制流。
用集合的函数式方法 (`map`, `filter`, `fold` 等) 进行数据处理。
善用模式匹配 (`match`) 来解构和处理数据。
利用 `Option` 等类型安全地处理可能缺失的值。
理解并恰当使用隐式，尤其是用于类型类和上下文传递，而不是简单地模仿 Java 的方法调用方式。

写 Scala 代码，就像是在学习一门新的语言，要抛弃一些旧的习惯，去体验它本身的哲学和优雅之处。刚开始可能会觉得别扭，但一旦你体会到函数式编程带来的简洁和力量，你就会觉得这些弯路是值得的。多看优秀的 Scala 开源项目，多练习，自然就能写出地道的 Scala 代码了。

不用避免。Scala是一门多范式编程语言，你可以同时使用多种范式，包括：

1. Java风格（例如：ThoughtWorksInc/each）
2. Haskell风格（例如：scalaz、Cats）
3. C++风格（例如：template.scala）
4. Idris风格（例如：milessabin/shapeless）
5. PHP风格（例如：Binding.scala）
6. 抽象工厂模式（例如：feature.scala/Factory）
7. 利用Haskell风格实现C++功能（例如：RAII.scala）
8. 利用抽象工厂模式解决Expression Problem（例如：DeepLearning.scala）

Scala的语言特性不算多，但是语言特性之间过于正交，一方面你把语言特性组合起来之后可以变得很复杂，写出各种其他语言的范式，另一方面容易玩脱。

不想玩脱的话，就得优先选用功能最弱的功能。只在弱的功能解决不了你面临的问题时，才用更强的功能。

李浩毅写了一篇Strategic Scala Style: Principle of Least Power，列举了面对各种状况下应该选择的语言功能。李浩毅和我一样，也写了许多Scala库，其中用各种Scala功能组合出强大的范式。然而，李浩毅认为该在默认情况下用的最弱功能却和这些高级范式无关，而是：

1. 尽量用不可变值（相当于Java的final变量）
2. 采用静态函数和内置数据结构设计API
3. 尽量使用JavaSE和Scala标准库的内置数据结构
4. 用Option代替异常处理和null
5. 尽量让函数立即返回值，而不要用异步编程
6. 手动传递参数，不要搞依赖注入

按李浩毅的意思，首选的Scala风格大致和Java风格一个样，甚至可能比一般的Java风格还要弱，因为不允许使用非final的变量了。

你可以看到Scala的创始人Martin Odersky也在李浩毅博客下面举双手赞成。所以，Scala社区公认的首选Scala风格就是阉割版的Java风格，不但不需要避免，反而应该是你追求的目标。