快速書寫常見的 Kotlin 代碼 MD

Markdown版本筆記	個人GitHub首頁	個人博客	個人微信	個人郵箱
MyAndroidBlogs	baiqiantao	baiqiantao	bqt20094	baiqiantao@sina.com

快速書寫常見的 Kotlin 代碼

---

目錄

目錄
如何定義變量
如何定義函數
如何定義數組
如何寫變長參數
如何寫三元運算符
如何寫 main 函數
如何實例化類
如何寫 Getter 和 Setter 方法
如何延遲初始化成員變量
如何對 final 的成員變量的初始化
如何得到 class 的實例

這篇文章主要是寫給須要快速上手 Kotlin 的 Java 程序員看的，這時候他們關注的是如何使用 Kotlin 寫出相似某些 Java 的寫法，因此本文基本不涉及 Kotlin 的高級特性。

如何定義變量

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。

如何定義函數

Java 當中若是定義函數，也就是方法，須要定義到一個類當中：

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

等價的 Kotlin 寫法：

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

注意到返回值的位置放到了參數以後。

如何定義靜態變量、方法
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 當中建議使用包級函數。

如何定義數組

Java 的數組：

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

Kotlin 的數組：

val names: Array<String> = arrayOf("Kyo", "Ryu", "Iory")//Array<T> 中的泛型T即數組元素的類型
val emptyStrings: Array<String?> = arrayOfNulls(10)

須要注意的是，爲了不裝箱和拆箱的開銷，Kotlin 對基本類型包括 Int、Short、Byte、Long、Float、Double、Char 等基本類型提供了定製版數組類型，寫法爲 XArray，例如 Int 的定製版數組爲 IntArray，若是咱們要定義一個整型數組，寫法以下：

val ints = intArrayOf(1, 3, 5)

如何寫變長參數

Java 的變長參數寫法以下：

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

Kotlin 的變長參數寫法以下：

fun hello(vararg names: String){ }

如何寫三元運算符

Java 能夠寫三元運算符：

int code = isSuccessfully? 200: 400;

Kotlin 沒有 : 這個運算符，聽說是由於 Kotlin 當中 : 使用的場景比 Java 複雜得多，所以若是加上這個三元運算符的話，會給語法解析器帶來較多的麻煩，Scala 也是相似的狀況。
對於上述示例，Kotlin 中能夠這樣表示：

int code = if(isSuccessfully) 200 else 400

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

如何寫 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>){ ... }

如何實例化類

Java 和 C++ 這樣的語言，在構造對象的時候常常須要用到 new 這個關鍵字，好比：

Date date = new Date();

Kotlin 構造對象時，不須要 new 這個關鍵字，因此上述寫法等價於：

val date = Date()

如何寫 Getter 和 Setter 方法

Java 的 Getter 和 Setter 是一種約定俗稱，而不是語法特性，因此定義起來相對自由，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
        }
}

如何延遲初始化成員變量

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 的成員變量的初始化

對於 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 的值纔會真正計算出來。

如何得到 class 的實例

Java 當中：

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

前面咱們展現了兩種得到 class 的途徑，一種直接用類名，一種經過類實例。剛剛接觸 Kotlin 的時候，獲取 Java Class 的方法倒是容易讓人困惑。

val clazz = Hello::class.java
val clazz2 = hello.javaClass

一樣效果的 Kotlin 代碼看上去確實很奇怪，實際上 Hello::class 拿到的是 Kotlin 的 KClass，這個是 Kotlin 的類型，若是想要拿到 Java 的 Class 實例，那麼就須要前面的辦法了。