【kotlin】Kotlin笔记20-委托(by,lazy)

青旅半醒 2022-11-18 13:44 191阅读 0赞

### Kotlin笔记20-泛型和委托-by,lazy原理 ###

**12.2 泛型和委托**

*  **类委托和委托属性**

<table> 
 <thead> 
  <tr> 
   <th align="left">序号</th> 
   <th align="left">Tips</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">委托</td> 
   <td align="left">设计模式</td> 
  </tr> 
  <tr> 
   <td align="left">基本理念</td> 
   <td align="left">操作对象自己不会去处理某段逻辑,而是会把工作委托给另外一个辅助对象去处理</td> 
  </tr> 
  <tr> 
   <td align="left">Java</td> 
   <td align="left">对于委托并没有语言层级的实现</td> 
  </tr> 
  <tr> 
   <td align="left">C#</td> 
   <td align="left">对委托进行了原生的支持</td> 
  </tr> 
  <tr> 
   <td align="left">Kotlin</td> 
   <td align="left">博采众长,支持委托功能</td> 
  </tr> 
  <tr> 
   <td align="left">类委托核心思想</td> 
   <td align="left">将一个类的具体实现委托给另外一个类去完成</td> 
  </tr> 
 </tbody> 
</table>

*类委托*

class MySet<T>(private val helperSet: HashSet<T>) : Set<T> {
        override val size: Int
            get() = helperSet.size
    
        override fun contains(element: T) = helperSet.contains(element)
    
        override fun containsAll(elements: Collection<T>) = helperSet.containsAll(elements)
    
        override fun isEmpty() = helperSet.isEmpty()
    
        override fun iterator() = helperSet.iterator()
    }
    //接收HashSet参数作为辅助对象,调用辅助对象中的方法实现,这其实是一种委托模式

<table> 
 <thead> 
  <tr> 
   <th align="left">序号</th> 
   <th align="left">Tips</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">1.委托模式的意义</td> 
   <td align="left">让大部分的方法实现调用对象的方法,少部分方法实现由自己重写,加入自己独有的方法,那么MySet就会成为全新的数据结构类</td> 
  </tr> 
  <tr> 
   <td align="left">2.弊端</td> 
   <td align="left">方法多的情况下,每个都去调用辅助对象的相应方法实现大量的模板代码</td> 
  </tr> 
  <tr> 
   <td align="left">3.优势</td> 
   <td align="left">相较于Java, Kotlin中可以通过类委托的功能来解决</td> 
  </tr> 
 </tbody> 
</table>

> **by:** 接口后声明,接上受委托的对象

`Example:`

class MySet1<T>(private val helperSet: HashSet<T>) : Set<T> by helperSet {}

class MySet1<T>(private val helperSet: HashSet<T>) : Set<T> by helperSet {
        fun helloWorld() = println("Hello World")
    
        override fun isEmpty() = false
    }

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th align="left">Tips</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td align="left">委托对我们简化代码</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td align="left">我们对某个方法进行重新实现,只需要单独重写一个方法就可以了,其他方法任然可以享受类委托的遍历</td> 
  </tr> 
 </tbody> 
</table>

*委托属性*

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th align="left">委托属性</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1核心思想</td> 
   <td align="left">将一个属性(字段)的具体实现委托给另一个类去完成</td> 
  </tr> 
 </tbody> 
</table>

`委托属性-语法结构:`

class MyClass3{
        var p by Delegate()
    }

`p属性的具体实现委托给了Delegate`

//当调用p属性的时候会自动调用Delegate类的getValue()方法
    //当给p赋值会自动调用Delegate类的setValue()方法
    
    class Delegate {
        var propValue: Any? = null
    
        operator fun getValue(myClass: MyClass3, prop: KProperty<*>): Any? {
            return propValue
        }
    
        operator fun setValue(myClass: MyClass3, prop: KProperty<*>, value: Any?) {
            propValue = value
        }
    }

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>参数</th> 
   <th align="left">作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>getValue()</td> 
   <td>MyClass</td> 
   <td align="left">声明该Delegate类的委托功能可以在什么类中使用,这里仅可在MyClass中使用</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>KProperty&lt;*&gt;</td> 
   <td align="left">属性操作类,可用于获取各种属性相关的值,这里必须在方法参数上声明</td> 
  </tr> 
  <tr> 
   <td>setValue()</td> 
   <td>…</td> 
   <td align="left">…</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>value: Any?</td> 
   <td align="left">具体要赋值给委托属性的值,必须和getValue()方法返回值类型一致</td> 
  </tr> 
 </tbody> 
</table>

*不用在Delegate中实现setValue的情况*

`p属性为val`

--------------------

*  **实现一个自己的lazy函数**

> **lazy:** 懒加载技术,高阶函数

`语法结构:`

val p by lazy {...}

`实现原理:`

class Later<T>(private val block: () -> T) {
        var value: Any? = null
    
        operator fun getValue(any: Any?, prop: KProperty<*>): T {
            if (value == null) {
                value = block
            }
            return value as T
        }
    }

`让用法更像lazy函数:`

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

`用法:`

val uriMatcher by later {
    	val matcher = UriMatcher(UriMatcher.NO_MATCH)
    	matcher .addURI(authority, "book", bookDir)
    	...
    	matcher
    }

`验证:`

val p by later {
    	Log.d("Tag", "run codes inside later block")
    	"test later"
    }

--------------------

**q(≧▽≦q) Kotlin新特性**

1.  <\*>这种泛型写法表示不知道或不关心泛型的具体类型,类似与Java中的<?>