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官方文档中找到。