《极客时间---快速上手Kotlin开发》学习笔记（二）

极客时间kotlin课程第11 ~ 15讲。

动态代理

对象代理

interface Animal {
 fun bark()
}

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

class Zoo(animal: Animal): Animal by animal {
        override fun bark(){
        println("before")
//        animal.bark()  编译错误
        println("after")
    }
}

fun main(args: Array<String>) {
    Dog().bark()
    Zoo(Dog()).bark()
}

课程中以上面的代码为例子，讲这个叫动态代理

而且在Zoo类中自定义实现的bark方法中，并没有办法在被代理的方法前后做一些事情。（会有编译错误）

这个工具能想到的使用场景，额，适配器，也许吧，感觉作用不大。

这里是官网关于kotlin代理的文档。

属性代理

官网文档相关的属性代理的文档，可以实现如下场景：

• lazy properties: the value gets computed only upon first access;
• observable properties: listeners get notified about changes to this property;
• storing properties in a map, instead of a separate field for each property.

本地属性延迟加载的例子：

class Foo {
    init {
        println("foo init")
    }
    fun isValid():Boolean = false
    fun doSomething(){
        println("do sth")
    }
}

fun example(computeFoo: () -> Foo) {
    val memoizedFoo by lazy(computeFoo)
    if (1 == 2) {
        memoizedFoo.doSomething()
    }
}

fun main(args: Array<String>) {
    example { Foo() }
}

上面这个方法不会输出foo init

其他两个场景，可以到官网看下例子。

数据类

通过data关键字描述类，自动实现get set toString方法，像下面这个Student类。

所以这个是不是可以立刻在自己的项目里开始使用，节省一些代码了。

data class Student(var age: Int, var name: String)

fun main(args: Array<String>) {
    var s = Student(12, "zhangsan")
    println(s.toString())
    println(s.age)
    println(s.name)
    s.age = 14
    s.name = "lisi"
    println(s.age)
    println(s.name)
}

超级枚举

没看到有多超级吧，挺好玩确实

sealed class Action{
    object UP: Action()
    object DOWN: Action()
}

fun exec(action: Action) = when(action){
    Action.UP -> {
        println("up")
    }
    Action.DOWN -> {
        println("down")
    }
}
fun main(args: Array<String>) {
    exec(Action.UP)
}

解构

class Student(var name: String, var age: Int) {
    operator fun component1() = name
    operator fun component2() = age

}

fun main(args: Array<String>) {
    var s = Student("zhangsan", 12)
    var (name, age) = s
    println("$name $age")

    var mapVal = mapOf<String, String>("name" to "zhangsan", "age" to "12")
    for ((k, v) in mapVal) {
        println("$k $v")
    }
}

循环

下面的代码编译错误

var i = 0
for (i = 0; i<10; i++){
  println(i)
}

循环的几种方法

fun main(args: Array<String>) {
    for (i in 1..10) {
        println(i)
    }

    for (i in 1..10 step 2) {
        println(i)
    }

    for (i in 1 until 10) {
        println(i)
    }

    for(i in 10 downTo 0){
        println(i)
    }

    repeat(10){
        println(it)
    }
}

list遍历

 var names = arrayListOf<String>("zhangsan", "lisi")

for (name in names) {
  println(name)
}
//index 和 str2 这两个变量名是无所谓的
for ((index, str2) in names.withIndex()) {
  println("$index    $str2")
}

集合操作符

这一块是第15讲的内容，知识点主要如下代码里的两项。

视频中讲师为了体现kotlin的有点，特意对比的写了一套基于rxjava的写法，一手的内部类做的，java原生也支持lambda的啊，没必要这样。（当然kotlin的lambda肯定是更精简的）

fun main(args: Array<String>) {
    var ages = arrayListOf(1, 2, 3, 4, 5, 6)
    //原生支持各种链式集合操作符号
    ages.map { it - 1 }
            .filter { it > 0 }
            .reduce{i1, i2 -> i1 + i2}
            .also { println(it) }
    ages.convert { it + 1 }.forEach{println(it)}

}

//自定义集合操作符（扩展函数）
inline fun <T, E> Iterable<T>.convert(action: (T) -> E): MutableList<E> {
    val result = mutableListOf<E>()
    for(i in this){
        result.add(action(i))
    }
    return result
}