Kotlin学习笔记-1

文章参考
文章参考

1、变量

class ArgUtils {

    /**
     * 变量 : var 可变变量， val 不可变变量
     * 可以简单的理解为var是可写的，在它生命周期中可以被多次赋值；而val是只读的，仅能一次赋值
     *
     * 一个不可变对象意味着它在实例化之后就不能再去改变它的状态了。
     * 如果你需要一个这个对象修改之后的版本，那就会再创建一个新的对象。
     * 这个让编程更加具有健壮性和预估性。
     * 所以在Kotlin中，只要可能，尽量在Kotlin中首选使用val不变值。
     *
     */
    fun argTest() {

        // var可变变量可多次赋值
        var arg1: String = "test1"
        var arg2: String
        arg2 = "test2"
        arg2 = "test22"
        arg2 = "test222"

        // val不可变变量只能赋值一次（多次赋值会报错）
        val arg3: String = "test3"
        val arg4: String
        arg4 = "test4"

        //变量可以不需要声明类型，光标停留在变量上时按Ctrl+Q可以查看变量类型
        var str1 = "test11" //自动推断出 String 类型
        var num1 = 1 //自动推断出 Int 类型
        val str2 = "test12"
        val num2 = 2


        //低精度类型无法自动转换成高精度类型
        //需要显式地调用对应的类型转换函数进行转换
        val x: Int = 10
        val y: Long = x.toLong()


        /**
         * 字符串
         * $ 表示一个变量名或者变量值
         * $varName 表示变量值
         * ${varName.fun()} 表示变量的方法返回值:
         */
        //原始字符串 由三重引号（"""）分隔, 都会原样输出，不会进行转义
        val rawString = """\a/b\\c//d"""
        println(rawString)  //输出\a/b\\c//d

        //字符串模板表达式 : 以美元符号（$）连接变量，方便字符串拼接
        val str = "test"
        val templateString = "$str has ${str.length} characters"
        println(templateString)  //输出 test has 5 characters
    }


    /**
     * is 运算符 (类似于Java中的instanceof关键字)
     */
    fun getLength(arg: Any): Int {
        if (arg is String) {
            return arg.length
        }
        return 0;
    }

}

判空处理

	/**
     * 判空处理
     * 1、字段后加 ? 可不做处理返回值为 null
     * 2、字段后加 ?: 做空判断处理
     * 3、字段后加 !! 像Java一样抛出空异常
     */
    fun checkNull() {

        //1、类型后加 ? 表示可为空
        var arg: String?
        var arg0: String? = "test"

        //2、arg为空时直接返回null, 不做处理
        val arg1 = arg0?.toInt()

        //3、arg为空时抛出空指针异常
        val arg2 = arg0!!.toInt()

        //4、arg0为空时不做处理，arg0.toInt()为空时返回-1
        val arg3 = arg0?.toInt() ?: -1
    }

区间

	/**
     * 区间
     */
    fun rangeFun() {

        //输出1,2,3,4,5
        for (i in 1..5) print("$i, ")
        println("\n")

        //输出5,4,3,2,1
        for (i in 5 downTo 1) print("$i, ")
        println("\n")

        //输出1,3,5
        for (i in 1..5 step 2) print("$i, ")
        println("\n")

        //输出1,2,3,4
        for (i in 1 until 5) print("$i, ")
        println("\n")

        //输出4
        val x: Int? = 4
        if (x in 1..5) {
            print("$x\n")
        }
    }

2、方法

class FunUtils {

    /**
     * 定义方法用 fun, 后面通过 : 接返回值类型, 无返回值不需要写
     *
     * 四种限定符：
     * public : 默认限定符，可以省略不写
     * private
     * protected
     * internal : 同模块限定符。同一 module可以调用 被internal修饰的方法, 跨module不行
     */
    fun sum1(a: Int, b: Int): Int {
        return a + b
    }

    fun sum2(a: Int, b: Int) = a + b  //返回类型自动推断为 Int

    //无返回值, 不写
    fun test1() {
        println("test1")
    }

    //无返回值, Unit修饰
    fun test2(): Unit {
        println("test2")
    }


    /**
     * 可变长参数函数
     * 参数可以用 vararg 关键字进行标识
     * 例 : varsArgFun(1,2,3,4,5) 结果为 15
     */
    fun varsArgFun(vararg args: Int): Int {
        var sum: Int = 0
        for (temp in args) {
            sum += temp
        }
        return sum
    }


    /**
     * 静态的属性、常量、函数 --- 使用 companion object
     * 这个对象被  这个类的所有对象 所共享，对象里的属性或者方法就像Java中的静态属性或者方法
     * 但是并不是静态属性或方法，其实只是创建 Companion静态对象 来调用里面的属性和方法。
     */

    companion object {
        //伴生方法，类似静态方法
        fun staticFun1() = "static fun 1"

        //定义静态方法的方式二，加静态注解
        @JvmStatic
        fun staticFun2() = "static fun 2"
    }
}

3、其他

想让变量以public static final的字段呈现给调用者，可以在var 或者val前面加上const修饰符

class KotlinUtils {
    
    companion object{
        const val TAG : String = "TAG_ZLZ"
    }
}

持续更新中。。。。。。