Kotlin与Java语法对比学习
定义变量
// Kotlin
val i: Int = 10 // 定义一个整数变量
val d: Double = 10.0 // 定义一个双精度浮点数变量
val b: Boolean = true // 定义一个布尔变量
val c: Char = 'a' // 定义一个字符变量
val s: String = "Hello, World!" // 定义一个字符串变量
val arr: Array<Int> = arrayOf(1, 2, 3) // 定义一个整数数组
val ui: UInt = 10u // 定义一个无符号整数变量
// Java
int i = 10; // 定义一个整数变量
double d = 10.0; // 定义一个双精度浮点数变量
boolean b = true; // 定义一个布尔变量
char c = 'a'; // 定义一个字符变量
String s = "Hello, World!"; // 定义一个字符串变量
int[] arr = {1, 2, 3}; // 定义一个整数数组
// java不支持无符号整数变量
类型检测
// Kotlin
if (obj is String) { val str = obj as String } // 类型检测与类型转换
// Java
if (obj instanceof String) { String str = (String) obj; } // 类型检测与类型转换
控制流
// Kotlin
val max = if (a > b) a else b // 条件表达式
when (x) { 1 -> print("x == 1") else -> print("x != 1") } // when表达式，类似于Java的switch
for (item in collection) println(item) // for循环
while (x > 0) x-- // while循环
// Java
int max = (a > b) ? a : b; // 条件表达式
switch (x) { case 1: System.out.println("x == 1"); break; default: System.out.println("x != 1"); } // switch语句
for (Object item : collection) System.out.println(item); // for-each循环
while (x > 0) x--; // while循环
…
// Kotlin
for (i in 1..10) { if (i == 5) break } // 使用break跳出循环
for (i in 1..10) { if (i % 2 == 0) continue; println(i) } // 使用continue跳过当前迭代
// Java
for (int i = 1; i <= 10; i++) { if (i == 5) break; } // 使用break跳出循环
for (int i = 1; i <= 10; i++) { if (i % 2 == 0) continue; System.out.println(i); } // 使用continue跳过当前迭代
异常
// Kotlin
try { /*...*/ } catch (e: SomeException) { /*...*/ } finally { /*...*/ } // 异常处理
throw SomeException() // 抛出异常
// Java
try { /*...*/ } catch (SomeException e) { /*...*/ } finally { /*...*/ } // 异常处理
throw new SomeException(); // 抛出异常
导包
// Kotlin
package com.example.myapp // 定义包
import kotlin.text.* // 导入包
// Java
package com.example.myapp; // 定义包
import java.util.*; // 导入包
类相关
// Kotlin
class MyClass { var x = 5 } // 定义一个类
open class Base { /*...*/ } // 定义一个可以被继承的类
class Derived : Base() { /*...*/ } // 定义一个继承自Base的类
interface MyInterface { /*...*/ } // 定义一个接口
fun interface Runnable { fun run() } // 定义一个函数式接口
val runnable = Runnable { println("Running") } // 创建一个函数式接口的实例
public var x = 5 // 定义一个公有变量
private fun foo() { /*...*/ } // 定义一个私有函数
// Java
class MyClass { int x = 5; } // 定义一个类
class Base { /*...*/ } // 定义一个可以被继承的类
class Derived extends Base { /*...*/ } // 定义一个继承自Base的类
interface MyInterface { /*...*/ } // 定义一个接口
@FunctionalInterface interface Runnable { void run(); } // 定义一个函数式接口
Runnable runnable = () -> System.out.println("Running"); // 创建一个函数式接口的实例
public int x = 5; // 定义一个公有变量
private void foo() { /*...*/ } // 定义一个私有函数
扩展函数和扩展属性
// Kotlin
fun String.lastChar(): Char = this[this.length - 1] // 定义一个扩展函数
val <T> List<T>.lastIndex: Int get() = size - 1 // 定义一个扩展属性
// Java
// 没有
数据类
// Kotlin
data class User(val name: String, val age: Int) // 定义一个数据类
// Java
// 没有，用Lombok可以实现
密封类
// Kotlin
sealed class Expr // 定义一个密封类
data class Const(val number: Double) : Expr() // 定义一个继承自Expr的数据类
data class Sum(val e1: Expr, val e2: Expr) : Expr() // 定义一个继承自Expr的数据类
// Java
// 没有
接口、泛型
// Kotlin
interface List<out E> : Collection<E> // 定义一个带有协变类型参数的接口
fun <T> MutableList<T>.swap(index1: Int, index2: Int) // 定义一个泛型函数
fun <T> List<T>.customFilter(predicate: (T) -> Boolean): List<T> // 定义一个接受lambda表达式参数的泛型函数
fun <T> List<T>.binarySearch(element: T, fromIndex: Int = 0, toIndex: Int = size, comparator: Comparator<in T>? = null): Int where T : Comparable<T> // 定义一个带有约束的泛型函数
// Java
interface List<E> extends Collection<E> { /*...*/ } // 定义一个带有类型参数的接口
<T> void swap(List<T> list, int i, int j) // 定义一个泛型函数
<T> List<T> customFilter(List<T> list, Predicate<T> predicate) // 定义一个接受函数式接口参数的泛型函数
<T extends Comparable<T>> int binarySearch(List<? extends T> list, T key) // 定义一个带有约束的泛型函数
嵌套类、内部类
// Kotlin
class Outer { class Nested { /*...*/ } } // 定义一个嵌套类
class Outer { inner class Inner { /*...*/ } } // 定义一个内部类
// Java
class Outer { static class Nested { /*...*/ } } // 定义一个静态嵌套类
class Outer { class Inner { /*...*/ } } // 定义一个内部类
枚举类
// Kotlin
enum class Direction { NORTH, SOUTH, EAST, WEST } // 定义一个枚举类
// Java
enum Direction { NORTH, SOUTH, EAST, WEST; } // 定义一个枚举类
内联类
// Kotlin
inline class Password(val value: String) // 定义一个内联类
// Java
// 没有
匿名内部类、单例
// Kotlin
val listener = object : MouseAdapter() { /*...*/ } // 创建一个匿名内部类的实例
object Singleton { /*...*/ } // 定义一个单例
// Java
// 没有用匿名内部类和单例模式实现
委托
// Kotlin
class Derived(b: Base) : Base by b // 类委托
class Example { var p: String by Delegate() } // 属性委托
// Java
// 没有
别名
// Kotlin
typealias NodeSet = Set<Network.Node> // 类型别名
typealias FileTable<K> = MutableMap<K, MutableList<File>> // 类型别名
// Java
// 没有
函数和lambda
// Kotlin
fun add(a: Int, b: Int): Int { return a + b } // 定义一个函数
fun <T> List<T>.customFilter(predicate: (T) -> Boolean): List<T> // 定义一个接受lambda表达式参数的泛型函数
// Java
int add(int a, int b) { return a + b; } // 定义一个函数
<T> List<T> customFilter(List<T> list, Predicate<T> predicate) // 定义一个接受函数式接口参数的泛型函数
// Kotlin
val sum = { x: Int, y: Int -> x + y } // 定义一个lambda表达式
// Java
BinaryOperator<Integer> sum = (x, y) -> x + y; // 定义一个lambda表达式
// Kotlin
inline fun <T> List<T>.customFilter(predicate: (T) -> Boolean): List<T> // 定义一个内联函数
// Java
// 没有
重载操作符
// Kotlin
operator fun BigInteger.plus(other: BigInteger): BigInteger // 定义一个重载操作符的函数
// Java
// 没有
类型安全的构建器
// Kotlin
html { body { p { +"Hello, World!" } } } // 使用类型安全的构建器创建一个HTML文档
// Java
// 没有，用建造者模式实现
null
// Kotlin
var a: String? = null // 定义一个可空类型的变量
a?.length // 安全调用操作符
// Java
String a = null; // 定义一个可以为null的变量
int length = (a != null) ? a.length() : null; // 使用条件表达式进行空安全的调用
相等判断
// Kotlin
a == b // 结构相等性
a === b // 引用相等性
// Java
a.equals(b) // 结构相等性
a == b // 引用相等性
this表达式
// Kotlin
class A { fun foo() { println(this) } } // this表达式
class A { inner class B { fun foo() { println(this@A) } } } // 使用限定的this表达式
// Java
class A { void foo() { System.out.println(this); } } // this表达式
class A { class B { void foo() { System.out.println(A.this); } } } // 使用外部类的this表达式
协程
// Kotlin
fun main() = runBlocking { /*...*/ } // 使用协程进行异步编程
// Java
// 没有协程用其他异步方式可以实现
注解
// Kotlin
@Target(AnnotationTarget.CLASS) annotation class Fancy // 定义一个注解
// Java
@Target(ElementType.TYPE) @interface Fancy { } // 定义一个注解
解构
// Kotlin
val (name, age) = person // 解构声明
// Java
// 没有
反射
// Kotlin
val c = MyClass::class // 反射
// Java
Class c = MyClass.class; // 反射
这只是Kotlin和Java的一部分代码示例，更多的语法元素和细节，你可以在Kotlin官方文档和Java官方文档中找到。