Kotlin备忘

1. as是不安全的类型转换, as? 是安全的类型转换

• as : 如果被转换的对象是null,或者类型不符,会触发异常
• as? : 如果被转换的对象是null,或者类型不符,会校验并返回null

private fun <T : View> getView(@IdRes id: Int): T? {
    val view: View? = viewHashMap[id]
    //return view as T?
    //as : 不安全的类型转换
        //如果被转换的对象是null,或者类型不符,会触发异常
        /**
        private final View getView(@IdRes int id) {
            View view = (View)this.viewHashMap.get(id);
            return view;
        }
         */

    //as? : 安全的类型转换
        //如果被转换的对象是null,或者类型不符,会校验并返回null
        /**
        private final View getView(@IdRes int id) {
            View view = (View)this.viewHashMap.get(id);
            View var10000 = view;
            if (!(view instanceof View)) {
                var10000 = null;
            }
            return var10000;
        }
        */
    return view as? T
}

2. Kotlin中声明枚举

enum class EnumClass1{
    //格式如下: 
    //Instance{}, Instance{}, Instance{}; 
    //abstract fun absFunName(param:Param):Result
    //open fun funName(param:Param):Resule{ return Result() }
    
    Instance1{
        //枚举类的抽象函数,枚举实例必须实现
        override fun f1():String{
            return "Instance1"
        }
    },
    Instance2{
        override fun f1():String{
            return "Instance2"
        }
        //枚举类的普通函数,枚举实例可以重写,也可以不重写
        override fun f2():Int{
            return 101
        }
    },
    Instance3{
        override fun f1():String{
            return "Instance3"
        }
    };
    
    //可以声明抽象函数
    //抽象函数枚举实例必须实现
    abstract fun f1():String
    //可以声明普通函数
    //普通函数枚举实例可以重写
    open fun f2():Int{
        return 100
    }
}

3. const val

• const val 只能声明在 object 或 companion object 中
• const val 相当于静态常量 / public static final

4. 数据类

• 数据类默认提供了 setter/getter, equals, hashCode, toString, copy, componentN
• 数据类的copy是浅拷贝
• componentN的存在是为了支持'解构'
  • 数据类支持 解构/将构造函数中的参数全部获取到.

data class DataClass1(var a1: String?, val a2: Int?, val a3: String)

fun main() {
    val a1: DataClass1 = DataClass1("1", 2, "3")
    val a2: DataClass1 = a1.copy()
    println(a1)
    println(a2)
    //== 是equals比较两个对象的属性值是否一致
    //=== 是比较两个对象是否是同一个对象
    println(a1 == a2)
    println(a1 === a2)
    /**
    运行结果
    DataClass1(a1=1, a2=2, a3=3)
    DataClass1(a1=1, a2=2, a3=3)
    true
    false
     */
     
    val (at1, at2, at3) = a1
    println(at1)
    println(at2)
    println(at3)
    /**
    运行结果
    1
    2
    3
     */
}

5. 方法最后1个参数是lambda表达式,可以将其写到外面.

fun main() {
    val list: List<String> = listOf("1","22","333")
    val result = list.filter {
        it.length > 1
    }
    result.forEach{
        println(it)
    }
    /*
    22
    333
    * */
}

6. @JvmOverloads 用于包含默认值参数的方法

class CustomConstraintHelper1 @JvmOverloads constructor(
    context: Context,
    attrs: AttributeSet? = null,
    defStyleAttr: Int = 0
) : ConstraintHelper(context, attrs, defStyleAttr) {
    @JvmOverloads
    fun f1(p1:Int = 1, p2:String?, p3:Long = 100){
    }

    override fun updatePostLayout(container: ConstraintLayout?) {
        getViews(container).forEach {
            animate(it)
        }
    }

    private fun animate(view: View) {
        val alpha: ValueAnimator = ObjectAnimator.ofFloat(view, "alpha", 0.0F, 1.0F)
        alpha.duration = 3000
        val scale: ValueAnimator = ObjectAnimator.ofFloat(view, "scaleX", 2.0F, 1.0F)
        scale.duration = 3000
        alpha.start()
        scale.start()
    }
}

• @JvmOverloads注解可以用于 构造方法，普通方法
• 只有当方法中包含默认值的参数，才需要使用@JvmOverloads