Kotlin 基础 | 委托及其应用

Android 0 395

托付是常见的办法，它和编程言语无关，即把本来自己做的工作托付给另一个政策去做。装修者办法和署理办法都通过托付复用了行为。Kotlin 在言语层面支撑了托付，这一篇结合实例介绍一下 Kotlin 的托付。

Kotlin 的装修者办法

装修者办法和承继具有相同的意图，都是为了扩展类，kotlin和java只不过它运用了更凌乱的办法通：承继 + 组kotlin是什么意思合。装修者办法在复用原有类型和行为的基础上为其扩展功用。关于装修者办法和署理办法的详细分析能够点击运用组合的规划办法 | 追女孩要用的长途署理办法。

下面是装修者办法的实例：

interface Accessory {
fun name(): Stringkotlin言语 // 配件姓名
fun cost(): Int /approach/  配件价格
fun tyapplicationpe(): String // 配件类别
}

这个接口用来描述一个笼统的配件，一个详细的配件需求结束三个办法，别离来appreciate界说配件姓名、价格、类别application。

茸毛、戒指、耳环是3个详细的配件，它的结束如下：

class Feather: Accessory{
oapplicationverrideapp装置下载 fun naKotlinme(): String = "Feather"
override fun cost(): Int  = 20
override fun type(): String  = "body accessory"
}
class Ring: Accessory{
override fun name(): String = "Ring"
override fun cost(): Int  = 30
override fun type(): String  = "body accessory"
}application
class Earrings: Accessory{
override fun name(): String = "Earrings"
override fun cost(): Int  = 15
override fun tkotlin怎样读ype(): String  =apple "body accessory"
}

现需求新增茸毛戒指和茸毛耳环，依照承继的思想能够这样结束：

class FeatherRing: Accessory{
override fun name(): String = "FeatherRing"
override fun coapp装置下载st(): Int  = 35
override fun type(): String  = "body accessory"
}
cKotlinlakotlin和java差异ss FeatherEarrings:kotlin言语 Accessory{
override fun name(): String = "FeathKotlinerEarrings"
oappleverride fun cost(): Int  = 45
override fun type(): String  = "body accessory"
}

这样写的缺陷是只复用了类型，没复用行为。每次新增类型Kotlin的时分都得新增一个子类，会构成子类胀大。若改用装修者办法，则能够削减一个子类：

class Feather(privateapproach var acceskotlin为什么盛行不起来sory: Accekotlin是什么意思ssory) : Accessory {
overridappreciatee fun name(): Stapplering = "Feather" + accessory.name()
override fun cost(): Int = 20 + accessory.cost()
ovapplicationerridekotlin怎样读 fun type(): String  = accessory.type()
}

现在茸毛戒指和耳环别离能够这样表达Featappleher(Ringappreciate())、Feaapplicationther(Earrings())。app装置下载

Fekotlin面试题ather运app装置下载用组合持有了一个笼统的配件，这样被注入配件的行为就Kotlin得以APP复用。name()和cost()在复用行为的基础上追加了新的功用，而type()直接将结束托付给了accesskotlin面试题ory。

运用 Koappearancetlin 的托付语法能够进一步简化Feather类：

class Feather(private var accessory: Accessory): Accessory by accessory {
override fun name(): String = "Feather" + accessory.name()
override fun cost(): Int =kotlin和java 20 + accessory.cost()
}

by 关键词出现在类名后边，表明类托付，即把类的结束托付一个政策，该政策有必要结束和类相同Kotlin的接口，在这儿是Accessappleory接口。运用by的长处是消除模板代kotlin现在不火了码，就如Kotlin上Kotlin面所示，type()接口的结束就能够省掉。

慵懒初始化一次

慵懒初始化也是一种常见的办法：推延政策的初始化，直到第一次拜访它。当初始化消耗很多资源，慵懒初始化显得特别有价值。

支撑特征是一种结束慵懒初始化的kotlin言语惯用技能：

class BitmapManager {kotlin为什么盛行不起来
// 支撑特征用于存储一组 Bitmap
private var _bitmaps: List<BitKotlinmap>? = null
// 供外部拜访的一组 Bitmap
val bitmaps: List<Bitmap>
get() {
if (_bitmaps == null) {
_bitmaps = loadBitmaps()
}
return _bitmaps!!
}
}

支撑特征_bitmaps是私有的，它用来存储一组 Bitmap，而另一个相同类型的bitmaps用来供应一组 Bitmap 的拜访。

这样只有当第一次拜访BitmapManager.bAPPitmapkotlin面试题s时，kotlin和java差异才会去加载 Bitmap。第2次拜访application时，也不会从头加载 Bitmap，可直接回来_bitmap。

上面这段代码便是 Kotlin 预界说函数lazy()kotlin是什么意思内部运用的技能，有了它appointment就能够消除模板代码：

class BitmapManager {
val bitmaps by lazy { loadappstoreBitmaps() }
}

这儿的关键词by出现在特征名后边，表明特征托付，行将特征的读和写托付给另kotlin怎样读一个政策，被托付的政策有必要满意必定的条件：

  1. 关于 val 修饰的只读变量进行特征托付时，被托付的政策有必要结束getValue()接口，即界说怎样获取变量值。
  2. 关于 var 修饰的读写变量进行特征托付时，被托付政策有必要结束getValue()和setValue()接口，即界说怎样读写变量值。

特征托付的三种结束办法

lazy()办法的回来值是一个Lazy政策：

public actual fun <T> lazyapproach(initializer: () -appear> T): Lazy<T> = SynchronizedLazyImpl(initializer)
public interface LazyAPP<out T> {
public val value: T
public fun isInitikotlin言语alized(): Boolean
}

Lazy类并没有直接结束getValue()方kotlin是什么意思法。它运用了另一种愈加灵敏的办法：kotlin和java

public inlinKotline operaappointmenttor fun <T> Lazy<T>.getValue(thisRef: Any?, property: KProperty<*>): T = value

getValue()被声明为Lazy类的扩展函数。这是 Kotlin 独有的在类体外为类新kotlin和java增功用的特性。在原有类不能被修正的时分，特别好用。

除了扩展函appear数，还有其他两种办法能够结束被托付类（假定署理的类型为 String）：

class Delegate {
operator fun getValue(thisRef: Any?, property: KProperty<*>): String {
return "Deappearlegate"
}
operator fun setValue(thisRef: Any?, property: KProperty<*>, value: String) {
}
}

这种办法新建了一个署理类，并且在类中通过关键词operator重载了getValue()和setValue()这两个运算符，别离对应取值和设置操作kotlin现在不火了。

最终一种办法如下（假定署理的类型为 String）：

claappreciatess Delegate : ReadKotlinWriteProperty<Any?, String> {
override fkotlin是什么意思un getValue(thisRef: Any?, property: KProperty<*>): StriKotlinng {
return "Delegate"
}
override fun setValue(thisRef: Any?, property: KProperty<*>, value: String) {
}
}

即结束ReadWritePropeapplicationrty接口中的getValue()和setValue()办法。

然后就能够像这样approach运用署理类：

class Test {
var str: String by Delegate()
}

特kotlin是什么意思色托付反面的完appstore结如下：

class Teapprovest {
private delegate = Delegate()
var str : String
get () = delegate.getValue(this, kProperty)
set (valueapproach: String) = delegate.approachsetValue(thiskotlin面试题, kProperty, value)
}

新建的Delegate类会被存储到一个支撑特征delegate中，托付特征的设置和取值办法的结束全approve权托付给署理类。

托付之后，当拜访托付特征时就比如在调用署理类的办法：

val test = Text()
val str = test.str // 等价于 val str = test.delegate.getValue(test, kProperty)
val test.str = str // 等价于 test.delegate.setValue(test, Kprappreciateoperty, str)

托付运用

1. 更简练地获取传参

托付能够躲藏细节Kotlin，特别是当细节是一些模板代码的时分：

class TestFragment : Fragment() {
override fappstoreun okotlin和java差异nCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
val ikotlin怎样读d = arguments?.getStrkotlin和javaing("id") ?: ""
}
}
class KotlinActivity : AppCompatActivity() {
overriapproachde fun onCreate(savedInstanceState: Bundle?) {
super.onCreatapp装置下载e(savedInstanceState)
val id = intent?.getStringExtra("id") ?: ""
}
}

获取传递给 Activitappointmenty 或 Fragment 值的代码就很模板。能够运用托付躲藏一下kotlin现在不火了细节：

// 新appearance建 Extras 类kotlin现在不火了作为被托付类
class Extras&kotlin为什么盛行不起来lt;out T>(private val key: String, private val default: T) {
// 重载取值操作符
operatapproachor fun getValue(thisRef: Any, kProperty: KPropappstoreertkotlin面试题y<*>): T? =
when (thappstoreisRef) {
// 获取传递给 Activity 的参数
is Activity -> {appstore thisRef.intent?.extras?appear.get(key) as? T ?: default }
// 获取传递给 Fragment 的参数
isappear Fragmenappreciatet -> { thisRef.argAPPuments?.get(key) as? T ?: default }
else -> default
}
}

然后就能够像这样运用托付：

class TestActivity : AppCompatActivity()app装置下载 {
private val id by Extras("id","0")
}
class TeapplestFragkotlin现在不火了ment : Fragmeapplent() {
private val id by Extras("id"kotlin怎样读,"0")
}

2. 更简练地获取 map 值

有些类的特征不是固定的，而是有时多，有时少，即动态的，比如：

class Person {
private val attrs = hashkotlin是什么意思Mapkotlin怎样读Of<String, Any&gtappearance;()
fun sAPPetAttrs( key: String, value: Any){
attrs[key]appstore = valappstoreue
}
vkotlin和javaal name:kotlin为什么盛行不起来 String
gapplicationet() = attrs["name"]
}

有些Person有孩子，有些没有，所以不同Person实例具有的特征application集是不同的。这种场景用Map来存储特征就很合适。

上述代码能够用托付简化：

class Person {
private val attrs = hashMapkotlin和javaOf<Strinappearg, Any>()
fun setAttrs( key: String, value: Any){
attrs[key] = value
}
val name: String by attrs
}

将name的获取托付给一个 map 政策。奇kotlin和java差异特之处在于，乃至都不需求指定key就能够正确地从 map 中获取 name 特征值。这是由于 Kotlin 标准库已经为 Map 界说了getValue()和sappstoreetValue()扩展函数。特征名将主动作用于 map 的键。

总结

  1. Kotlin 托付分为类托付和特征托付。它们都通过关键词by来进行托付kotlin为什么盛行不起来。
  2. 类托付能够kotlin怎样读用简练的语法将类的结束托付给另一个政策，以削减模板代码。
  3. 特征托APP付能够将对特征的拜访托付给另一个政策，以削减模板代appointment码并躲藏拜访appear细节。
  4. 特征托付有三种结束办法，别离是扩展办法、结束ReadWriteProperty接口、重载运算符。
上一篇 死磕 36 个 JS 手写题（搞懂后，提升真的大）
下一篇 简述TCP可靠性传输设计

相关文章