1. 为什么从Java迁移到Kotlin

1.1 Kotlin的核心优势

简洁性：

减少约40%的样板代码（基于JetBrains官方数据）
类型推断让代码更简洁
数据类（data class）自动生成equals()、hashCode()等方法

安全性：

编译时空指针检查（著名的NPE防御）
不可变集合作为默认选择
强制异常处理策略更灵活

互操作性：

100%兼容JVM平台
可直接调用Java代码，反之亦然
与现有Java框架无缝集成（Spring、Android等）

现代特性：

扩展函数（无需继承即可扩展类功能）
协程（轻量级线程解决方案）
类型安全的DSL构建能力

1.2 实际案例

大型企业采用情况：

Google官方宣布Kotlin为Android开发首选语言
Spring Framework 5.0+全面支持Kotlin
Twitter、Netflix、Uber等公司核心业务采用案例

生产力提升数据：

代码行数减少30-50%
NPE相关崩溃减少90%+
开发速度提升约20%（基于JetBrains调查）

1.3 JVM生态定位

与Java的关系：

不是替代，而是增强
共享相同的字节码和运行时环境
互补关系：Java适合底层/高性能场景，Kotlin适合业务逻辑

与Scala的比较：

比Scala更轻量
学习曲线更平缓
编译速度更快

2. 开发环境搭建

2.1 IDE配置（IntelliJ IDEA为例）

必要插件：

Kotlin插件（已内置在新版IDEA中）
Kotlin-Java互转换工具

推荐设置：

File -> Settings -> Editor -> Code Style -> Kotlin
建议设置缩进为4空格，保持与Java一致

实用快捷键：

Alt+Enter：快速修复建议
Ctrl+Alt+L：格式化代码
Ctrl+Shift+K：Java转Kotlin

2.2 构建工具配置

Gradle配置示例（Kotlin DSL）：

plugins {
    kotlin("jvm") version "1.8.0"
    application
}

dependencies {
    implementation(kotlin("stdlib"))
    testImplementation(kotlin("test"))
}

Maven配置示例：


    1.8.0



    
        org.jetbrains.kotlin
        kotlin-stdlib
        ${kotlin.version}

2.3 混合项目实践

渐进式迁移策略：

新文件用Kotlin编写
修改旧文件时转换为Kotlin
单元测试层优先迁移（风险最低）

注意事项：

编译顺序：Kotlin文件先于Java文件编译
注解处理需要额外配置（kapt）
反射功能需要添加kotlin-reflect依赖

3. 基础语法对比

3.1 变量声明

不可变变量：

// Java
final String name = "Kotlin";

// Kotlin
val name = "Kotlin"  // 类型推断为String
val explicitType: String = "Kotlin"

可变变量：

// Java
int count = 0;
count = 1;

// Kotlin
var count = 0
count = 1  // 可以重新赋值
// count = "string"  // 编译错误，类型已推断为Int

类型系统关键差异：

Kotlin所有类型默认不可为null
必须显式声明可空类型：val nullable: String? = null
平台类型（来自Java的变量）：String!表示可能为null

3.2 函数定义

基本函数对比：

// Java
public String greet(String name) {
    return "Hello, " + name;
}

// Kotlin
fun greet(name: String): String {
    return "Hello, $name"
}

// 表达式体简写
fun greet(name: String) = "Hello, $name"

默认参数（Java需要重载实现）：

fun connect(
    host: String, 
    port: Int = 80, 
    timeout: Int = 1000
) { /*...*/ }

// 调用方式
connect("example.com")  // 使用默认port和timeout
connect("example.com", timeout = 2000)  // 命名参数

顶级函数（不需要类包装）：

// File: StringUtils.kt
fun String.capitalizeWords(): String {
    return split(" ").joinToString(" ") { it.capitalize() }
}

// 任何地方可调用
"hello world".capitalizeWords()  // 返回 "Hello World"

3.3 字符串处理

多行字符串：

// Java
String html = "\n" +
              "    \n" +
              "        Hello\n" +
              "    \n" +
              "";

// Kotlin
val html = """
    
        
            Hello
        
    
""".trimIndent()

字符串模板：

// Java
String message = "User " + name + " has " + items.size() + " items";

// Kotlin
val message = "User $name has ${items.size} items"

4. 流程控制结构

4.1 when表达式（强化版switch）

基础用法：

// Java
switch (status) {
    case 0: type = "Pending"; break;
    case 1: type = "Processing"; break;
    case 2: type = "Completed"; break;
    default: type = "Unknown";
}

// Kotlin
val type = when (status) {
    0 -> "Pending"
    1 -> "Processing"
    2 -> "Completed"
    else -> "Unknown"  // 必须包含else分支
}

高级特性：

支持任意表达式作为分支条件
可以省略参数直接作为布尔表达式使用
支持智能类型转换

when {
    x.isOdd() -> print("x is odd")
    y.isEven() -> print("y is even")
    else -> print("x+y is even")
}

when (obj) {
    is String -> print(obj.length)  // 自动转换为String
    !is String -> print("Not a string")
}

4.2 范围表达式

区间表示法：

val range = 1..10  // 闭区间[1,10]
val untilRange = 1 until 10  // 半开区间[1,10)
val downTo = 10 downTo 1  // 递减区间
val stepRange = 1..10 step 2  // 1,3,5,7,9

应用场景：

// 替代传统for循环
for (i in 1..10) { print(i) }

// 集合过滤
val filtered = list.filter { it in 1..100 }

// when表达式中使用
when (score) {
    in 90..100 -> "A"
    in 80..89 -> "B"
    else -> "C"
}

4.3 循环结构优化

集合遍历：

// Java
for (String item : items) {
    System.out.println(item);
}

// Kotlin
for (item in items) {
    println(item)
}

// 带索引遍历
for ((index, item) in items.withIndex()) {
    println("$index: $item")
}

函数式风格操作：

items.forEach { println(it) }
items.forEachIndexed { index, item -> println("$index: $item") }

范围循环：

// 递减循环
for (i in 10 downTo 1) {
    println(i)
}

// 步长控制
for (i in 1..10 step 2) {
    println(i)
}

5. 空安全设计

5.1 可空类型系统

基本概念：

var neverNull: String = "Kotlin"  // 不可为null
neverNull = null  // 编译错误

var nullable: String? = "Kotlin"  // 可null
nullable = null  // 允许

安全调用操作符（?.）：

// Java
String city = null;
String street = null;
if (user != null && user.address != null) {
    street = user.address.street;
}

// Kotlin
val street = user?.address?.street  // 任一为null则返回null

Elvis操作符（?:）：

val length = nullableString?.length ?: 0  // 如果为null则返回0

5.2 非空断言

!!操作符（谨慎使用）：

val length = nullableString!!.length  // 如果为null则抛出NPE

最佳实践：

尽量避免使用!!
用lateinit var替代var foo: Foo? = null的初始化模式
合约函数（contract）提供更灵活的null检查

5.3 平台类型处理

Java互操作时的类型：

// Java方法：public String getName() { ... }
val name = javaClass.name  // 类型为"String!"（平台类型）

// 推荐处理方式
val safeName: String = javaClass.name ?: "default"  // 明确处理null情况

6. 类型检查与转换

6.1 智能类型转换

Java风格：

if (obj instanceof String) {
    String str = (String) obj;
    System.out.println(str.length());
}

Kotlin智能转换：

if (obj is String) {
    println(obj.length)  // 自动转换为String类型
}

when表达式中的智能转换：

when (shape) {
    is Circle -> println("Radius: ${shape.radius}")
    is Rectangle -> println("Area: ${shape.width * shape.height}")
}

6.2 安全转换操作符

as? 安全转换：

val intValue: Int? = number as? Int  // 转换失败返回null

对比Java的强制转换：

// Java
try {
    int value = (int) obj;
} catch (ClassCastException e) {
    // 处理异常
}

7. 异常处理

7.1 基本语法对比

// Java
try {
    FileReader reader = new FileReader("file.txt");
} catch (IOException e) {
    System.err.println("Error reading file");
} finally {
    // 清理资源
}

// Kotlin
try {
    val reader = FileReader("file.txt")
} catch (e: IOException) {
    System.err.println("Error reading file")
} finally {
    // 清理资源
}

7.2 Kotlin异常特性

差异点：

所有异常都是unchecked（不需要声明throws）
try可以作为表达式使用

try表达式示例：

val number = try {
    input.toInt()
} catch (e: NumberFormatException) {
    null  // 解析失败返回null
}

8. 基本类型与数组

8.1 基本类型处理

与Java的对应关系：

Kotlin没有原始类型（primitive type）的概念
编译时会优化为Java原始类型（如Int变为int）

特殊类型：

Unit ≈ void（但是一个真实类型）
Nothing：永远不返回的函数返回类型

8.2 数组差异

创建方式：

// Kotlin数组是类（Array）
val array = arrayOf(1, 2, 3)
val primitiveArray = intArrayOf(1, 2, 3)  // 对应Java的int[]

// 与Java互操作
val javaArray: Array = javaMethodReturningArray()

注意事项：

避免在性能关键路径使用泛型数组
与Java互操作时注意平台类型问题

9. 代码风格与惯用法

9.1 命名约定

与Java的主要差异：

包名：全小写，不使用复数（com.example.util）
函数/变量名：驼峰式，但首字母可小写
常量：const val MAX_SIZE = 10（位于顶层或object中）

9.2 代码组织

文件结构：

一个文件可以包含多个类/顶级函数
推荐按功能而非严格按类组织文件

导入差异：

支持导入单个函数：import com.example.util.formatDate
默认导入的包比Java更多（包括kotlin.*等）

10. 实用转换技巧

10.1 Java到Kotlin的惯用转换

常见模式转换表：

Java模式	Kotlin惯用法
Utils类+静态方法	顶级扩展函数
Builder模式	命名参数+默认值
Singleton	object声明
POJO	data class

10.2 自动转换工具

IntelliJ转换功能：

选中Java代码
右键选择"Convert Java File to Kotlin File"
检查并优化转换结果

转换后常见优化点：

将if语句转换为when表达式
移除多余的?.let块
简化getter/setter为属性

结语

上篇内容涵盖了从Java迁移到Kotlin所需的基础知识，重点在于两种语言在基础语法层面的对比。掌握这些内容后，Java开发者已经可以开始编写基本的Kotlin代码。中篇将深入探讨面向对象设计、函数式编程等更高级的主题，帮助开发者充分利用Kotlin的强大特性。

Java开发者迁移到Kotlin指南(上篇)