1. 简介
在本教程中，我们将探讨 Scala 和 Kotlin 的关键特性，它们是 JVM 上除 Java 外最受欢迎的编程语言。
我们还将了解它们之间的对比，以及在哪些情况下它们可能比 Java 更适合使用。
2. 关键特性
我们先来看看 Scala 和 Kotlin 的主要特性，这有助于我们后续的讨论。
2.1. Scala
Scala 的设计由 Martin Odersky 于 2001 年在 EPFL 启动。其名称是“scalable”和“language”的合成词。当时，尽管 Java 迅速发展，但由于需要保持向后兼容性，其灵活性受到限制。这促使了基于 join calculus 的 Funnel 项目诞生，但 Funnel 并不实用，最终催生了 Scala。
Scala 是一种通用编程语言，支持面向对象和函数式编程，其源码编译为 Java 字节码，因此可在任何 JVM 上运行，并与 Java 完全互操作。
Scala 增加了许多 Java 所缺乏的功能，这些功能受到 Scheme、Standard ML 和 Haskell 等语言的启发。
2.2. Kotlin
Kotlin 是 JetBrains 于 2011 年推出的较新语言，该公司也开发了流行的 IDE IntelliJ IDEA。虽然设计目标与 Scala 相似，但 Kotlin 的目标是改进 Scala 的不足之处，尤其是其编译速度慢的问题。
Kotlin 是一种多范式、面向对象的语言，旨在比 Java 更优秀，并保持与 Java 的完全互操作性，便于 Java 开发者逐步采用。2019 年，Google 宣布 Kotlin 成为 Android 平台的首选语言。
Kotlin 也支持多平台编程，除了 JVM 外，还可以编译为 JS 和原生平台代码。Kotlin 是一种轻量级语言，并通过扩展库提供序列化、并发等高级功能。
3. 类型系统
类型系统是任何编程语言的核心特性之一，它定义了变量、函数或表达式等语言结构的类型规则。
类型系统可以是静态或动态的，分别在编译时和运行时进行类型检查。此外，参数化类型（泛型）允许我们编写通用类和函数，提高代码复用性和类型安全性。
3.1. Scala 类型系统
Scala 是一种静态类型语言，其类型系统比 Java 更加复杂和全面。它有一个统一的类型层次结构，其中 Any 是所有类型的超类，有两个直接子类：
AnyVal：表示值类型AnyRef：表示引用类型（即 Java 对象）
此外，还有 Null（所有引用类型的子类）和 Nothing（所有类型的子类）。
Scala 支持泛型类，例如：
class Garage[+A]
默认情况下，泛型类是不变的，但可以通过声明点变体（declaration-site variance）来使其协变或逆变：
class Garage[+A]
val myGarage: Garage[Vehicle] = new Garage[Car] // 合法
还可以通过类型边界限制泛型参数：
class Garage[T <: Vehicle] { }
class Garage[T >: Car] { }
3.2. Kotlin 类型系统
Kotlin 也是静态类型语言，但其类型系统更简单。它明确区分可空类型和非空类型，其中：
Any：非空类型的超类Any?：可空类型的超类
Kotlin 中的 Unit 相当于 Java 的 void，而 Nothing 表示非终止类型。
Kotlin 支持泛型类：
class Garage<T>
默认也是不变的，但支持声明点变体和使用点变体（use-site variance）：
class Garage<out T>
var myGarage: Garage<Vehicle> = Garage<Car>() // 合法
class Garage<in T>
var myGarage: Garage<Car> = Garage<Vehicle>() // 合法
还可以使用星投影（star projection）处理未知类型参数：
fun transfer(from: Garage<*>, to: Garage<Vehicle>) {}
同样支持类型边界：
class Garage<T: Vehicle> { }
class Garage<T> where T: Vehicle, T: Electric { }
4. 面向对象编程支持
面向对象编程（OOP）是一种以对象为核心的编程范式，对象包含数据（属性）和行为（方法），并遵循封装、继承、多态等原则。
Java 从诞生起就是面向对象的，而 Scala 和 Kotlin 在此基础上提供了更丰富的特性。
4.1. Scala 的 OOP 支持
Scala 是基于类的面向对象语言，类可以包含方法、变量、类型、对象、特质（trait）等：
class Car(var make: String, var model: String) {
val description = s"($make, $model)"
}
成员默认是 public，但可以使用 private 等修饰符限制访问。
Scala 提供单例对象（singleton object）和伴生对象（companion object）来模拟 Java 的静态成员。
object Logger {
def info(message: String): Unit = println(s"INFO: $message")
}
抽象类和 trait 是 Scala 中实现抽象的方式，trait 支持多继承：
trait Electric {
def recharge: Unit
}
trait Insured {
def renew: Unit
}
class Car extends Vehicle with Electric with Insured { ... }
还可以使用自类型（self-type）强制 trait 的混入：
trait Electric {
this: Insured =>
def recharge: Unit
}
4.2. Kotlin 的 OOP 支持
Kotlin 也是基于类的面向对象语言，类可以有主构造器和初始化块：
class Car(var make: String, var model: String) {
val description = "($make, $model)"
init {
print(description)
}
}
默认可见性为 public，属性的 getter/setter 自动生成。
类默认是 final，需要使用 open 才能继承：
open class Vehicle
class Bike: Vehicle()
Kotlin 提供单例对象和伴生对象（companion object）：
object Logger {
fun info(message: String) { println("INFO: $message") }
}
class Bike: Vehicle() {
companion object {
private fun log(message: String) { Logger.info(message) }
}
}
Kotlin 支持扩展函数（extension functions），无需继承即可为类添加新功能：
fun Bike.start() {
Logger.info("Starting")
}
抽象类和接口用于抽象化，接口不能保存状态：
interface Electric {
fun recharge()
}
interface Insured {
fun renew()
}
支持多接口继承，但只能继承一个类：
class Bike: Vehicle(), Electric, Insured { ... }
还支持委托（delegation）作为继承的替代方案：
class BaseInsured: Insured {
override fun renew() { Logger.info("Renewing") }
}
class Bus(insured: Insured) : Vehicle(), Insured by insured { ... }
5. 函数式编程支持
函数式编程是一种声明式范式，将函数视为一等公民，强调不可变性和组合函数。
Java 8 开始引入了一些函数式特性，但 Scala 和 Kotlin 提供了更全面的支持。
5.1. Scala 的函数式支持
函数在 Scala 中是一等公民：
val myFunction = (x:Int) => x*2
支持高阶函数：
def handle(number: Int, function: Int => Int): Int = function(number)
支持嵌套函数和柯里化（currying）：
def weight(gravity: Double) = (mass: Double) => mass*gravity
支持不可变数据（case class）：
case class Planet(gravity: Double)
支持尾递归优化（tail recursion）：
@tailrec
def next(x: Int, result: Int): Int = {
if(x == 1) result
else next(x-1, result*x)
}
5.2. Kotlin 的函数式支持
Kotlin 也支持函数作为一等公民：
val myFunction = {x: Int -> x*2}
支持高阶函数和内联函数（inline）以减少内存开销：
inline fun handle(number: Int, function: (Int) -> Int): Int = function(number)
支持嵌套函数和柯里化函数：
fun weight(gravity: Double) = {mass: Double -> mass*gravity}
支持不可变数据类（data class）：
data class Planet(val gravity: Double)
支持尾递归优化：
tailrec fun next(x: Int, result: Int): Int {
return if (x == 1) result
else next(x - 1, result * x)
}
6. 其他语言特性
除了上述特性，还有一些其他语言特性值得比较，它们在 Java 中表现不佳或缺失。
6.1. 空安全（Null Safety）
Java 的 null 引用被称为“十亿美元的错误”。Scala 和 Kotlin 都对此进行了改进。
Scala 的空安全
Scala 强制变量必须初始化，但允许赋值 null：
val x: String = null // 合法
推荐使用 Option 类来处理可能为 null 的情况：
def findCar(model: String): Option[Car] = {
val cars = Map("Ford" -> new Car("Ford"))
cars.get(model)
}
Kotlin 的空安全
Kotlin 默认不允许变量为 null，必须显式声明可空类型：
val x: String = null // 非法
val x: String? = null // 合法
使用安全调用 ?. 或非空断言 !! 来处理可空类型：
println(x?.length) // 安全调用
println(x!!.length) // 非空断言
6.2. 模式匹配（Pattern Matching）
Scala 的模式匹配非常强大，常用于 match 表达式和 case class 解构：
def dayOfWeek(x: Int): String = x match {
case 1 => "Monday"
case 2 => "Tuesday"
case _ => "other"
}
Kotlin 使用 when 块实现类似功能：
fun dayOfWeek(x: Int): String {
return when (x) {
1 -> "Monday"
2 -> "Tuesday"
else -> "other"
}
}
Kotlin 的模式匹配功能不如 Scala 强大，特别是在序列匹配方面。
6.3. 异常处理（Exception Handling）
Java 支持检查异常（checked exceptions）和非检查异常（unchecked exceptions），但检查异常一直饱受争议。
Scala 的异常处理
Scala 不支持检查异常，使用 try-catch-finally 结构，并支持模式匹配：
def divide(x: Double, y: Double): Double = {
if (y == 0) throw IllegalArgumentException
x / y
}
def performDivision(x: Double, y: Double) = {
try {
divide(x, y)
} catch {
case ex: IllegalArgumentException => println(ex.getMessage)
} finally {
println("Performing cleanup")
}
}
Kotlin 的异常处理
Kotlin 同样不支持检查异常，语法与 Scala 类似，但不支持 catch 块中的模式匹配：
fun divide(x: Double, y: Double): Double {
if (y == 0.0) throw IllegalArgumentException("Illegal argument")
return x / y
}
fun performDivision(x: Double, y: Double) {
try {
divide(x, y)
} catch (ex: IllegalArgumentException) {
println(ex.message)
} finally {
println("Performing cleanup")
}
}
7. 总结
本教程对 Kotlin 和 Scala 进行了全面对比，涵盖类型系统、OOP 和函数式编程特性。
| 特性 | Scala | Kotlin |
|---|---|---|
| 类型系统 | 强大、支持声明点变体、类型边界 | 简洁、支持声明点/使用点变体、类型边界 |
| OOP | 支持 trait、自类型、伴生对象 | 支持扩展函数、委托、伴生对象 |
| 函数式编程 | 支持柯里化、尾递归、模式匹配 | 支持高阶函数、内联、尾递归 |
| 空安全 | Option 类型 | 可空类型系统 |
| 异常处理 | 不支持检查异常、支持模式匹配 | 不支持检查异常 |
| 编译性能 | 较慢 | 更快 |
| Android 支持 | 有限 | 官方推荐 |
✅ 如果你需要强大的类型系统和丰富的函数式特性，选择 Scala
✅ 如果你需要更快的编译速度和 Android 支持，选择 Kotlin