父类返回子类类型的函数写法

野性酷女 2022-04-25 07:12 174阅读 0赞

![640?wx\_fmt=jpeg][640_wx_fmt_jpeg]

今天的话题很简单，分享下也许对大家可以有帮助或者有启发。

## 1. 背景 ##

一看题目，有点儿晕。看个例子马上就明白了：

1.  `abstract class EventBuilder() {`
2.  `   protected var retryLimit = 3`
3.    
    
4.  `   fun retryLimit(retryLimit: Int): EventBuilder {`
5.  `       this.retryLimit = retryLimit`
6.  `       return this`
7.  `   }`
8.    
    
9.  `   abstract fun build(): PollingEvent`
10. `}`

我们有这么一个类，一看就是要写 Builder 模式。不过由于我们的这个 Event 的类型比较多，因此希望写一个父类，来一个子类感受下：

1.  `class DisposableEventBuilder : EventBuilder() {`
2.  `   private var delay: Long = 0L`
3.  `   fun delay(delay: Long): DisposableEventBuilder {`
4.  `       this.delay = delay`
5.  `       return this`
6.  `   }`
7.    
    
8.  `   override fun build() = object: DisposableEvent(name, delay){`
9.  `       override fun onDisposableEvent() {`
10. `           callback.onEvent(this)`
11. `       }`
12. `   }`
13. `}`

看上去也没啥大毛病，用一下吧：

1.  `DisposableEventBuilder().retryLimit(3)`
2.  `       .delay(60_000) // ERROR!!`
3.  `       .build()`

我们调用完父类的 `retryLimit` 方法后，想要设置下 `delay`，结果发现没有这个方法。

> “我 X，这什么玩意儿”，你嘟囔了一句。

因为返回的是父类，所以链式调用掉链子了。这就尴尬了。

## 2. Scala 的解法 ##

如果这段代码用 Scala 写，那么用 `this.type` 就简直完美的解决了这个问题：

1.  `abstract class SuperBuilder {`
2.  `   private var retryLimit: Int = 0`
3.    
    
4.  `   def retryLimit(retryLimit: Int): this.type = {`
5.  `       this.retryLimit = retryLimit`
6.  `       this`
7.  `   }`
8.  `}`
9.    
    
10. `class SubBuilder extends SuperBuilder {`
11. `   private var delay: Long = 0`
12.   
    
13. `   def delay(delay: Long): SubBuilder = {`
14. `       this.delay = delay`
15. `       this`
16. `   }`
17. `}`

调用时：

1.  `new SubBuilder().retryLimit(3).delay(60000)`

一点儿毛病都么有。

Kotlin 有这个特性吗？并没有。

## 3. Kotlin 的解法 ##

Kotlin 倒也不是没有办法解决这个问题，用下泛型就好了：

1.  `abstract class EventBuilder<T : EventBuilder<T>>() {`
2.  `   protected var retryLimit = 3`
3.    
    
4.  `   fun retryLimit(retryLimit: Int): T {`
5.  `       this.retryLimit = retryLimit`
6.  `       return this as T`
7.  `   }`
8.    
    
9.  `   abstract fun build(): PollingEvent`
10. `}`

这个泛型给父类加了一个泛型参数，这个参数则必须是当前类的子类，那么这样的话我们就可以在返回自身类型的位置返回 T 这个类型了。

子类的改动就很简单了，只需要给父类加一个泛型参数为自己的类型即可：

1.  `class DisposableEventBuilder : EventBuilder<DisposableEventBuilder>() {`
2.  `    ...`
3.  `}`

其他的什么也不用动，这时候我们的链式调用就没啥问题了：

1.  `DisposableEventBuilder().retryLimit(3)`
2.  `       .delay(60_000) // OK!!`
3.  `       .build()`

这一点上 Kotlin 和 Java 其实是一致的，所以你也可以用 Java 写出类似的代码：

1.  `abstract class SuperBuilder<T extends SuperBuilder<T>> {`
2.  `   private int retryLimit = 0;`
3.    
    
4.  `   T retryLimit(int retryLimit) {`
5.  `       this.retryLimit = retryLimit;`
6.  `       return (T) this;`
7.  `   }`
8.  `}`
9.    
    
10. `class SubBuilder extends SuperBuilder<SubBuilder> {`
11. `   private long delay = 0;`
12.   
    
13. `   SuperBuilder delay(long delay) {`
14. `       this.delay = delay;`
15. `       return this;`
16. `   }`
17. `}`

好了，今天就先这样~~

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

转载请注明出处：微信公众号 Kotlin

![640?wx\_fmt=jpeg][640_wx_fmt_jpeg 1]

[640_wx_fmt_jpeg]: /images/20220125/e9f6eee3a0ad49149b0d3bb57b93ae0f.png
[640_wx_fmt_jpeg 1]: /images/20220125/e4c5e279c61e4511b78f3330b4ed2cf9.png