代碼講解-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 = {
    }
}

關鍵詞

/**
 * 關鍵詞
 * 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 {
    }
}