最易懂的kotlin用法

類

package com.example.demos.kotlin

/**
 * 普通類
 */
class kotlin_class {
    /**
     * 內部伴侶 , 外部可以直接通過類名訪問 , 可以理解成,java的static修飾被統一整理到這裏面了
     */
    companion object {
    }

    /**
     * object 用於創建單例模式
     */
    object Resource {
        val name = "Rocker"
    }

    /**
     *  內部類,與java大致相同
     */
    inner class test {
    }

    /**
     *  嵌套類,與同包下的類權限相同,不能訪問外部成員和方法
     */
    class test1 {
    }

    //匿名內部類完整寫法
    val runnable: Runnable = object : Runnable {
        override fun run() {
        }
    }

    //匿名內部類,簡寫1
    val runnable1 = Runnable {
    }

    //匿名內部類,簡寫2
    var runnable2: () -> Unit = {
    }

    //匿名內部類,簡寫3
    var runnable3 = {
    }
}

關鍵詞

 fun								//函數定義使用 如:fun sum(a: Int, b: Int): Int {...}
 vararg								//函數的變長參數(類似於java裏面參數後面帶...) 如:fun vars(vararg v:Int){...}
 var 								//可變變量定義(可以代替任意類型) 如: var x = 5
 val 								//不可變變量定義(只能賦值一次的變量(類似Java中final修飾的變量)) 如: val b = 1
 is									//運算符檢測一個表達式是否某類型的一個實例(類似於Java中的instanceof關鍵字) 如: if (obj is String) {...}
-------------區間↓------------
 in 								//區間 如:for (i in 1..4) print(i)
 step								//步長 如:for (i in 1..4 step 2) print(i)
 ..									//從小到大 如:1..4
 downTo								//從大到小 如:for (i in 4 downTo 1 step 2) print(i)
 until								//排除 如:for (i in 1 until 4) {...}
 ------------區間↑-----------
 when								//類似其他語言的 switch 操作符
 field								//後端變量
 lateinit 							//非空屬性必須在定義的時候初始化,kotlin提供了一種可以延遲初始化的方案 如: lateinit var subject: TestSubject
 init 								//主構造器中不能包含任何代碼，初始化代碼可以放在初始化代碼段中,如: init {...}
 constructor						//類也可以有二級構造函數，需要加前綴 如: constructor (name: String, alexa: Int) : this(name) {...}
 inner								//內部類使用 inner 關鍵字來表示。如 inner class Inner {...}
 Unit								//是一個特殊的返回值，相當於void，意思就是此函數沒有返回值

/**
 * 關鍵詞
 * object
 * by lazy
 * lateinit
 * when
 */
class kotlin_keyword {
    // ---------------修辭符--public--private--protected--internal--------------------------------------------
    public var test1 = null//默認修飾符，被其修飾的在任何位置都能訪問
    private var test2 = null//表示只在這個類(以及它的所有成員)之內可以訪問
    protected var test3 = null//在當前類及其子類內訪問
    internal var test4 = null//在同一模塊內使用


    // ---------------修辭符--var--val------------------------------------------
    var test5 = null//var 可變修飾
    val test6 = null//val 不可變修飾(類似於java裏面final修飾的)


    // ---------------修辭符--lateinit------------------------------------------
    lateinit var test7: String  //lateinit 修飾var的變量，且變量是非空的類型


    /**
     * object 用於創建匿名類
     */
    var object_1 = object : Handler.Callback {
        override fun handleMessage(msg: Message): Boolean {
            return false
        }
    }

    /**
     * by lazy  修飾val的變量
     */
    val keyword: String by lazy {
        "Rocker"
    }


    /**
     * when 用於判斷 相當於java中的switch()語句
     */
    fun keyword_when(age: Int) = when (age) {
        1 -> "when1"                //age等於1
        2 -> "when2"                //age等於2
        in 3..10 -> "when3"         //age等於3到10時
        !in 11..20 -> "when4"       //age不等於11到20
        else -> "when5"             //其餘的
    }

// ---------------判斷,數組,循環,區間-----------------------------------------------------

    /**
     * 數組,區間
     */
    fun keyword_array(vararg arr0: Int) {
        var arr1 = arrayOf(1, 2, 3, 4)              //結果:   1,2,3,4
        var arr2 = arrayOf(1..4)                    //結果:   1,2,3,4
        var arr3 = 1..4                             //結果:   1,2,3,4
        var arr4 = 1..4 step 2                      //結果:   1 3     步長爲2 ->1(保留) 2(捨棄) 3(保留) 4(捨棄)
        var arr6 = 1 until 4                        //結果:   1,2,3   類似[1,4) , 排除了 4
        var arr7 = 4 downTo 1                       //結果:   4,3,2,1
        var arr8 = Array<Any?>(1, { null })     //結果:   創建一個大小爲1的數組
        var arr9 = arrayOfNulls<String>(3)      //結果:   初始化一個空的數組，需要傳入數組大小
        var arr10 = charArrayOf('d')                 //結果:   初始化一個特定數據類型-字符類型的數組
        var arr11 = emptyArray<String>()            //結果:   初始化一個空的數組，實際上它是大小爲0繼承arrayOfNulls的數組
    }

    /**
     * 條件 in
     */
    fun keyword_in() {

        //判斷
        val number = 1
        val array = 1..4
        if (number in array) {
            Log.e("log", "number在1-4內")
        }

        //循環
        for (i in array) {
            Log.e("log", "循環array" + i)
        }
    }

    /**
     * 條件 is 判斷類型
     */
    fun keyword_is(name: Any) {
        if (name is Int) {
            Log.e("log", "name 是 Int")
        } else if (name is String) {
            Log.e("log", "name 是 String")
        } else if (name !is Float) {
            Log.e("log", "name 不是 Float")
        }
    }
}

枚舉

package com.example.demos.kotlin

/**
 * 枚舉
 */
enum class kotlin_enum {
    KOTLIN;
    /**
     * 內部伴侶 , 外部可以直接通過類名訪問 , 可以理解成,java的static修飾被統一整理到這裏面了
     */
    companion object {
    }

    /**
     *  內部類,與java大致相同
     */
    inner class test {
    }

    /**
     *  嵌套類,與同包下的類權限相同,不能訪問外部成員和方法
     */
    class test1 {
    }

    //匿名內部類完整寫法
    val runnable: Runnable = object : Runnable {
        override fun run() {
        }
    }

    //匿名內部類,簡寫1
    val runnable1 = Runnable {
    }

    //匿名內部類,簡寫2
    var runnable2: () -> Unit = {
    }

    //匿名內部類,簡寫3
    var runnable3 = {
    }
}

方法

package com.example.demos.kotlin

/**
 * 方法
 */
class kotlin_function {
    /**
     * 最簡單方法
     */
    fun test1() {
    }

    /**
     * 公開的方法
     */
    public fun test2() {
    }

    /**
     * 私有方法
     */
    private fun test3() {
    }

    /**
     * 受保護的方法
     */
    protected fun test4() {
    }

    /**
     * 帶參數方法
     */
    fun test5(str: String, int: Int) {
    }

    /**
     * 有返回值的方法
     */
    fun test6(int: Int): Int {
        return 0
    }

    /**
     * 直接給方法賦值
     */
    fun test7(a: Int) = test6(a)

    /**
     * 直接給方法賦值
     */
    fun test8(a: Int) = {
        test6(a)
    }

    /**
     * 無返回值 <: Unit>也可以省略,(類似Java中的void)
     */
    fun test9(): Unit {
    }

    /**
     * 可變長度參數,test9(1,2,3)  ,類似java的...
     */
    fun test9(vararg arr: Int) {
    }

}

接口

package com.example.demos.kotlin

/**
 * 接口
 */
interface kotlin_interface {
    /**
     * 內部伴侶 , 外部可以直接通過類名訪問 , 可以理解成,java的static修飾被統一整理到這裏面了
     */
    companion object {
    }

    /**
     *  嵌套類,與同包下的類權限相同,不能訪問外部成員和方法
     */
    class test1 {
    }
}

符號功能

$									//這個符號代表在字符串中加代碼塊 如:"我叫$name" 或者 "我叫${getName()}"
?									//NULL檢查機制
!!									//確定不爲空
:									//指定參數類型,指定繼承關係
===									//值相等，對象地址才爲true
@									//標籤(例如：abc@、fooBar@、break@loop)

位操作符

shl(bits) – 左移位 (Java’s <<)
shr(bits) – 右移位 (Java’s >>)
ushr(bits) – 無符號右移位 (Java’s >>>)
and(bits) – 與
or(bits) – 或
xor(bits) – 異或
inv() – 反向