第一行代码 (第三版) 第八，九，十章

一: 泛型和委托

1.泛型

        泛型类:

                 class MyClass<T>{

                        fun method(param: T) : T {

                                return param

                        }

                }

        泛型方法：

                class MyClass {

                        fun <T> method(param: T ) :T   {

                                return param

                        }

                }

        kotlin 允许对泛型的类型进行限制：指定上界的方式来对类型进行约束

                class MyClass {

                        fun <T : Number> method(param: T) : T{

                                return param

                        }

                }

        实例：apply

                fun <T> T.builder (block: T.() -> Unit) : T {

                        block()

                        return this

                }               

2.委托

        基本理念：操作对象自己不会去处理某段逻辑，而是把工作委托给另一辅助对象去处理

        类委托：by

        一个类的具体实现委托给另一个类去处理（大部分方法调用辅助对象的方法，少部分实现

        由自己来重写），Java中辅助对象方法必须每个重写，而kotlin提供了委托（by）

                java: 辅助对象方法必须每个重写

                class MySet<T>(val helperSet : HashSet<T>) : Set<T> {

                        override val size : Int get () = helperSet.size

                        override fun contains(element : T)= helperSet.contais(element)

                        ......

                        overide fun iterator() = helperSet.interator()

                }

                kotlin:只写 对某个方法的重新实现

                    class MySet<T>(val helperSet : HashSet<T>) : Set<T> by helperSet {       

                          fun helloWorld() = println("Hellp World")

                          override fun isEmpty() = false

                        }

        

        委托属性：

                将一个属性（字段）委托给另一个类去完成

                class MyClass{

                        var p by Delegate()

                }

                class Delegate {

                        var propvalue : Any? = null

                        operator fun getValue(myClass : MyClass, prop: KProperty<*>) : Any?{

                                return propvalue

                        }

                          operator fun setValue(myClass : MyClass, prop: KProperty<*>,value : Any?) {

                                propvalue = value

                                }

                        }

3.实现一个lazy函数

        val p by lazy {} （代码块中的代码只会执行一次）

        lazy实现原理：by 关键字，lazy高阶函数（lazy - Delegate - getValue - Lambda）

        仿写：懒加载技术是不会对属性进行赋值的(Lambda,最后一行作为返回)

                class Later <T> (val block : () -> T){

                        var value : Any? = null

                        operator fun getValue (any: Any?,prop:KProperty<*>): T{

                                if (value == null){

                                        value = block()

                                }

                                return value as T

                        }

                }

        注意：later定义为顶层函数(不定义在任何类中的函数才是顶层函数)

        fun <T> later(block: () -> T) = Later(block)

        使用：

                val uriMatcher by later{

                        val mathcher = UriMatcher (UriMatcher.NO_MATCH)

                        matcher.addURI(authority,"book",bookDir)

                        matcher.addURI(authority,"book/#",bookItem)

                        matcher.addURI(authority,"category",categoryDir)

                        matcher.addURI(authority,"category/#",categoryItem)

                        matcher

                }

二：infix 函数

                infix : 允许将我们调用函数时的小数点，括号等计算机相关的语法去掉

                        (A to B)

                前提条件：

                        1.infix 不能定义成顶层函数，必须是某个类的成员函数

                        2.infix 函数必须接收且只能接收一个参数

                定义：

                infix fun String.beginWith(prefix: String) = startWith(prefix)

                调用：

                if ("hello world" beginWith "hello"){

                }

               举例：

                        定义：

                                infix fun <T> Collection<T>.has(element : T) = contains(element)

                        使用：

                                val list = listOf{"Apple","Banana","Orange"}

                                if （   list has "Banana"）{

                                     

                                }

三：泛型的高级特性

1.实化  (T :: class.java)

        前提： 

                1.inline 关键字

                2.reified 关键字

        inline fun <reified T> getGenericType(){

        } 

        inline fun <reified T> getGenericType() = T :: class.java

2.应用(startActivity)

        定义：

        inline fun <reified T>startActivity(context :Context, block : Intent.() -> Unit ){

                val intent = Intent(context, T :: class.java)

                intent.block()

                context.startActivity(intent)

        }

        使用：

      startActivity<MainActivity>(context){

                putExtra("param1","data")

                putExtra("param2",123)

        }

3.协变

4.逆变