快速入門 Kotlin 的 11 招

最近經常會收到一些 “用 Kotlin 怎麼寫” 的問題，作為有經驗的程式設計師，我們已經掌握了一門或者多門語言，那麼學 Kotlin 的時候就經常會有類似 “ ‘再見’用日語怎麼說？”、“ ‘你好’ 用西班牙語怎麼說？” 的問題，所以我決定把一些常用的語法對照列舉出來，如果大家熟悉 Java，那麼快速上手 Kotlin 會變得非常地容易。

這篇文章主要是寫給需要快速上手 Kotlin 的 Java 程式設計師看的，這時候他們關注的是如何 Kotlin 寫出類似某些 Java 的寫法，所以本文基本不涉及 Kotlin 的高階特性。

1. 如何定義變數

Java 定義變數的寫法：

String string = "Hello";

基本等價的 Kotlin 定義變數的寫法：

var string: String = "Hello"

Java 定義 final 變數的寫法：

final String string = "Hello";

注意到前面的是一個編譯期常量，Kotlin 當中應該這麼寫：

const val string: String = "Hello"

同樣是 final 變數，Java 這麼寫：

final String string = getString();

注意到，這個不是編譯期常量，Kotlin 這麼寫：

val string: String = getString()

另外， Kotlin 有型別推導的特性，因此上述變數定義基本上都可以省略掉型別 String。

2. 如何定義函式

Java 當中如何定義函式，也就是方法，需要定義到一個類當中：

public boolean testString(String name){
	...
}

等價的 Kotlin 寫法：

fun testString(name: String): Boolean {
	...
}

注意到返回值的位置放到了引數之後。

3. 如何定義靜態變數、方法

Java 的靜態方法或者變數只需要加一個 static 即可：

public class Singleton{
	private static Singleton instance = ...;

	public static Singleton getInstance(){
		...
		return instance;
	}
}

用 Kotlin 直譯過來就是：

class KotlinSingleton{
    companion object{
        private val kotlinSingleton = KotlinSingleton()

        @JvmStatic
        fun getInstance() = kotlinSingleton

    }
}

注意 getInstance 的寫法。 JvmStatic 這個註解會將 getInstance 這個方法編譯成與 Java 的靜態方法一樣的簽名，如果不加這個註解，Java 當中無法像呼叫 Java 靜態方法那樣呼叫這個方法。

另外，對於靜態方法、變數的場景，在 Kotlin 當中建議使用包級函式。

4. 如何定義陣列

Java 的陣列非常簡單，當然也有些抽象，畢竟是編譯期生成的類：

String[] names = new String[]{"Kyo", "Ryu", "Iory"};
String[] emptyStrings = new String[10];

Kotlin 的陣列其實更真實一些，看上去更讓人容易理解：

val names: Array<String> = arrayOf("Kyo", "Ryu", "Iory")
val emptyStrings: Array<String?> = arrayOfNulls(10)

注意到，Array T 即陣列元素的型別。另外，String? 表示可以為 null 的 String 型別。

陣列的使用基本一致。需要注意的是，為了避免裝箱和拆箱的開銷，Kotlin 對基本型別包括 Int、Short、Byte、Long、Float、Double、Char 等基本型別提供了定製版陣列型別，寫法為 XArray，例如 Int 的定製版陣列為 IntArray，如果我們要定義一個整型陣列，寫法如下：

val ints = intArrayOf(1, 3, 5)

5. 如何寫變長引數

Java 的變長引數寫法如下：

void hello(String... names){
	...
}

Kotlin 的變長引數寫法如下：

fun hello(vararg names: String){

}

6. 如何寫三元運算子

Java 可以寫三元運算子：

int code = isSuccessfully? 200: 400;

很多人抱怨 Kotlin 為什麼沒有這個運算子。。。據說是因為 Kotlin 當中 : 使用的場景比 Java 複雜得多，因此如果加上這個三元運算子的話，會給語法解析器帶來較多的麻煩，Scala 也是類似的情況。那麼這中情況下，我們用 Kotlin 該怎麼寫呢？

int code = if(isSuccessfully) 200 else 400

注意到，if else 這樣的語句也是表示式，這一點與 Java 不同。

7. 如何寫 main 函式

Java 的寫法只有一種：

class Main{
	public static void main(String... args){
		...
	}
}

注意到引數可以是變長引數或者陣列，這二者都可。

對應 Kotlin，main 函式的寫法如下：

class KotlinMain{
    companion object{
        @JvmStatic
        fun main(args: Array<String>) {

        }
    }
}

Kotlin 可以有包級函式，因此我們並不需要宣告一個類來包裝 main 函式：

fun main(args: Array<String>){
	...
}

8. 如何例項化類

Java 和 C++ 這樣的語言，在構造物件的時候經常需要用到 new 這個關鍵字，比如：

Date date = new Date();

Kotlin 構造物件時，不需要 new 這個關鍵字，所以上述寫法等價於：

val date = Date()

9. 如何寫 Getter 和 Setter 方法

Java 的 Getter 和 Setter 是一種約定俗稱，而不是語法特性，所以定義起來相對自由：

public class GetterAndSetter{
    private int x = 0;

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }
}

Kotlin 是有屬性的：

class KotlinGetterAndSetter{
    var x: Int = 0
        set(value) { field = value }
        get() = field
}

注意看到，我們為 x 顯式定義了 getter 和 setter，field 是 x 背後真正的變數，所以 setter 當中其實就是為 field 賦值，而 getter 則是返回 field。如果你想要對 x 的訪問做控制，那麼你就可以通過自定義 getter 和 setter 來實現了：

class KotlinGetterAndSetter{
    var x: Int = 0
        set(value) {
            val date = Calendar.getInstance().apply {
                set(2017, 2, 18)
            }
            if(System.currentTimeMillis() < date.timeInMillis){
                println("Cannot be set before 2017.3.18")
            }else{
                field = value
            }
        }
        get(){
            println("Get field x: $field")
            return field
        }   
}

10. 如何延遲初始化成員變數

Java 定義的類成員變數如果不初始化，那麼基本型別被初始化為其預設值，比如 int 初始化為 0，boolean 初始化為 false，非基本型別的成員則會被初始化為 null。

public class Hello{
	private String name;
}

類似的程式碼在 Kotlin 當中直譯為：

class Hello{
    private var name: String? = null
}

使用了可空型別，副作用就是後面每次你想要用 name 的時候，都需要判斷其是否為 null。如果不使用可控型別，需要加 lateinit 關鍵字：

class Hello{
    private lateinit var name: String
}

lateinit 是用來告訴編譯器，name 這個變數後續會妥善處置的。

對於 final 的成員變數，Java 要求它們必須在構造方法或者構造塊當中對他們進行初始化：

public class Hello{
	private final String name = "Peter";
}

也就是說，如果我要想定義一個可以延遲到一定實際再使用並初始化的 final 變數，這在 Java 中是做不到的。

Kotlin 有辦法，使用 lazy 這個 delegate 即可：

class Hello{
	private val name by lazy{
		NameProvider.getName() 
	}
}

只有使用到 name 這個屬性的時候，lazy 後面的 Lambda 才會執行，name 的值才會真正計算出來。

11. 如何獲得 class 的例項

Java 當中：

public class Hello{
	...
}

...

Class<?> clazz = Hello.class;

Hello hello = new Hello();
Class<?> clazz2 = hello.getClass();

前面我們展示了兩種獲得 class 的途徑，一種直接用類名，一種通過類例項。剛剛接觸 Kotlin 的時候，獲取 Java Class 的方法卻是容易讓人困惑。

class Hello

val clazz = Hello::class.java

val hello = Hello()
val clazz2 = hello.javaClass

同樣效果的 Kotlin 程式碼看上去確實很奇怪，實際上 Hello::class 拿到的是 Kotlin 的 KClass，這個是 Kotlin 的型別，如果想要拿到 Java 的 Class 例項，那麼就需要前面的辦法了。