从 Java 到 Kotlin 语法平滑迁移指南

3. 数据类

Kotlin 的 data class 让创建简单的数据对象变得非常简单，而 Java 中需要写很多模板代码。

// Java
public class User {
    private String name;
    private int age;
    // 需要 getter/setter、equals、hashCode、toString 等方法
}

// Kotlin
data class User(val name: String, val age: Int)
// 自动生成 equals、hashCode、toString、copy 等方法

4. 扩展函数

扩展函数允许在不修改原始类的情况下为现有类添加新功能。

// Java - 需要工具类
public class StringUtil {
    public static String capitalize(String str) {
        return str.substring(0, 1).toUpperCase() + str.substring(1);
    }
}
String result = StringUtil.capitalize("hello");

// Kotlin - 扩展函数
fun String.capitalize(): String {
    return this.substring(0, 1).uppercase() + this.substring(1)
}
val result = "hello".capitalize() // 直接调用

5. Lambda 表达式简化

Kotlin 的 Lambda 表达式语法更加简洁，特别适合事件处理和回调。

button.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {
        // 处理点击
    }
});

button.setOnClickListener { // 处理点击，it 代表 View 参数
    it.visibility = View.GONE
} // 或明确参数名
button.setOnClickListener { view -> view.visibility = View.GONE }

6. 尾随 Lambda 和函数类型

Kotlin 支持尾随 Lambda 语法，使高阶函数调用更加优雅。

// 回调需要接口
interface OnResult {
    void onSuccess(String data);
    void onError(String message);
}
void fetchData(OnResult callback) {
    // ...
}
// 使用
fetchData(new OnResult() {
    @Override
    public void onSuccess(String data) { /* ... */ }
    @Override
    public void onError(String message) { /* ... */ }
});

// 使用 - 尾随 Lambda 语法
fetchData(
    onSuccess = { data -> println("成功：$data") },
    onError = { error -> println("错误：$error") }
)
// 如果最后一个参数是 Lambda，可以移到括号外
fetchData { data -> println("成功：$data") }
// 注意：这只适用于单个 Lambda 参数的情况

7. when 表达式

Kotlin 的 when 表达式比 Java 的 switch 语句更强大、更灵活。

switch(status) {
    case 0: text = "初始状态"; break;
    case 1: text = "进行中"; break;
    default: text = "未知";
}

val text = when (status) {
    0 -> "初始状态"
    1 -> "进行中"
    else -> "未知"
}
// 还可以判断类型
when (obj) {
    is String -> println("字符串：$obj")
    is Int -> println("整数：$obj")
}

8. 字符串模板

Kotlin 的字符串模板使字符串拼接更加直观和简洁。

String message = "Hello, " + name + "! You have " + count + " messages.";

val message = "Hello, $name! You have $count messages."
val detailed = "Name length: ${name.length}" // 表达式

9. 默认参数和命名参数

Kotlin 支持默认参数和命名参数，减少了方法重载的需要。

public void showDialog(String title, String message) {
    showDialog(title, message, true);
}
public void showDialog(String title, String message, boolean cancelable) {
    // 实现
}

fun showDialog(title: String, message: String, cancelable: Boolean = true) {
    // 实现
}
// 使用
showDialog("提示", "操作成功")
showDialog("确认", "是否删除？", cancelable = false) // 命名参数

10. 集合操作

Kotlin 提供了丰富的函数式集合操作，使数据处理更加简洁。

List<String> filtered = new ArrayList<>();
for (String item : list) {
    if (item.startsWith("A")) {
        filtered.add(item.toUpperCase());
    }
}

val filtered = list
    .filter { it.startsWith("A") }
    .map { it.uppercase() } // 链式调用

11. 类型推断和智能转换

Kotlin 具有强大的类型推断能力，并且支持智能转换，减少了显式类型转换的需要。

Object obj = getObject();
if (obj instanceof String) {
    String str = (String) obj; // 需要显式转型
    System.out.println(str.length());
}

val obj: Any = getObject()
if (obj is String) {
    println(obj.length) // 自动智能转换为 String 类型
    // 在 if 作用域内，obj 已经是 String 类型
}
// when 表达式中的智能转换
when (obj) {
    is String -> println(obj.length) // 这里 obj 是 String
    is Int -> println(obj + 1) // 这里 obj 是 Int
}

12. 泛型

Kotlin 的泛型系统在 Java 的基础上进行了改进，提供了更安全的类型参数约束。

// 1. 定义一个泛型函数
fun <T> printItem(item: T) {
    // T 是函数的类型参数
    println("物品：$item")
}
// Any 是所有类型的父类
fun <T : Any> processNonNull(value: T) {
    // T 必须是非空类型
    println("值：$value")
}
// 2. 使用泛型函数
fun main() {
    printItem("字符串") // Kotlin 自动推断 T 为 String
    printItem(100) // Kotlin 自动推断 T 为 Int
    printItem(3.14) // Kotlin 自动推断 T 为 Double
    printItem(true) // Kotlin 自动推断 T 为 Boolean
    printItem(listOf("A", "B", "C")) // T 被推断为 List<String>
}

13. 密封类

密封类（Sealed Class）用于表示受限的类层次结构，是枚举类的扩展。

public abstract class Result {
    private Result() {}
    public static class Success extends Result {
        private final String data; // getter...
    }
    public static class Error extends Result {
        private final String message; // getter...
    }
}

sealed class Result {
    data class Success(val data: String) : Result()
    data class Error(val message: String) : Result()
}
// 使用时，when 表达式可以检查所有分支
fun handleResult(result: Result) {
    when (result) {
        is Result.Success -> println("成功：${result.data}")
        is Result.Error -> println("错误：${result.message}")
        // 不需要 else 分支，因为密封类已覆盖所有情况
    }
}

14. 构造器语法简化

Kotlin 的主构造函数语法大大简化了类的定义。

public class Person {
    private String name;
    private int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

class Person(val name: String, val age: Int) {
    // 初始化块
    init {
        require(age >= 0) { "年龄不能为负数" }
    }
    // 次构造函数
    constructor(name: String) : this(name, 0)
}
// 使用
val person = Person("Alice", 25)

15. 解构声明

解构声明（Destructuring Declarations）允许将对象属性解构为多个变量。

Point point = new Point(10, 20);
int x = point.getX();
int y = point.getY();

data class Point(val x: Int, val y: Int)
// 解构
val (x, y) = Point(10, 20)
println("x=$x, y=$y") // 输出：x=10, y=20
// 在循环中使用
val points = listOf(Point(1, 2), Point(3, 4))
for ((xCoord, yCoord) in points) {
    println("坐标：($xCoord, $yCoord)")
}
// 忽略某些值
val (_, justY) = Point(10, 20) // 只获取 y 值

16. 范围表达式

Kotlin 的范围表达式提供了更直观的范围操作。

for (int i = 1; i <= 10; i++) {
    System.out.println(i);
}
if (score >= 0 && score <= 100) {
    System.out.println("有效分数");
}

for (i in 1..10) { // 包含边界
    println(i)
}
for (i in 1 until 10) { // 不包含 10
    println(i)
}
for (i in 10 downTo 1) { // 递减
    println(i)
}
if (score in 0..100) { // 范围检查
    println("有效分数")
}
if (score !in 0..100) { // 不在范围内
    println("无效分数")
}

17. 作用域函数

Kotlin 的作用域函数（let, also, run, with, apply）提供了在对象的上下文中执行代码块的能力。

// 创建一个 Person 对象实例
val person = Person("Alice", 25)
// 1. let - 非空执行，最后一行作为返回值
// let 函数在对象非空时执行 lambda，返回 lambda 的最后一行结果
// 通常用于：空安全检查、转换对象、链式调用
val result = person?.let { it.age * 2 } ?: 0
// 最终 result 的值：person.age * 2 = 25 * 2 = 50，或如果 person 为 null 则返回 0
// 2. apply - 返回对象本身，适合配置对象
// apply 函数执行 lambda，但返回调用者对象本身（this）
// 通常用于：对象初始化、配置属性
val configuredPerson = Person().apply {
    name = "Bob"
    age = 30
}
// 返回配置好的 Person 对象本身
// 3. also - 返回对象本身，适合附加操作
// also 函数执行 lambda，但返回调用者对象本身
// 与 apply 类似，但 also 使用 it 引用对象，apply 使用 this
// 通常用于：添加副作用、调试、验证
val copy = person.also { println("复制了：${it.name}") }
// 返回 person 对象本身，copy 和 person 指向同一个对象
// 4. run - 执行代码块，返回最后一行
// run 函数有两种形式：扩展函数形式（如这里）和普通函数形式
// 返回 lambda 的最后一行结果
// 通常用于：计算值、执行多个操作
val ageAfterYears = person.run {
    age + 5 // 最后一行作为返回值，计算 5 年后的年龄
}
// ageAfterYears 的值：person.age + 5 = 25 + 5 = 30
// 5. with - 类似 run，但作为函数调用
// with 不是扩展函数，而是将对象作为参数传递
// 返回 lambda 的最后一行结果
// 通常用于：在一个对象上执行多个操作而不需要结果
with(person) {
    println("$name is $age years old")
}
// 返回 Unit，因为最后一行是 println 语句

18. 伴生对象替代静态方法

Kotlin 使用伴生对象（Companion Object）来替代 Java 的静态成员。

public class Utils {
    public static final String TAG = "Utils";
    public static int add(int a, int b) {
        return a + b;
    }
}
// 使用
int sum = Utils.add(1, 2);

class Utils {
    companion object {
        const val TAG = "Utils"
        fun add(a: Int, b: Int): Int = a + b
    }
}
// 使用（类似静态调用）
val sum = Utils.add(1, 2)
// 或者在 Java 中调用
// Java 代码中：Utils.Companion.add(1, 2);

19. 单例对象

Kotlin 通过 object 关键字提供了一种简洁的单例实现方式。

// 使用 object 关键字
object Singleton {
    private const val TAG = "Singleton"
    fun doSomething() {
        println("Doing something")
    }
    init {
        println("单例初始化")
    }
}
// 使用（直接调用，无需 getInstance）
Singleton.doSomething()

// 双重校验锁 - 线程安全且高效
class Singleton private constructor() {
    companion object {
        @Volatile
        private var INSTANCE: Singleton? = null
        fun getInstance(): Singleton {
            return INSTANCE ?: synchronized(this) {
                INSTANCE ?: Singleton().also { INSTANCE = it }
            }
        }
    }
    fun doSomething() {
        println("Singleton 执行操作")
    }
}
// 使用：Singleton.getInstance().doSomething()

// 伴生对象 + lazy - 懒汉式（首次使用时初始化）
class Singleton private constructor() {
    companion object {
        // 使用 lazy 委托实现懒加载
        val instance: Singleton by lazy(LazyThreadSafetyMode.SYNCHRONIZED) {
            println("Singleton2 初始化 - 懒汉式")
            Singleton()
        }
    }
    fun doSomething() {
        println("Singleton 执行操作")
    }
}
// 使用：Singleton.instance.doSomething()

20. 协程替代异步任务

Kotlin 协程提供了更简洁、更强大的异步编程解决方案。

new AsyncTask<Void, Void, String>() {
    @Override
    protected String doInBackground(Void... voids) {
        return fetchData(); // 后台执行
    }
    @Override
    protected void onPostExecute(String result) {
        updateUI(result); // UI 线程更新
    }
}.execute();

// lifecycleScope 与 Activity/Fragment 生命周期绑定
// launch 默认在调用者的线程（通常是主线程）启动一个新的协程
lifecycleScope.launch {
    // withContext 临时切换到 Dispatchers.IO 线程，执行完后返回原线程
    val result = withContext(Dispatchers.IO) {
        fetchData()
    }
    // 自动切换回主线程
    updateUI(result)
}

21. Kotlin 序列化

Kotlin 提供了现代化的序列化解决方案，比传统的 Java 序列化更安全、更高效。

import kotlinx.serialization.*
import kotlinx.serialization.json.*
// 1. 声明可序列化类
@Serializable
data class User(
    val name: String,
    val age: Int,
    @SerialName("email_address") // 自定义序列化名称
    val email: String,
    @Transient // 不序列化
    val password: String? = null
)
// 2. JSON 序列化
val json = Json { prettyPrint = true; ignoreUnknownKeys = true }
val userBean = User("Alice", 25, "[email protected]")
val jsonString = json.encodeToString(userBean)
println(jsonString)
// 3.1 反序列化对象
val decodedUserBean = json.decodeFromString<User>(jsonString)
println(decodedUserBean)
// 3.2 反序列化列表
val decodedList = json.decodeFromString<List<User>>(jsonListString)
println("\n反序列化结果:")
decodedList.forEach { user ->
    println("${user.name}, ${user.age}, ${user.email}")
}

22. Kotlin 图片加载

Kotlin 生态提供了简洁强大的图片加载解决方案。

import coil.load
import coil.transform.CircleCropTransformation
import coil.transform.RoundedCornersTransformation
// 1. 简单加载
imageView.load("https://example.com/image.jpg")
// 2. 带配置
imageView.load(url) {
    crossfade(true) // 淡入效果
    placeholder(R.drawable.placeholder)
    error(R.drawable.error)
    transformations(CircleCropTransformation()) // 圆形
    // 或圆角
    transformations(RoundedCornersTransformation(16f))
}
// 3. 更多配置
imageView.load(url) {
    size(200, 200) // 指定大小
    scale(Scale.FIT)
    memoryCacheKey(cacheKey) // 缓存控制
    diskCacheKey(cacheKey)
    allowHardware(false) // 硬件加速
}

Kotlin 与 Java 的完全兼容性确保了平稳的迁移路径，开发者可以逐步将现有 Java 项目迁移到 Kotlin，或在新项目中直接采用 Kotlin。随着 Kotlin 在 Android 生态中的日益普及，掌握这门语言将成为 Android 开发者的核心竞争力。