[3] —— 每次都有点新收获

作者: junerver | 来源:发表于2018-06-15 16:53 被阅读19次

    转载请标明作者与出处:https://www.jianshu.com/p/91c6f28adb31

    遍历集合、控制流、伴生对象

    遍历集合

    在 Java 中我们经常需要遍历一些数组或者集合时我们常用的操作是这样的:

    List<String> list = new ArrayList();
    list.add("1");
    list.add("2");
    list.add("3");
    for (String item : list) {
        System.out.println(item);
    }
    list.forEach((s)-> System.out.println(s)); //Java8中我们可以使用 Lambda 表达式
    

    最常用的应该还是增强 for 循环,在 Kotlin 中我们也可以使用这种增强 for 循环,只是格式不太一样:

    var list:List<String> = listOf("1","2","3","4")
    for (item in list) {
        println(item)
    }
    list.forEach { println(it) }
    

    我们还可以这样来使用:

    for (index in list.indices) {
        println(list[index])
    }
    

    调用集合的indices方法可以获得集合的范围,上述代码运行时等同于

    for (index in 0..list.lastIndex) {
       println(list[index])
    }
    

    遍历一个 Map 以及字符串模板:

    image.png

    强大的判断

    在第一篇文章中我们曾经提到过,在 Kotlin 中 if-else 不仅仅是判断语句,他更是一个有返回值的表达式,代码块的最后一行的值就是他的返回值。所以,在 Kotlin 中,我们可以写出这样的代码:

    override fun onKeyDown(keyCode: Int, event: KeyEvent): Boolean {
        return if (keyCode == KeyEvent.KEYCODE_BACK && event.action == KeyEvent.ACTION_DOWN) {
            if (!acStateIsMap) {
                mLlMap.visibility = View.VISIBLE
                mLlSearch.visibility = View.GONE
                acStateIsMap = true
                false
            } else {
                this.setResult(Activity.RESULT_CANCELED)
                finish()
                true
            }
        } else {
            super.onKeyDown(keyCode, event)
        }
    }
    

    在 Kotlin 中还有一个强大的判断表达式:when,这是一个加强版的 if-else 表达式,Kotlin 中推荐我们使用 when 来代替 switch。如果 when 作为一个表达式使用,则必须有 else 分支,除非编译器检查出我们已经在其中覆盖了全部的情况。

    var result = when (mutablemap.size){
        1-> 1
        2 ->{
            println("我是一个when中的代码块")
            "一共有两个"
        }
        3->"3"
        else -> println("大于3个")
    }
    

    可以参考 Kotlin中when表达式的使用:超强的switch(KAD 13)

    伴生对象与静态成员

    首先我们来看看 Kotlin 中对伴生对象的定义:

    类内部的对象声明可以用 companion 关键字标记:

    class MyClass {
       companion object Factory {
           fun create(): MyClass = MyClass()
       }
    }
    

    该伴生对象的成员可通过只使用类名作为限定符来调用:

    val instance = MyClass.create()
    

    可以省略伴生对象的名称,在这种情况下将使用名称 Companion:

    class MyClass {
       companion object {
       }
    }
    val x = MyClass.Companion
    

    请注意,即使伴生对象的成员看起来像其他语言的静态成员,在运行时他们仍然是真实对象的实例成员,而且,例如还可以实现接口:

    interface Factory<T> {
       fun create(): T
    }
    
    class MyClass {
       companion object : Factory<MyClass> {
           override fun create(): MyClass = MyClass()
       }
    }
    

    简单解释就是,伴生对象是与所在类共生的一个对象,请注意这个对象是个天然的单实例:

    伴生对象是天然的单实例
    由于这个特性,我们可以在伴生对象中声明一个成员,这个成员的实际效果,将等同于在 Java 中创建的一个单例的实例。如果伴生对象没有命名我们将使用 类名.Companion 来访问,如果命名了则使用 类名.伴生对象命名 来访问,但这不是必须的,通常下是可以省略的。

    我们在 Java 中申明一个全局能够使用的常量时,一般是这样的:

    class Constants{
        public static final String SERVER = "xxxxxxxx";
    }
    

    利用伴生对象的属性特点我们可以这样声明一个常量:

    class Constants{
        companion object {
            const val SERVER = "xxxxx"
        }
    }
    

    在调用时 Java 与 Kotlin 是完全一样的 :Constants.SERVER,注意这里的 const 修饰符不是必须的,我们声明成 val 只读时,他就是一个单例模式的对象中成员变量。加修饰符的话,就是单例模式中的一个静态成员,根据我们自己的实际情况来决定。

    如果我们只是要声明一个基本类型的静态常量,完全不用这么麻烦
    在任意 Kotlin 文件的顶层声明冠以 const 的修饰符即可。

    package com.moxigua.smarthome.test
    
    const val SERVER = "XXXXXX"
    

    但是这两者是不同的,前面我们已经说了,伴生对象是一个单例,所以我们访问的时候需要先写上类名,而在顶层的静态常量则不需要。
    访问时:


    image

    需要注意的是,这俩者的 import 是不同的,伴生对象调用时,需要导入这个类,而顶层声明的静态常量直接导入该常量即可!

    相关文章

      网友评论

        本文标题:[3] —— 每次都有点新收获

        本文链接:https://www.haomeiwen.com/subject/hgmasftx.html