Kotlin学习笔记：类声明、修饰符、伴随对象、替换静态、单例模式……

1.Kotlin课堂宣言：

​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​如果不需要final修饰符，可以手动在类前添加open修饰符

open class MainActivity: AppCompatActivity()

open class MainActivity: AppCompatActivity()、OnClick Listener

II、

Kotlin修饰符：

private 、 protected 、 public 与 java 相同。
internal 是 Kotlin 特定的修饰符。只能访问同一个模块（Module）中的类，而不能访问其他模块。

3.Kotlin伴生对象，替代static

public class StringUtils {
    public static boolean isEmpty(String string){
        return "".equals(string);
    }
}

我们在Java中经常看到上面的表示方法在kotlin中是不行的，因为kotlin中没有static修饰符。有两种方法可以替换它。一种是jvm静态注解方法，另一种是使用伴生对象，如下：

class StringUtils {
    companion object {
        fun isEmpty(string: String): Boolean {
            return "" == string;
        }
    }
}

伴生对象 应该写在类内部，并作为该类的伴生对象存在。

4. Kotlin单例模式：

class Singleton private constructor() {
    companion object {
        fun getInstance(): Singleton {
            return Holder.instance
        }
    }

    private object Holder {
        val instance = Singleton()
    }
}

5. Kotlin动态代理：

/**
 * 动态代理
 */

    interface Animal{
        fun bark()
    }

    class Dog:Animal{
        override fun bark() {
            println("汪汪")
        }
    }

    class Zoo(animal: Animal) : Animal by animal

    fun main() {
        Zoo(Dog()).bark()
    }

Kotlin 在编译时将动态代理转换为静态，所以 Kotlin 的动态代理肯定比 Java 的动态代理效率更高。因为Java的动态代理是通过一系列反射来实现的。

6. Kotlin循环：

    for (i in 1..10){
        println(i)
    }
    //结果：打印1到10

    for (i in 1 until  10){
        println(i)
    }
    //结果：打印1到9

    for (i in 10 downTo 1){
        println(i)
    }
    //结果：打印10到1

    for (i in 1..10 step 2){
        println(i)
    }
    //结果：打印1,3,5,7,9

    repeat(10){
        println(it)
    }
    //结果：打印0到9


    val list: ArrayList<String> = arrayListOf("a", "b", "c", "d")

    //类似java的写法
    for (str: String in list) {
        println(str)
    }

    //kotlin 解构写法
    for ((index,str) in list.withIndex()){
        println("第${index}个元素是$str")
    }