1. 递归定义泛型

1.1 原始情况-问题由来

当我们定义了如下的关系的类时：

abstract class AbstractBuilder {
    private var id: Int? = null

    open fun setId(id: Int): AbstractBuilder {
        this.id = id
        return this
    }
}

open class MyBuilder1 : AbstractBuilder() {
    private var name: String? = null

    open fun setName(name: String): MyBuilder1 {
        this.name = name
        return this
    }
}

class MyBuilder2 : MyBuilder1() {
    private var age: Int? = null

    fun setAge(age: Int): MyBuilder2 {
        this.age = age
        return this
    }
}

我们想要依次完成setId/setName/setAge的链式调用，但是当我们完成了setId之后，发现完成不了setName和setAge了，因为setId返回的是AbstractBuilder类型，而不是它的子类类型。

MyBuilder2().setId(1)

如果我们想要完成链式调用，可以使用下面的代码

((MyBuilder2().setId(1) as MyBuilder2).setName("wanna") as MyBuilder2).setAge(18)

但是这个过程中，使用到了多次强转。但是我们明明已经知道this其实是个MyBuilder2类型了呀，为啥还要我强转啊！！！

原因在于，在父类当中根本无法知道子类的类型。这个很容易理解对吧，我怎么有哪些子类会存在？但是我们可以利用泛型去进行实现，我们通过泛型让子类告诉父类我是什么类型。

1.2 使用泛型去实现让父类知道子类的类型

abstract class AbstractBuilder<B : AbstractBuilder<B>> {
    private var id: Int? = null

    open fun setId(id: Int): B {
        this.id = id
        return this as B
    }
}

open class MyBuilder1 : AbstractBuilder<MyBuilder1>() {
    private var name: String? = null

    open fun setName(name: String): MyBuilder1 {
        this.name = name
        return this
    }
}

class MyBuilder2 : MyBuilder1() {
    private var age: Int? = null

    fun setAge(age: Int): MyBuilder2 {
        this.age = age
        return this
    }
}

我们在AbstractBuilder当中定义了泛型B，而B又必须继承于AbstractBuilder<B>，在子类MyBuilder1当中，我们将泛型类型B设置为自己本身的类型，这样，在父类当中通过this as B，就可以拿到MyBuilder1类型了。

但是当我们调用完setId和setName之后，因为不管AbstractBuilder中的setId方法还是MyBuilder1中setName方法返回的还是MyBuilder1类型，并不是MyBuilder2类型的。

MyBuilder2().setId(1).setName("wanna")

我们继续改造

abstract class AbstractBuilder<B : AbstractBuilder<B>> {
    private var id: Int? = null

    open fun setId(id: Int): B {
        this.id = id
        return this as B
    }
}

open class MyBuilder1<B : MyBuilder1<B>> : AbstractBuilder<B>() {
    private var name: String? = null

    open fun setName(name: String): B {
        this.name = name
        return this as B
    }
}

class MyBuilder2 : MyBuilder1<MyBuilder2>() {
    private var age: Int? = null

    fun setAge(age: Int): MyBuilder2 {
        this.age = age
        return this
    }
}

我们让MyBuilder1也带上泛型B，并且约束泛型类型必须继承于MyBuilder1<B>，接着在MyBuilder2当中继承时，也带上MyBuilder2的泛型了。

接着，我们就可以完成我们的需求，依次完成setId/setName/setAge。

MyBuilder2().setId(1).setName("wanna").setAge(18)

不管是setId/setName/setAge，返回的类型都会根据我们传递的泛型类型去推断。也就是说，当我们使用MyBuilder2去创建对象时，setId/setName/setAge返回的都是MyBuilder2类型。

1.3 递归定义泛型的作用

我们想让父类A知道子类B的类型，我们完全可以在父类当中定义泛型H : A<H>，在子类B当中去定义一个泛型H : B<H>，如果B再来一个子类C，我们可以继续去在C当中去定义泛型H : B<H>。实际上，在很多语言当中，我们管父类中匹配子类的类型称为self，父类返回父类自身称为this，但是在Kotlin和Java当中，都是没有提供self的特性的。

有一个问题：为什么MyBuilder2当中继承父类的是<MyBuilder2>，而不是像之前说的，定义一个泛型H呢。因为MyBuilder2类本身就不是open的，也就是说这个类是final的，已经不允许子类去继承了，因此我们完全可以写死泛型类型。

还有个问题，我们如果想要构造一个MyBuilder1，去完成setId和setName呢？需要怎么做，因为该类MyBuilder1的泛型，是需要我们去定义的，我们需要传递一个MyBuilder1的泛型进去。

MyBuilder1<MyBuilder1>().setId(1).setName("wanna")

但是，这样使用是不是感觉没有MyBuilder2那样简洁呢？在Kotlin1.6之后，支持将泛型抹掉，直接使用如下的方式去进行构建：

MyBuilder1().setId(1).setName("wanna")

Kotlin会直接支持泛型的类型匹配，因为我们在MyBuilder1的泛型当中定义了泛型B : MyBuilder1<B>。因此当我们省略泛型时，Kotlin能够自动对泛型进行匹配，得到MyBuilder1的泛型类型，从而可以让我们省略泛型可以不写。但是，在Kotlin1.6之前是并不支持这样的泛型推断的。、、

实际上，Java当中完全同理

abstract class AbstractBuilder<B extends AbstractBuilder<B>> {

    private int id;

    public B setId(int id) {
        this.id = id;
        return (B) this;
    }
}

class MyBuilder1<B extends MyBuilder1<B>> extends AbstractBuilder<B> {

    private String name;

    public B setName(String name) {
        this.name = name;
        return (B) this;
    }
}

final class MyBuilder2 extends MyBuilder1<MyBuilder2> {

    private int age;

    public MyBuilder2 setAge(int age) {
        this.age = age;
        return this;
    }
}

完全能够推断出来self类型，MyBuilder1也支持不指定泛型去进行创建对象。

        new MyBuilder2().setId(1).setName("wanna").setAge(18);
        new MyBuilder1<>().setId(1).setName("wanna");

1.4 递归定义泛型的应用

在Netty中，定义了如下的类

AbstractBootstrap<B extends AbstractBootstrap<B, C>, C extends Channel>

而AbstractBootStrap的子类有如下两个

ServerBootstrap extends AbstractBootstrap<ServerBootstrap, ServerChannel>
Bootstrap extends AbstractBootstrap<Bootstrap, Channel>

在我们使用中，会使用如下的方式去创建ServerBootStrap，并启动Netty程序。

        NioEventLoopGroup bossGroup = new NioEventLoopGroup(bossLoops);
        NioEventLoopGroup workerGroup = new NioEventLoopGroup(workerLoops);
        ServerBootstrap serverBootstrap = new ServerBootstrap();
        serverBootstrap.group(bossGroup, workerGroup)
                .channel(NioServerSocketChannel.class)
                .childHandler(initializer)
                .childOption(ChannelOption.SO_KEEPALIVE, true);
        ChannelFuture future = serverBootstrap.bind(port);

我们往往会用到option/childOption、handler/childHandler等方法，但是带child的方法定义在子类，不带child的方法定义在父类，父类返回的确是子类类型的对象。

在父类当中，handler方法的实现如下，它返回的就是self，实际上就是基于递归定义泛型的方式去进行实现的在父类当中，返回子类类型的对象。

    public B handler(ChannelHandler handler) {
        this.handler = ObjectUtil.checkNotNull(handler, "handler");
        return self();
    }
    
    private B self() {
        return (B) this;
    }