幾分鐘內學會Kotlin語言

//這是單行註釋 //
/*
這是多行註釋
*/
// 這和Java的 "package" 差不多.
package com.learnxinyminutes.kotlin

/*
Kotlin程式入口函式是名為"main".
這個函式的入參是包含命令列引數的陣列
*/
fun main(args: Array<String>) {
    /*
    宣告值是使用"var" 或 "val".
    "val"是一旦分配值後就不能變，不變數，相反"vars" 是宣告變數
    */
    val fooVal = 10 // 之後就不能再給fooVal分配其他值了
    var fooVar = 10
    fooVar = 20 // fooVar是變數，能夠再次分配值

    /*
    大多數情況, Kotlin能夠決定一個變數的型別是什麼。
    這樣我們不必顯式明確每次去指定變數型別了。
    我們可以透過如下方式明確定義變數型別:
    */
    val foo : Int = 7

    /*
    Kotlin包含兩種型別的字串：與Java字串相同的escaped strings和新的raw strings,
    escaped strings中的換行符是\n字串和Java中一樣定義，
    反斜槓是換行符
    */
    val fooString = "My String Is Here!"
    val barString = "Printing on a new line?\nNo Problem!"
    val bazString = "Do you want to add a tab?\tNo Problem!"
    println(fooString)
    println(barString)
    println(bazString)

    /*
    行字串(raw strings)由三個引號分隔 (""").
    顧名思義能包含新的一行和其他任何字元。
   下面是給fooRawString賦值的是一個函式helloWorld，直至第四行的三個引號才表示賦值結束
    */
    val fooRawString = """
fun helloWorld(val name : String) {
   println("Hello, world!")
}
"""
    println(fooRawString)

    /*
    字串能保護模板表示式
    模板表示式是以美元符號開始($).
    */
    val fooTemplateString = "$fooString has ${fooString.length} characters"
    println(fooTemplateString)

    /*
    對於一個變數是空必須明確指定其是nullable.
    變數可以在其型別後面追加問號?指定其是nullable，
    然後使用?.運算子訪問這個nullable的變數
    也可以使用?: 運算子在其為null時為其分配一種值。
    */
    var fooNullable: String? = "abc"
    println(fooNullable?.length) // => 3
    println(fooNullable?.length ?: -1) // => 3
    fooNullable = null
    println(fooNullable?.length) // => null
    println(fooNullable?.length ?: -1) // => -1

    /*
    函式是使用"fun" 定義
    函式引數在函式名後面的括號中指定。函式引數可以有預設值。如果需要，函式返回型別在引數之後指定。
    */
    fun hello(name: String = "world"): String {
        return "Hello, $name!"
    }
    println(hello("foo")) // => Hello, foo!
    println(hello(name = "bar")) // => Hello, bar!
    println(hello()) // => Hello, world!

    /*
    一個函式引數可以使用"vararg" 標註，
    能夠讓許多引數傳遞進入函式。
    */
    fun varargExample(vararg names: Int) {
        println("Argument has ${names.size} elements")
    }
    varargExample() // => Argument has 0 elements
    varargExample(1) // => Argument has 1 elements
    varargExample(1, 2, 3) // => Argument has 3 elements

    /*
    當一個函式由單個表示式組成時，那麼這個卷括號可以被省略。函式內容體是在等於號=之後指定。
    */
    fun odd(x: Int): Boolean = x % 2 == 1
    println(odd(6)) // => false
    println(odd(7)) // => true

    // 如果返回型別能被推斷，我們就不必指定了。
    fun even(x: Int) = x % 2 == 0
    println(even(6)) // => true
    println(even(7)) // => false

    // 函式能用函式作為引數，返回頁首函式。
    fun not(f: (Int) -> Boolean): (Int) -> Boolean {
        return {n -> !f.invoke(n)}
    }
    // Named函式能使用 :: 作為引數指定.
    val notOdd = not(::odd)
    val notEven = not(::even)
    // Lambda 表示式能指定為引數
    val notZero = not {n -> n == 0}
    /*
    如果一個lambda僅有一個引數，它的宣告可以被忽視(隨著 ->一起).
    單個引數名將是"it".
    */
    val notPositive = not {it > 0}
    for (i in 0..4) {
        println("${notOdd(i)} ${notEven(i)} ${notZero(i)} ${notPositive(i)}")
    }

    //  "class" 是用來宣告類
    class ExampleClass(val x: Int) {
        fun memberFunction(y: Int): Int {
            return x + y
        }

        infix fun infixMemberFunction(y: Int): Int {
            return x * y
        }
    }
    /*
    建立新的例項使用構造器
    Kotlin沒有 "new" 
    */
    val fooExampleClass = ExampleClass(7)
    // 成員函式能使用點符號呼叫
    println(fooExampleClass.memberFunction(4)) // => 11

    /*
    如果一個函式被"infix"標註，能使用infix notation呼叫
    下面fooExampleClass infixMemberFunction 4等同於
fooExampleClass.memberFunction(4)
    */
    println(fooExampleClass infixMemberFunction 4) // => 28

    /*
   資料類是建立只包含資料的精確方式.
     "hashCode"/"equals" 和 "toString" 等方法會自動產生。
    */
    data class DataClassExample (val x: Int, val y: Int, val z: Int)
    val fooData = DataClassExample(1, 2, 4)
    println(fooData) // => DataClassExample(x=1, y=2, z=4)

    // 資料類沒有 "copy" 函式
    val fooCopy = fooData.copy(y = 100)
    println(fooCopy) // => DataClassExample(x=1, y=100, z=4)

    // 物件能被解構入多個變數。
    val (a, b, c) = fooCopy
    println("$a $b $c") // => 1 100 4

    // 解構 "for" 迴圈
    for ((a, b, c) in listOf(fooData)) {
        println("$a $b $c") // => 1 100 4
    }

    val mapData = mapOf("a" to 1, "b" to 2)
    // Map.Entry 也能解構
    for ((key, value) in mapData) {
        println("$key -> $value")
    }

    //  "with" 函式類似JavaScript "with" 語句.
    data class MutableDataClassExample (var x: Int, var y: Int, var z: Int)
    val fooMutableData = MutableDataClassExample(7, 4, 9)
    with (fooMutableData) {
        x -= 2
        y += 2
        z--
    }
    println(fooMutableData) // => MutableDataClassExample(x=5, y=6, z=8)

    /*
    使用 "listOf" 函式建立集合
    集合是不可變的，元素不能增加和移走
    */
    val fooList = listOf("a", "b", "c")
    println(fooList.size) // => 3
    println(fooList.first()) // => a
    println(fooList.last()) // => c
    // list元素可透過索引訪問。
    println(fooList[1]) // => b

    // 一個可變的 list能使用 "mutableListOf" 函式建立
    val fooMutableList = mutableListOf("a", "b", "c")
    fooMutableList.add("d")
    println(fooMutableList.last()) // => d
    println(fooMutableList.size) // => 4

    // 使用 "setOf"  建立set
    val fooSet = setOf("a", "b", "c")
    println(fooSet.contains("a")) // => true
    println(fooSet.contains("z")) // => false

    // 使用 "mapOf" f建立map
    val fooMap = mapOf("a" to 8, "b" to 7, "c" to 9)
    // Map values can be accessed by their key.
    println(fooMap["a"]) // => 8

     //待續
<p class="indent">