代码讲解-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 {
    }
}