Kotlin续(一)

1、静态类和变/常量：

如果整个类都是静态的，可使用Object 来修饰类

object TestData {
    val TAG = TestData::class.java.simpleName

    fun test1(): String {
        return "123"
    }
}

如果只是类中的一部分是静态的，那么我们可以使用companion object 来修饰方法或变/常量

class TestData {
    val TAG = TestData::class.java.simpleName
    fun test1(): String {
        return "123"
    }
    companion object {
        val testString = "我是一个静态常量"
        fun test2(): String {
            return "我是一个静态方法"
        }
    }
}

就想这样，用companion object{ }把静态变/常量、方法包裹起来就好了

2、构造方法 和多构造方法

2.1只有一个构造方法

class SMSMessage(messageType: Int) {
    var MessageType: Int? = null

    //为构造方法的参数赋值
    init {
        this.MessageType = messageType
    }
}

2.2只有一个构造方法

在构造方法中添加'var'/'val'关键字，就等于为此类添加了这个属性，不用再声明属性和初始化

class SMSMessage(var messageType: Int) {
    
    //为构造方法的参数赋值
    init {
     
    }
}

2.2主构造方法和多个次构造方法

次构造方法不会走init初始化方法

class EventMessage constructor(messageType: Int) {
    var MessageType: Int? = null
    var MessageFlag: Boolean? = null
    var MessageString: String? = null

    init {
        MessageType = messageType
    }

    //次构造方法一
    constructor(messageType: Int, messageFlag: Boolean) : this(messageType) {
        MessageFlag = messageFlag
    }
    //次构造方法二
    constructor(messageType: Int, messageString: String) : this(messageType) {
        MessageString = messageString
    }
}

3、类的扩展方法

这里有一个类，由于某些原因不方便修改次类，我们可以为此类添加一个扩展方法

class NoticeBean(var NoticeTitle: String, var NoticeContent: String)  {
 
}

声明扩展方法和什么普通方法几乎一致，需要在方法名前边添加类名

    fun NoticeBean.toJson(bean: NoticeBean) {
        LogUtils.loge("JSON:${MiJsonUtil.getJson(bean)}")
    }

扩展方法的使用

 val testBean = NoticeBean("小米标题", "小米内容")
 testBean.toJson(testBean)

4、for循环

4.1until和..的区别

  //打印 0，1，2，3，4
    for (index in 0 until 5) {
        System.err.println(index)
    }
//打印 0，1，2，3，4，5
    for (index in 0 .. 5) {
        System.err.println(index)
    }
//不想以1为增量
    for (index in 1..100 step 2){
        System.err.println(index)//会输出1..3..5......
    }
//如果想实现下边这种效果
     for (int i = 0; i < 100; ) {
         i++;
     }
//可以这样写
    var i = 0
    while (i < 100) {
        i++
    }

4.2跳出循环

        //这里注意，return@outside 必须写在 run ounside@{}里边，而return@forEach不用
        run outside@{
            (0..10).forEach {
                LogUtils.loge("aaaaaaa==${it}")
                if (it % 2 == 0) {
                    //跳出当前循环 相当于continue
                    LogUtils.loge("${it}")
                    return@forEach
                }
                if (it == 9) {
                    //跳出整个循环,相当于break
                    return@outside
                }
            }
        }

5、声明暂不实例化的变量(lateinit关键字)

lateinit 关键字表示不用IDE管这个是不是为空了，后边在使用的时候肯定不会为空的

lateinit var mRoomDetailsViewpager: ViewPager

6、“==”于“===”

• “==”是比较的两个对象的值
• “===”是比较的两个对象的存储地址

    var mes = arrayListOf<String>("1", "2", "3")
    var mes1 = arrayListOf<String>("1", "2", "3")
    var mes2 = mes
    System.err.println(mes == mes1)//true
    System.err.println(mes === mes1)//false
    System.err.println(mes == mes2)//true
    System.err.println(mes === mes2)//true