从 Kotlin 到 Java

Kotlin 是一种在 Java 平台上运行的静态类型编程语言。Kotlin 兼容 Java，可以与 Java 平台上的大多数库进行交互，同时也可以逐步替换掉 Java 代码。本文将介绍 Kotlin 到 Java 的转换，包括基本语法、类型转换和一些常见的编程模式。

基本语法

如果你已经熟悉了 Java，那么学习 Kotlin 会非常容易。Kotlin 与 Java 类似，都有类、方法、接口和一些基础数据类型。下面是一些基本语法的比较：

创建类

Kotlin 中创建类的语法如下：

class MyClass(val name: String) {
    fun hello() {
        println("Hello, $name!")
    }
}

Java 中创建类的语法如下：

public class MyClass {
    private String name;

    public MyClass(String name) {
        this.name = name;
    }

    public void hello() {
        System.out.println("Hello, " + name + "!");
    }
}

可以看到，Kotlin 中创建类比 Java 要简洁一些。这是因为 Kotlin 可以通过属性声明来简化代码。

创建对象

在 Kotlin 中创建对象的语法如下：

val myObject = MyClass("World")
myObject.hello()

在 Java 中创建对象的语法如下：

MyClass myObject = new MyClass("World");
myObject.hello();

可以看到，Kotlin 与 Java 的创建对象语法非常相似。

控制流

Kotlin 中的 if 表达式比 Java 更简洁：

val max = if (a > b) a else b

Java 中的 if 语句如下：

int max;
if (a > b) {
    max = a;
} else {
    max = b;
}

同样，Kotlin 中的 when 表达式比 Java 中的 switch 语句更简洁：

when (x) {
    1 -> print("x == 1")
    2 -> print("x == 2")
    else -> {
        print("x is neither 1 nor 2")
    }
}

Java 中的 switch 语句如下：

switch (x) {
    case 1:
        System.out.println("x == 1");
        break;
    case 2:
        System.out.println("x == 2");
        break;
    default:
        System.out.println("x is neither 1 nor 2");
        break;
}

Kotlin 的 when 表达式在处理多个条件时更加简洁。

循环

Kotlin 中的 for 循环比 Java 更简洁：

for (i in 0 until n) {
    println(i)
}

Java 中的 for 循环如下：

for (int i = 0; i < n; i++) {
    System.out.println(i);
}

同样，Kotlin 中的 while 循环比 Java 更简洁：

while (x != 0) {
    x /= 10
}

Java 中的 while 循环如下：

while (x != 0) {
    x /= 10;
}

类型转换

Kotlin 自动推断类型，并允许在不同类型之间进行转换。在 Java 中，需要使用强制类型转换来转换类型。下面是一些 Kotlin 类型转换的例子：

数字类型转换

Kotlin 中可以自动转换数字类型：

val a: Int = 1
val b: Long = a.toLong()

Java 中需要使用强制类型转换：

int a = 1;
long b = (long) a;

字符串转换

Kotlin 中可以自动转换字符串类型：

val x = "1"
val y: Int = x.toInt()

Java 中需要使用包装类的方法进行转换：

String x = "1";
int y = Integer.parseInt(x);

类型检查和类型转换

Kotlin 中使用 is 运算符来进行类型检查：

if (obj is String) {
    println(obj.length)
}

Java 中需要使用 instanceof 运算符：

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

Kotlin 中可以使用 as 运算符来进行类型转换：

val x: Any = "Hello"
val y: String = x as String

Java 中需要使用强制类型转换：

Object x = "Hello";
String y = (String) x;

常见编程模式

Kotlin 支持许多常见的编程模式，例如单例、策略、观察者和链式调用。下面是一些常见的编程模式的例子：

单例

Kotlin 中创建单例的语法如下：

object MySingleton {
    fun sayHello() {
        println("Hello, Singleton!")
    }
}

Java 中创建单例的语法如下：

public class MySingleton {
    private static MySingleton instance;

    private MySingleton() {}

    public static synchronized MySingleton getInstance() {
        if (instance == null) {
            instance = new MySingleton();
        }
        return instance;
    }

    public void sayHello() {
        System.out.println("Hello, Singleton!");
    }
}

可以看到，Kotlin 中创建单例要比 Java 更加简洁。

策略

Kotlin 中使用 lambda 表达式来实现策略模式：

interface Strategy {
    fun execute(a: Int, b: Int): Int
}

class Add : Strategy {
    override fun execute(a: Int, b: Int): Int = a + b
}

class Subtract : Strategy {
    override fun execute(a: Int, b: Int): Int = a - b
}

class Calculator(val strategy: Strategy) {
    fun execute(a: Int, b: Int): Int = strategy.execute(a, b)
}

val calculatorAdd = Calculator(Add())
println(calculatorAdd.execute(2, 3))
val calculatorSubtract = Calculator(Subtract())
println(calculatorSubtract.execute(5, 2))

Java 中实现策略模式需要使用接口：

interface Strategy {
    int execute(int a, int b);
}

class Add implements Strategy {
    public int execute(int a, int b) {
        return a + b;
    }
}

class Subtract implements Strategy {
    public int execute(int a, int b) {
        return a - b;
    }
}

class Calculator {
    private Strategy strategy;

    public Calculator(Strategy strategy) {
        this.strategy = strategy;
    }

    public int execute(int a, int b) {
        return strategy.execute(a, b);
    }
}

Calculator calculatorAdd = new Calculator(new Add());
System.out.println(calculatorAdd.execute(2, 3));
Calculator calculatorSubtract = new Calculator(new Subtract());
System.out.println(calculatorSubtract.execute(5, 2));

Kotlin 中使用 lambda 表达式可以使代码更加简洁。

观察者

Kotlin 中使用观察者模式需要使用 Observable 和 Observer 接口：

class MyObservable : Observable() {
    fun update(value: Any) {
        setChanged()
        notifyObservers(value)
    }
}

class MyObserver : Observer {
    override fun update(o: Observable?, arg: Any?) {
        println("Received: $arg")
    }
}

val observable = MyObservable()
observable.addObserver(MyObserver())
observable.update("Hello, Observer!")

Java 中实现观察者模式需要使用 Observable 和 Observer 接口：

class MyObservable extends Observable {
    public void update(Object value) {
        setChanged();
        notifyObservers(value);
    }
}

class MyObserver implements Observer {
    public void update(Observable o, Object arg) {
        System.out.println("Received: " + arg);
    }
}

MyObservable observable = new MyObservable();
observable.addObserver(new MyObserver());
observable.update("Hello, Observer!");

可以看到，Kotlin 的语法比 Java 更加简洁。

链式调用

Kotlin 中使用链式调用可以使代码更加简洁：

data class Person(val name: String, val age: Int)

val persons = listOf(
    Person("Alice", 28),
    Person("Bob", 42)
)

val result = persons
    .filter { it.age > 30 }
    .map { it.name }
    .joinToString(separator = ", ")

println(result)

Java 中的链式调用语法如下：

List<Person> persons = Arrays.asList(
    new Person("Alice", 28),
    new Person("Bob", 42)
);

String result = persons.stream()
    .filter(person -> person.age > 30)
    .map(person -> person.name)
    .collect(Collectors.joining(", "));

System.out.println(result);

可以看到，Kotlin 中链式调用可以使代码更加简洁。

总结

Kotlin 是一种逐渐流行的编程语言，它与 Java 兼容，并且可以逐步替换掉 Java 代码。Kotlin 的基本语法与 Java 类似，但是在一些地方更加简洁。Kotlin 也支持许多常见的编程模式，例如单例、策略、观察者和链式调用。如果你已经熟悉了 Java，并且想要学习一种新的编程语言，那么 Kotlin 值得一试。