Kotlin基礎語法

時間 2019-12-05

標籤 kotlin 基礎語法简体版

原文原文鏈接

Kotlin基礎

1. 函數

1 . 示例

fun max(a: Int,b: Int): Int{
    return if (a>b) a else b
}
println(max(1,2))
/**
 * Main方法
 */
fun main(args: Array<String>){
    println("Hello World")
}

2 . 語句與表達式：在Kotlin中if是表達式，不是語句，在Kotlin中除了循環（for/do/do...while）外，大多數控制結構都是表達式
3 . 若是函數體寫在花括號中，咱們說這個函數有代碼塊體。若是它直接返回一個表達式，它就有表達式體。只有表達式體函數的返回類型能夠省略。
4 . 一個函數要麼具備並非代碼塊的表達式函數體，要麼具備包含顯示return語句的代碼塊函數體

IDEA中提供這兩種函數風格之間轉換的操做

2. 變量

1 . 可變變量和不可變變量java
- val:不可變引用（final）
- var:可變引用
- 若變量沒有初始化，則須要顯示的指定他的類型
- 不可變變量，只能進行惟一一次初始化
- val 引用自身是不可變的，可是它指向的對象多是可變的
- var容許變量改變本身的值，但他的類型倒是不可變的

val a =  "string"
val a: String = "string"

3. 字符串格式化

1 . 示例

fun main (args: Array<String>){
    val name = if (args.size>0) args[0] else "kotlin"
    /**
     * 引用變量，若要打印$符號，則須要轉義操做 \$
     */
    println("Hello $name")
    /**
     * 引用表達式
     */
     if(args.size>0){
        println("Hello ,${args[0]}")
     }
     /**
      * 雙引號中使用雙引號，須要保證內部的雙引號在表達式體內
      */
      println("Hello , ${if (args.size>0) args[0] else "kotlin"}")
}

2 . 編譯後的代碼，建立了一個StringBulider對象，並吧常量部分和變量附加上去

4. 類和屬性

1 . 類

class Person(val name: String)

kotlin 中public是默認的可見性，因此省略了

2 . 屬性git
- 聲明爲val的屬性是隻讀的，並自動提供一個getter
- 聲明爲var的屬性是可變的，並自動提供一個getter和一個setter
- 對於Java中定義的類，同樣可使用Kotlin語法進行屬性訪問
```
class Person(
    val name: String
    var isMarried: Boolean
)

val person = new Person("Bob",true)
println(person.name)
```

3 . 自定義訪問器express

此方式和聲明一個沒有參數的函數同樣的效果
在Java中訪問該屬性,直接調用isSquare()便可
不須要使用帶花括號的完成語法
一般來講，若描述的是類的屬性(特徵)，則應該聲明爲屬性

class Rectangle(val height: Int, val width: Int) {
    val isSquare: Boolean
        get() {
            return height == width
        }
        /**
         * 也能夠爲:
         * get() = height==width
         */
}

fun main(args: Array<String>) {
    val rectangle = Rectangle(41, 43)
    println(rectangle.isSquare)
}

4 . 枚舉dom

Kotlin中，只有enum關鍵字在class前面時才表示枚舉，其餘狀況下，仍能夠當作普通名稱使用
枚舉常量中的生命構造方法和屬性的語法與以前同樣，必須提供屬性值
若要在枚舉類中定義任何方法，就要使用分號把枚舉常量列表和方法定義分開

/**
 * 普通枚舉
 */
 enum class Color {
     RED, ORANGE, YELLOW, GREEN, BLUE, INDIGO, VIOLET
 }
/**
 * 帶屬性值的枚舉
 */
 enum class Color(val r: Int, val g: Int, val b: Int) {
     RED(255, 0, 0), 
     ORANGE(255, 165, 0),
     YELLOW(255, 255, 0), 
     GREEN(0, 255, 0), 
     BLUE(0, 0, 255),
     INDIGO(75, 0, 130), 
     VIOLET(238, 130, 238)
     ;
     /**
      * 此處聲明瞭方法，則枚舉最後必需要使用分號;
      */
     fun rgb() = (r * 256 + g) * 256 + b
 }
 
 fun main(args: Array<String>) {
     println(Color.BLUE.rgb())
 }

5 . 接口與實現ide

聲明實現類時，使用一個冒號(:)後面跟上接口名稱，來標記這個類實現了這個接口

/**
 * 接口，標記接口，無任何方法
 */
interface Expr

/**
 * 實現類，使用:來標明實現哪一個接口
 */
class Num(val value: Int) : Expr
/**
 * 實現類，使用:來標明實現哪一個接口
 */
class Sum(val left: Expr, val right: Expr) : Expr

6 . 類型檢查和類型轉換函數
- 使用is來判斷一個變量是不是某種類型，在進行類型判斷後，變量會自動轉換成響應的類型，無需強制轉換，這種方式的轉換爲智能轉換，在使用智能轉換時，屬性值必須是val屬性，並且不能有自定義的訪問器
- 使用as來顯示轉換，val n = e as Num

5. 目錄和包

與Java同樣，在文件開頭聲明package,則該文件中定義的全部聲明（類，函數，屬性）都會屬於這個包
導入包使用import關鍵字，可使用*在指定包下的全部類
在Kotlin中，能夠吧多個類放在同一個文件中，但應該使用Java的包使用規則

package geometry.shapes

import java.util.Random //使用java的工具包

class Rectangle(val height: Int, val width: Int) {
    val isSquare: Boolean
        get() = height == width
}

fun createRandomRectangle(): Rectangle {
    val random = Random()
    return Rectangle(random.nextInt(), random.nextInt())
}

package geometry.example

import geometry.shapes.createRandomRectangle //使用上面👆的對象

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

6.選擇語句`when`

1 . 枚舉中使用when工具

when是一個有返回值的表達式，所以能夠直接返回表達式函數體

分支語句上無需使用breakcode

enum class Color {
    RED, ORANGE, YELLOW, GREEN, BLUE, INDIGO, VIOLET
}

fun getMnemonic(color: Color) = //直接返回when表達式
    when (color) {
        Color.RED -> "Richard"
        Color.ORANGE -> "Of"
        Color.YELLOW -> "York"
        Color.GREEN -> "Gave"
        Color.BLUE -> "Battle"
        Color.INDIGO -> "In"
        Color.VIOLET -> "Vain"
    }

fun main(args: Array<String>) {
    println(getMnemonic(Color.BLUE))
}

/**
 * 合併多個選項
 */
fun getWarmth(color: Color) = when(color) {
    Color.RED, Color.ORANGE, Color.YELLOW -> "warm"
    Color.GREEN -> "neutral"
    Color.BLUE, Color.INDIGO, Color.VIOLET -> "cold"
}

fun main(args: Array<String>) {
    println(getWarmth(Color.ORANGE))
}

/**
 * 可導入枚舉常量，從而簡化代碼
 */
import ch02.colors.Color
import ch02.colors.Color.*

fun getWarmth(color: Color) = when(color) {
    RED, ORANGE, YELLOW -> "warm"
    GREEN -> "neutral"
    BLUE, INDIGO, VIOLET -> "cold"
}

fun main(args: Array<String>) {
    println(getWarmth(Color.ORANGE))
}

2 . 在when結構中使用任意對象orm

與Java中的switch不同，可使用任意對象對象

import ch02.colors.Color
import ch02.colors.Color.*

fun mix(c1: Color, c2: Color) =
        when (setOf(c1, c2)) {  //表達式匹配表達式
            setOf(RED, YELLOW) -> ORANGE
            setOf(YELLOW, BLUE) -> GREEN
            setOf(BLUE, VIOLET) -> INDIGO
            else -> throw Exception("Dirty color")
        }

fun main(args: Array<String>) {
    println(mix(BLUE, YELLOW))
}

3 . 不帶參數的when

若是沒有給when表達式提供參數，則分支條件就是任意的布爾表達式（當作if來使用）

import ch02.colors.Color
import ch02.colors.Color.*

fun mixOptimized(c1: Color, c2: Color) =
    when {
        (c1 == RED && c2 == YELLOW) ||
        (c1 == YELLOW && c2 == RED) ->
            ORANGE

        (c1 == YELLOW && c2 == BLUE) ||
        (c1 == BLUE && c2 == YELLOW) ->
            GREEN

        (c1 == BLUE && c2 == VIOLET) ||
        (c1 == VIOLET && c2 == BLUE) ->
            INDIGO

        else -> throw Exception("Dirty color")
    }

fun main(args: Array<String>) {
    println(mixOptimized(BLUE, YELLOW))
}

4 . 使用when代替if

在kotlin中沒有三元運算符，由於if表達式有返回值

在使用代碼塊時，代碼塊的最後一條表達式就是結果

interface Expr
class Num(val value: Int) : Expr
class Sum(val left: Expr, val right: Expr) : Expr

/**
 * 使用if
 */
fun eval(e: Expr): Int =
    if (e is Num) {
        e.value
    } else if (e is Sum) {
        eval(e.right) + eval(e.left)
    } else {
        throw IllegalArgumentException("Unknown expression")
    }
/**
 * 使用when替換if
 */
fun eval(e: Expr): Int =
    when (e) {
        is Num ->
            e.value
        is Sum ->
            eval(e.right) + eval(e.left)
        else ->
            throw IllegalArgumentException("Unknown expression")
    }
/**
 * 複雜表達式體可使用{}
 */
fun evalWithLogging(e: Expr): Int =
    when (e) {
        is Num -> {
            println("num: ${e.value}")
            e.value
        }
        is Sum -> {
            val left = evalWithLogging(e.left)
            val right = evalWithLogging(e.right)
            println("sum: $left + $right")
            left + right
        }
        else -> throw IllegalArgumentException("Unknown expression")
    }

fun main(args: Array<String>) {
    println(eval(Sum(Num(1), Num(2))))
}

5 . 迭代while和for循環

while循環和Java一致

區間數字

* 一個起始值，一個結束值，使用`..`運算符來表示區間`val oneToTen = 1 .. 10`
* Kotlin中的區間是包含的或者閉合的，即第二個值始終是區間的一部分
* 若是能迭代區間中全部的值，這樣的區間被稱爲數列

downTo表示降序
step表示步長，在普通區間和降序區間中都能使用

until表示開區間的結束

/**
 * 區間[1,100]
 */
for(i in 1 .. 100 ){
    println(i)
}

/**
 * 區間[1,100)
 */
for(i in 1 until 100 ){
    println(i)
}

/**
 * 區間[100,1] 降序使用downTo
 */
for(i in 100 downTo 1 ){
    println(i)
}

/**
 * 區間[100,1? 降序,而且指定步長
 */
for(i in 100 downTo 1 step 2 ){
    println(i)
}
/**
 * 區間[1,100?
 */
for(i in 1 .. 100 step 2 ){
    println(i)
}

迭代Map

fun main(args: Array<String>) {
    val binaryReps = TreeMap<Char, String>()

    for (c in 'A'..'F') {
        val binary = Integer.toBinaryString(c.toInt())
        binaryReps[c] = binary
    }

    for ((letter, binary) in binaryReps) {
        println("$letter = $binary")
    }
}

使用下標迭代List

val list = arrayListOf("10","11","12")
for((index,element) in list.withIndex()){
    println("$index:$element")
}

in/!in運算符，能夠檢查一個值是否在區間內，或者不在區間內
在when語句中也可以使用in`運算符

in運算符使用於全部實現java.lang.Comparable接口的類

fun isLetter(c: Char) = c in 'a'..'z' || c in 'A'..'Z'
fun isNotDigit(c: Char) = c !in '0'..'9'

fun main(args: Array<String>) {
    println(isLetter('q'))
    println(isNotDigit('x'))
}

fun recognize(c: Char) = when (c) {
    in '0'..'9' -> "It's a digit!"
    in 'a'..'z', in 'A'..'Z' -> "It's a letter!"
    else -> "I don't know…"
}

fun main(args: Array<String>) {
    println(recognize('8'))
}

Kotlin中的異常

異常不需new關鍵字來建立實例
Kotlin中的throw能夠做爲另外一個表達式的通常部分
Kotlin中，無需使用throws關鍵在來拋出異常，由於Kotlin中並不區分受檢測異常和並不受檢測異常，因此在代碼中能夠處理異常，也可不處理異常
JDK1.7中的try-with-resources在kotlin中爲一個庫函數，在後面會介紹
try關鍵字和if、when同樣，能夠做爲表達式賦值給一個變量，但必須用花括號把語句主體包裹起來，若是主體包含多個表達式，則try表達式的值就是最後一個表達式的值

catch語句中也須要有返回值或者直接return

import java.io.BufferedReader
import java.io.StringReader

fun readNumber(reader: BufferedReader): Int? {  //無需throws
    try {
        val line = reader.readLine()
        return Integer.parseInt(line)
    }
    catch (e: NumberFormatException) {  //類型在右邊
        return null
    }
    finally {
        reader.close()
    }
}

fun main(args: Array<String>) {
    val reader = BufferedReader(StringReader("239"))
    println(readNumber(reader))
}

無finally語句

import java.io.BufferedReader
import java.io.StringReader

fun readNumber(reader: BufferedReader) {
    val number = try {
        Integer.parseInt(reader.readLine())
    } catch (e: NumberFormatException) {
        return  //return 中斷邏輯執行
        //null  //也可返回null
    }

    println(number)
}

fun main(args: Array<String>) {
    val reader = BufferedReader(StringReader("not a number"))
    readNumber(reader)
}