前言

通常我们在res/drawable下面自定义shape和selector来满足一些UI的设计，但是由于xml最终转换为drawable需要经过IO或反射创建，会有一些性能损耗，另外随着项目的增大和模块化等，很多通用的样式并不能快速复用，需要合理的项目资源管理规范才能实施。那么通过代码直接创建这些drawable，可以在一定程度上降低这些副作用。本篇介绍用kotlin DSL简洁的语法特性来实现常见的drawable.

代码对应效果预览

集成和使用

1. 在项目级的build.gradle文件种添加仓库Jitpack：

allprojects {

    repositories {

        ...

        maven { url 'https://jitpack.io' }

    }

}

复制代码

2. 添加依赖

dependencies {		

	implementation 'com.github.forJrking:DrawableDsl:0.0.1’

}

复制代码

3. 抛弃xml创建方式示例（其他参见demo)

// infix用法用于去掉括号更加简洁，详细后面说明

image src = shapeDrawable {

  	//指定shape样式

    shape(ShapeBuilder.Shape.RECTANGLE)

  	//圆角，支持4个角单独设置

  	corner(20f)

  	//solid 颜色

    solid("#ABE2E3")

  	//stroke 颜色，边框dp，虚线设置

    stroke(android.R.color.white, 2f, 5f, 8f)

}

//按钮点击样式

btn.background = selectorDrawable {

  	//默认样式

    normal = shapeDrawable {

        corner(20f)

        gradient(90, R.color.F97794, R.color.C623AA2)

    }

  	//点击效果

    pressed = shapeDrawable {

        corner(20f)

        solid("#84232323")

    }

}

复制代码

实现思路

xml如何转换成drawable

xml变成drawable，通过android.graphics.drawable.DrawableInflater这个类来IO解析标签创建:

//标签创建

private Drawable inflateFromTag(@NonNull String name) {

    switch (name) {

        case "selector":

            return new StateListDrawable();

        case "level-list":

            return new LevelListDrawable();

        case "layer-list":

            return new LayerDrawable();

        ....

        case "color":

            return new ColorDrawable();

        case "shape":

            return new GradientDrawable();

        case "vector":

            return new VectorDrawable();

        ...

    }

}

//反射创建

private Drawable inflateFromClass(@NonNull String className) {

    try {

        Constructor<? extends Drawable> constructor;

        synchronized (CONSTRUCTOR_MAP) {

            constructor = CONSTRUCTOR_MAP.get(className);

            if (constructor == null) {

                final Class<? extends Drawable> clazz = mClassLoader.loadClass(className).asSubclass(Drawable.class);

                constructor = clazz.getConstructor();

                CONSTRUCTOR_MAP.put(className, constructor);

            }

        }

        return constructor.newInstance();

    } catch (NoSuchMethodException e) {

    ...

}

复制代码

代码实现

由于创建shape等需要设置各种属性来构建，比较符合build设计模式，那我们首先封装build模式的shapeBuilder，这样做虽然代码比起直接使用apply{}多但是可以让纯java项目用起来很舒服，其他实现请查看源码：

class ShapeBuilder : DrawableBuilder {

    private var mRadius = 0f

    private var mWidth = 0f

    private var mHeight = 0f

    ...

    private var mShape = GradientDrawable.RECTANGLE

    private var mSolidColor = 0



    /**分别设置四个角的圆角*/

    fun corner(leftTop: Float,rightTop: Float,leftBottom: Float,rightBottom: Float): ShapeBuilder {

        ....

        return this

    }



    fun solid(@ColorRes colorId: Int): ShapeBuilder {

        mSolidColor = ContextCompat.getColor(context, colorId)

        return this

    }

    // 省略其他参数设置方法 详细代码查看源码

    override fun build(): Drawable {

        val gradientDrawable = GradientDrawable()

        gradientDrawable = GradientDrawable()

        gradientDrawable.setColor(mSolidColor)

        gradientDrawable.shape = mShape

        ....其他参数设置

        return gradientDrawable

    }    

}

复制代码

把build模式转换为dsl

理论上所有的build模式都可以轻松转换为dsl写法:

inline fun shapeDrawable(builder: ShapeBuilder.() -> Unit): Drawable {

    return ShapeBuilder().also(builder).build()

}

//使用方法 

val drawable = shapeDrawable{

    ...

}

复制代码

备注：dsl用法参见juejin.cn/post/695318… 中dsl小节

infix函数来去括号

通过上面封装已经实现了dsl的写法，通常setBackground可以通过setter简化，但是我发现由于有些api设计还需要加括号，这样不太kotlin：

//容易阅读

iv1.background = shapeDrawable {

    shape(ShapeBuilder.Shape.RECTANGLE)

    solid("#ABE2E3")

}

//多了括号看起来不舒服

iv2.setImageDrawable(shapeDrawable {

    solid("#84232323")

})

复制代码

怎么去掉括号呢？这里就要用到infix函数特点和规范：

• Kotlin允许在不使用括号和点号的情况下调用函数


• 必须只有一个参数


• 必须是成员函数或扩展函数


• 不支持可变参数和带默认值参数

/**为所有ImageView添加扩展infix函数 来去掉括号*/

infix fun ImageView.src(drawable: Drawable?) {

    this.setImageDrawable(drawable)

}

//使用如下 舒服了

iv2 src shapeDrawable {

    shape(ShapeBuilder.Shape.OVAL)

    solid("#E3ABC2")

}

复制代码

当然了代码是用来阅读的。个人认为如果我们大量使用infix函数，阅读困难会大大增加，所以建议函数命名必须可以直击函数功能，而且函数功能简单且单一。

优缺点

优点：

• 代码直接创建比起xml方式可以提升性能


• dsl方式比起build模式和调用方法设置更加简洁符合kotlin风格


• 通过合适的代码管理可以复用这些代码，比xml管理方便

缺点：

• 没有as的预览功能，只有通过上机观测


• api还没有覆盖所有drawable属性

后语

上面把的DrawableDsl基础用法介绍完了，欢迎大家使用，欢迎提Issues，记得给个star哦。Github链接：https://github.com/forJrking/DrawableDsl

一.面试题

            相信大家在面试的时候经常会被问到Category的实现原理，以及Category为什么只能加方法不能加属性？个人理解这个问题本身问的就有问题，首先我们看分类的底层代码：

                        struct category_t {

                                    const char *name;

                                    classref_t cls;

                                    struct method_list_t *instanceMethods; // 对象方法

                                    struct method_list_t *classMethods; // 类方法

                                    struct protocol_list_t *protocols; // 协议

                                    struct property_list_t *instanceProperties; // 属性

                                    // Fields below this point are not always present on disk.

                                    struct property_list_t *_classProperties;

                                    method_list_t*methodsForMeta(boolisMeta) {

                                if(isMeta)returnclassMethods;

                                            elsereturninstanceMethods;

                            }

                        property_list_t*propertiesForMeta(boolisMeta,structheader_info *hi);

                    };

        通过上面的分类底层代码我们可以找到category_t 结构体，它里面包含了对象方法，类方法，协议，属性，既然分类的底层代码里面已经包含了属性，为什么我们面试的时候会被问到分类为什么不能添加属性？下面我们来揭开它的神秘面纱

        1.首先我们创建一个person类，再给penson类创建一个分类Person+TCText，在分类的.h文件

一.函数修饰符

Metal 有以下3种函数修饰符:

        1）kernel , 表示该函数是⼀个数据并⾏计算着⾊函数. 它可以被分配在⼀维/⼆维/三维线程组中去执⾏

        2）vertex , 表示该函数是⼀个顶点着⾊函数 , 它将为顶点数据流中的每个顶点数据执⾏⼀次然后为每个顶 点⽣成数据输出到绘制管线

        3）fragment , 表示该函数是⼀个⽚元着⾊函数, 它将为⽚元数据流中的每个⽚元 和其关联执⾏⼀次然后 将每个⽚元⽣成的颜⾊数据输出到绘制管线中; 

eg：

//1.并行计算函数(kernel)

kernelvoidCCTestKernelFunctionA(inta,intb)

{

    /*

     注意:

     1. 使用kernel 修饰的函数返回值必须是void 类型

     2. 一个被函数修饰符修饰过的函数,不允许在调用其他的被函数修饰过的函数. 非法

     3. 被函数修饰符修饰过的函数,只允许在客户端对齐进行操作. 不允许被普通的函数调用.

     */

    //不可以的!

    //一个被函数修饰符修饰过的函数,不允许在调用其他的被函数修饰过的函数. 非法

    CCTestKernelFunctionB(1,2);//非法

    CCTestVertexFunctionB(1,2);//非法

    //可以! 你可以调用普通函数.而且在Metal 不仅仅只有这3种被修饰过的函数.普通函数也可以存在

    CCTest();

}

kernelvoidCCTestKernelFunctionB(inta,intb)

{

}

//顶点函数

vertexintCCTestVertexFunctionB(inta,intb){

}

//片元函数

fragmentintCCTestVertexFunctionB(inta,intb){

}

//普通函数

voidCCTest()

{

}

        说明：使⽤kernel 修饰的函数. 其返回值类型必须是void 类型; 只有图形着⾊函数才可以被 vertex 和 fragment 修饰. 对于图形着⾊函数, 返回值类型可以辨认出它是为 顶点做计算还是为每像素做计算. 图形着⾊函数的返回值可以为 void , 但是这也就意味着该函数不产⽣数 据输出到绘制管线; 这是⼀个⽆意义的动作; ⼀个被函数修饰符修饰的函数不能在调⽤其他也被函数修饰符修饰的函数; 这样会导致编译失败;

二.⽤于变量或者参数的地址空间修饰符

        Metal 着⾊器语⾔使⽤ 地址空间修饰符 来表示⼀个函数变量或者参数变量 被分配于那⼀⽚内存区域. 所有的着⾊函数(vertex, fragment, kernel)的参数,如果是指针或是引⽤, 都必须带有地址空间修饰符号; 

        1） device： 设备地址空间

        Device Address Space(设备地址空间) ，在设备地址空间(Device) 指向设备内存池分配出来的缓存对象, 它是可读也是可写的; ⼀个缓存对象可 以被声明成⼀个标量,向量或是⽤户⾃定义结构体的指针或是引⽤. 

eg：

        // 设备地址空间: device 用来修饰指针.引用

        //1.修饰指针变量

        device float4 *color;

        structCCStruct{

            floata[3];

            intb[2];

        };

        //2.修饰结构体类的指针变量

        device  CCStruct*my_CS;

        注意: 纹理对象总是在设备地址空间分配内存, device 地址空间修饰符不必出现在纹理类型定义中. ⼀个纹 理对象的内容⽆法直接访问. Metal 提供读写纹理的内建函数; 

        2）threadgroup： 线程组地址空间

        线程组地址空间⽤于为 并⾏计算着⾊函数分配内存变量. 这些变量被⼀个线程组的所有线程共享. 在线 程组地址空间分配的变量不能被⽤于图形绘制着⾊函数[顶点着⾊函数, ⽚元着⾊函数] 在并⾏计算着⾊函数中, 在线程组地址空间分配的变量为⼀个线程组使⽤, 声明周期和线程组相同; 

eg：

        /*

         1. threadgroup 被并行计算计算分配内存变量, 这些变量被一个线程组的所有线程共享. 在线程组分配变量不能被用于图像绘制.

         2. thread 指向每个线程准备的地址空间. 在其他线程是不可见切不可用的

         */

        kernel void CCTestFouncitionF(threadgroup float *a)

        {

            //在线程组地址空间分配一个浮点类型变量x

            threadgroup float x;

            //在线程组地址空间分配一个10个浮点类型数的数组y;

            threadgroup float y[10];

        }

        constant float sampler[] = {1.0f,2.0f,3.0f,4.0f};

        kernel  void  CCTestFouncitionG(void)

        {

            //在线程空间分配空间给x,p

            float  x;

            thread  float  p = &x;

}

       3） constant 常量地址空间

        常量地址空间指向的缓存对象也是从设备内存池分配存储, 但是它是只读的; 在程序域的变量必须定义在常量地址空间并且声明的时候初始化; ⽤来初始化的值必须是编译时的常 量. 在程序域的变量的⽣命周期和程序⼀样, 在程序中的并⾏计算着⾊函数或者图形绘制着⾊函数调⽤, 但 是constant 的值会保持不变; 

        注意: 常量地址空间的指针或是引⽤可以作为函数的参数. 向声明为常量的变量赋值会产⽣编译错误. 声明常量但是没有赋予初值也会产⽣编译错误; 

eg：

        1 constant float samples[] = { 1.0f, 2.0f, 3.0f, 4.0f }; 

        2 //对⼀个常量地址空间的变量进⾏修改也会失败,因为它只读的 

        3 sampler[4] = {3,3,3,3}; //编译失败; 

        4 //定义为常量地址空间声明时不赋初值也会编译失败 

        5 constant float a; 

        4）thread 线程地址空间

        thread 地址空间指向每个线程准备的地址空间, 这个线程的地址空间定义的变量在其他线程不可⻅, 在 图形绘制着⾊函数或者并⾏计算着⾊函数中声明的变量thread 地址空间分配; 在图形绘制着色函数 或者 并行计算着色函数中声明的变量，在线程地址空间分配存储

eg：

        kernel void CCTestFouncitionG(void){

        //在线程空间分配空间给x,p

        float x; 

        thread   float   p=&x;

        }

        对于图形着⾊器函数, 其指针或是引⽤类型的参数必须定义为 device 或是 constant 地址空间; 对于并⾏计算着⾊函数, 其指针或是引⽤类型的参数必须定义为 device 或是 threadgrounp 或是 constant 地址空间; 并不是所有的变量都需要修饰符，也可以定义普通变量（即无修饰符的变量）

三.函数参数与变量

        图形绘制或者并⾏计算着⾊器函数的输⼊输出都是通过参数传递. 除了常量地址空间变量和程序域定义 的采样器以外.

        device buffer- 设备缓存, ⼀个指向设备地址空间的任意数据类型的指针或者引⽤; 

        constant buffer -常量缓存区, ⼀个指向常量地址空间的任意数据类型的指针或引⽤ 

        texture - 纹理对象; 

        sampler - 采样器对象; 

        threadGrounp - 在线程组中供各线程共享的缓存.

        注意: 被着⾊器函数的缓存(device 和 constant) 不能重名; 

        Attribute Qualifiers to Locate Buffers, Textures, and Samplers ⽤于寻址缓存,纹理, 采样器的属性修饰符;对于每个着⾊器函数来说, ⼀个修饰符是必须指定的. 他⽤来设定⼀个缓存,纹理, 采样器的位置; 

        device buffers/ constant buffer --> [[buffer (index)]] 

        texture -- [[texture (index)]] 

        sampler -- [[sampler (index)]] 

        threadgroup buffer -- [[threadgroup (index)]] 

        index是⼀个unsigned integer类型的值，它表示了⼀个缓存、纹理、采样器参数的位置(在函数参数索引 表中的位置)。 从语法上讲，属性修饰符的声明位置应该位于参数变量名之后 

        例⼦中展示了⼀个简单的并⾏计算着⾊函数 add_vectors，它把两个设备地址空间中的缓存inA和inB相 加，然后把结果写⼊到缓存out。属性修饰符 “(buffer(index))”为着⾊函数参数设定了缓存的位置。

//属性修饰符

/*

 1. device buffer(设备缓存)

 2. constant buffer(常量缓存)

 3. texture Object(纹理对象)

 4. sampler Object(采样器对象)

 5. 线程组 threadgroup

 属性修饰符目的:

 1. 参数表示资源如何定位? 可以理解为端口

 2. 在固定管线和可编程管线进行内建变量的传递

 3. 将数据沿着渲染管线从顶点函数传递片元函数.

 在代码中如何表现:

 1.已知条件:device buffer(设备缓存)/constant buffer(常量缓存)

 代码表现:[[buffer(index)]]

 解读:不变的buffer ,index 可以由开发者来指定.

 2.已知条件:texture Object(纹理对象)

 代码表现: [[texture(index)]]

 解读:不变的texture ,index 可以由开发者来指定.

 3.已知条件:sampler Object(采样器对象)

 代码表示: [[sampler(index)]]

 解读:不变的sampler ,index 可以由开发者来指定.

 4.已知条件:threadgroup Object(线程组对象)

 代码表示: [[threadgroup(index)]]

 解读:不变的threadgroup ,index 可以由开发者来指定.

 */

//并行计算着色器函数add_vectros ,实现2个设备地址空间中的缓存A与缓存B相加.然后将结果写入到缓存out.

//属性修饰符"(buffer(index))" 为着色函数参数设定了缓存的位置

//并行计算着色器函数add_vectros ,实现2个设备地址空间中的缓存A与缓存B相加.然后将结果写入到缓存out.

//属性修饰符"(buffer(index))" 为着色函数参数设定了缓存的位置

kernelvoidadd_vectros(

                const device float4*inA [[buffer(0)]],

                const device float4*inB [[buffer(1)]],

                device float4*out [[buffer(2)]]

                uintid[[thread_position_in_grid]])

{

    out[id] = inA[id] + inB[id];

}

        注意：thread_position_in_grid : ⽤于表示当前节点在多线程⽹格中的位置; 

四.内建变量属性修饰符 

        [[vertex_id]] 顶点id 标识符; 

        [[position]] 顶点信息(float4) /� 述了⽚元的窗⼝相对坐标(x, y, z, 1/w) 

        [[point_size]] 点的⼤⼩(float) 

        [[color(m)]] 颜⾊, m编译前得确定; 

        struct MyFragmentOutput { 

         // color attachment 0 

         float4 clr_f [[color(0)]]; // color attachment 1 

         int4 clr_i [[color(1)]]; // color attachment 2 

         uint4 clr_ui [[color(2)]]; }; 

         fragment MyFragmentOutput my_frag_shader( ... ) 

         { 

         MyFragmentOutput f; 

         .... 

         f.clr_f = ...; 

         ... 

         return f;

        }

        [[stage_in]] : ⽚元着⾊函数使⽤的单个⽚元输⼊数据是由顶点着⾊函数输出然后经过光栅化⽣成的.顶 点和⽚元着⾊函数都是只能有⼀个参数被声明为使⽤“stage_in”修饰符，对于⼀个使⽤ 了“stage_in”修饰符的⾃ 定义的结构体，其成员可以为⼀个整形或浮点标量，或是整形或浮点向量

数字媒体压缩

        为缩小数字媒体文件的大小，我们需要对其使用压缩技术，一般来说我们所欣赏的媒体内容都进行过一定程度的压缩，无论在电视上的视频，蓝光碟片，网页上的视频流还是冲iTunes Store购买的资源，我们其实都是和这些内容的原始文件的压缩格式在打交到，对数字媒体进行压缩可以大幅度缩小文件的尺寸，但是通常会在资源的质量上有小幅可见的衰减，

色彩的二次采样

        视频数据是使用称之为YCbCr颜色模式，它也常称为YUV，虽然YUV术语并不准确，但是读起来比较方便，大部分的软件开发者都更熟悉RGB颜色模式，即每个像素点都由红，绿，蓝三个颜色组合而成，YCbCr或者是YUV则使用色彩（颜色）通道UV替换了像素的亮度通道.

从上图中我们可以看到图片的细节都保存在亮度的通道中，假设世界上没有阳光，我们的眼睛是看不到任何的东西，如果去除亮度，剩下的就是一副灰度图片，我们在看整合的色彩通道中关于图片的所有细节都丢失了，这是由于我们眼睛对亮度的敏感度要高于颜色，所以，在YUV中，我们可以通过大幅减少存储在每个像素点中的颜色信息，而不致于图片的质量严重受损，这个减少颜色数据的过程就称之为色彩的二次采样。

我们平时所说的4:4:4和4:2:2以及4:2:0到底指的是什么，以及它的由来？

        色彩的二次采样一般发生在取样时，一些专业的相机以4:4:4的参数捕捉图像，但大部分情况下对于图片的拍摄使用4:2:2的方式进行的，面向消费者的摄像头装置，比如iPhone手机上的摄像头，通常是以4:2:0的方式进行拍摄，即使经过大量层级的二次抽样之后仍然可以捕捉到高质量的图片，iPhone手机上拍出来的高质量视频就是很好的例证，

1.RGB的颜色编码

        RGB 三个字⺟分别代表了 红（Red）、绿（Green）、蓝（Blue），这三种颜⾊称为 三原⾊，将它们以不同的⽐例相加，可以产⽣多种多样的颜⾊。

 在图像显示中，⼀张1280 * 720 ⼤⼩的图⽚，就代表着它有1280 * 720 个像素点。其中每⼀个像素点的颜⾊显示都采⽤RGB 编码⽅法，将RGB 分别取不同的值，就会展示不同的颜⾊。

        RGB 图像中，每个像素点都有红、绿、蓝三个原⾊，其中每种原⾊都占⽤8 bit，也就是⼀个字节，那么⼀个像素点也就占⽤24 bit，也就是三个字节。

        ⼀张1280 * 720 ⼤⼩的图⽚，就占⽤1280 * 720 * 3 / 1024 / 1024 = 2.63 MB 存储空间

2.YUV的颜色编码

        YUV 颜⾊编码采⽤的是 明亮度 和 ⾊度 来指定像素的颜⾊。其中，Y 表示明亮度（Luminance、Luma），⽽U 和V 表示⾊度（Chrominance、Chroma）。⽽⾊度⼜定义了颜⾊的两个⽅⾯：⾊调和饱和度

  和RGB 表示图像类似，每个像素点都包含Y、U、V 分量。但是它的Y 和UV 分量是可以分离的，如果没有UV 分量⼀样可以显示完整的图像，只不过是⿊⽩的。对于YUV 图像来说，并不是每个像素点都需要包含了Y、U、V 三个分量，根据不同的采样格式，可以每个Y 分量都对应⾃⼰的UV 分量，也可以⼏个Y 分量共⽤UV 分量

传说中的4:4:4

        在4:4:4的模式下，色彩的全部信息被保全下来，如图：

1. 背景介绍

最近参加了Compose挑战赛的终极挑战，使用Compose完成了一个天气app。之前几轮挑战我也都有参与，每次都学到不少新东西，希望在这最后一轮挑战中，活用这段时间的积累做出更加成熟的作品。

项目挑战

因为没有美工协助，所以我考虑通过代码实现app中的所有UI元素例如各种icon等，这样的UI在任何分辨率下都不会失真，而且可以更灵活地完成各种动画效果。

为了降低实现成本，我将app中的UI元素定义成偏卡通的风格，更利于代码实现：

上面的动画没有使用gif、lottie等三方资源，所有效果都基于Compose代码绘制。

MyApp：CuteWeather

App界面比较简洁，采用单页面呈现（这也是挑战赛要求），可以查看近一周的天气信息和温度走势等。

项目地址: github.com/vitaviva/co…

其中，卡通风格的天气动画算是这个app相对于同类应用的特色，本文将围绕这些天气动画介绍一下如何使用Compose绘制自定义图形、并基于这些图形实现动画。

2. Compose自定义绘制

像常规的Android开发一样，除了各种默认的Composable控件以外，Compose也提供了Canvas用来绘制自定义图形。

Canvas相关的API在各个平台都大同小异，但在Compose上具有以下特点：

• 用声明式的方式创建和使用Canvas


• 通过DrawScope提供必要的state及各种APIs


• API更简单易用

声明式地创建和使用Canvas

Compose中，Canvas作为Composable可以声明式地添加到其他Composable中，并通过Modifier进行配置

Canvas(modifier = Modifier.fillMaxSize()){ // this: DrawScope 

	//内部进行自定义绘制

}

复制代码

传统方式需要获取Canvas句柄命令式地进行绘制，而Canvas{...}通过状态驱动的方式执行block内的绘制逻辑，从而刷新UI。

强大的DrawScope

Canvas{...}通过DrawScope提供了一些当前绘制所需的state，例如经常使用到的size；DrawScope还提了各种常用的绘制API，例如drawLine等

Canvas(modifier = Modifier.fillMaxSize()){

	//通过size获取当前canvas的width和height

    val canvasWidth = size.width

    val canvasHeight = size.height



	//绘制直线

    drawLine(

        start = Offset(x=canvasWidth, y = 0f),

        end = Offset(x = 0f, y = canvasHeight),

        color = Color.Blue,

        strokeWidth = 5F //设置直线宽度

    )

}

复制代码

上面代码绘制效果如下：

简单易用的API

传统的Canvas API需要进行Paint的配置，而DrawScope的API则更简单、使用更友好。

例如绘制一个圆，传统的API是这样：

public void drawCircle(float cx, float cy, float radius, @NonNull Paint paint) {

	//...	

}

复制代码

DrawScope提供的API：

fun drawCircle(

    color: Color,

    radius: Float = size.minDimension / 2.0f,

    center: Offset = this.center,

    alpha: Float = 1.0f,

    style: DrawStyle = Fill,

    colorFilter: ColorFilter? = null,

    blendMode: BlendMode = DefaultBlendMode

) {...}

复制代码

虽然看起来参数变多了，但是其实已经通过size等设置了合适的默认值，同时省去了Paint的创建和配置，使用起来更方便。

使用原生Canvas

目前DrawScope提供的API还不及原生Canvas丰富（比如不支持drawText等），当不满足使用需求时，也可以直接使用原生Canvas对象进行绘制

   drawIntoCanvas { canvas ->

            //nativeCanvas是原生canvas对象，android平台即android.graphics.Canvas

            val nativeCanvas  = canvas.nativeCanvas

            

        }

复制代码

上面对Compose中的Canvas做了简单介绍，下面结合app中的具体示例看一下实际使用效果

首先，看一下雨水的绘制过程。

3. 雨天效果

雨天天气的关键是如何绘制不断下落的雨水

雨滴的绘制

我们先绘制构成雨水的基本单元：雨滴

经拆解后，雨水效果可由三组雨滴构成，每一组雨滴分成上下两段，这样在运动时可以形成接连不断的效果。

我们使用drawLine绘制每一段黑线，设置适当的stokeWidth，并通过cap设置端点的圆形效果：

@Composable

fun rainDrop() {



	Canvas(modifier) {



       val x: Float = size.width / 2 //x坐标： 1/2的位置

        

        drawLine(

            Color.Black,

            Offset(x, line1y1), //line1 的起点

            Offset(x, line1y2), //line1 的终点

            strokeWidth = width, //设置宽度

            cap = StrokeCap.Round//头部圆形

        )



		// line2同上

        drawLine(

            Color.Black,

            Offset(x, line2y1),

            Offset(x, line2y2),

            strokeWidth = width,

            cap = StrokeCap.Round

        )

    }

}

复制代码

雨滴下落动画

完成雨滴的基本图形绘制后，接下来为两线段增加位移动画，形成流动的效果。

以两线段中间空隙为动画的锚点，根据animationState变动其y轴位置，从canvas的顶端移动到低端（0 ~ size.hight），然后restart这个动画。

然后以锚点为基准绘制上下两线段，就行成接连不断的动画效果了

代码如下：

@Composable

fun rainDrop() {

	//循环播放的动画 （ 0f ~ 1f)

    val animateTween by rememberInfiniteTransition().animateFloat(

        initialValue = 0f,

        targetValue = 1f,

        animationSpec = infiniteRepeatable(

            tween(durationMillis, easing = LinearEasing),

            RepeatMode.Restart //start动画

        )

    )



    Canvas(modifier) {



        // scope ： 绘制区域

        val width = size.width

        val x: Float = size.width / 2



 		// width/2是strokCap的宽度，scopeHeight处预留strokCap宽度，让雨滴移出时保持正圆，提高视觉效果

        val scopeHeight = size.height - width / 2 



        // space ： 两线段的间隙

        val space = size.height / 2.2f + width / 2 //间隙size

        val spacePos = scopeHeight * animateTween //锚点位置随animationState变化

        val sy1 = spacePos - space / 2

        val sy2 = spacePos + space / 2



        // line length

        val lineHeight = scopeHeight - space



        // line1

        val line1y1 = max(0f, sy1 - lineHeight)

        val line1y2 = max(line1y1, sy1)



        // line2

        val line2y1 = min(sy2, scopeHeight)

        val line2y2 = min(line2y1 + lineHeight, scopeHeight)



        // draw

        drawLine(

            Color.Black,

            Offset(x, line1y1),

            Offset(x, line1y2),

            strokeWidth = width,

            colorFilter = ColorFilter.tint(

                Color.Black

            ),

            cap = StrokeCap.Round

        )



        drawLine(

            Color.Black,

            Offset(x, line2y1),

            Offset(x, line2y2),

            strokeWidth = width,

            colorFilter = ColorFilter.tint(

                Color.Black

            ),

            cap = StrokeCap.Round

        )

    }

}



复制代码

Compose自定义布局

完成了单个雨滴的动画，接下来我们使用三个雨滴组成雨水的效果。

首先可以使用Row+Space的方式进行组装，但是这种方式缺少灵活性，仅通过Modifier很难准确布局三雨滴的相对位，因此考虑借助Compose的自定义布局，以提高灵活性和准确性：

Layout(

    modifier = modifier.rotate(30f), //雨滴旋转角度

    content = { // 定义子Composable

		Raindrop(modifier.fillMaxSize())

		Raindrop(modifier.fillMaxSize())

		Raindrop(modifier.fillMaxSize())

    }

) { measurables, constraints ->

    // List of measured children

    val placeables = measurables.mapIndexed { index, measurable ->

        // Measure each children

        val height = when (index) { //让三个雨滴的height不同，增加错落感

            0 -> constraints.maxHeight * 0.8f

            1 -> constraints.maxHeight * 0.9f

            2 -> constraints.maxHeight * 0.6f

            else -> 0f

        }

        measurable.measure(

            constraints.copy(

                minWidth = 0,

                minHeight = 0,

                maxWidth = constraints.maxWidth / 10, // raindrop width

                maxHeight = height.toInt(),

            )

        )

    }



    // Set the size of the layout as big as it can

    layout(constraints.maxWidth, constraints.maxHeight) {

        var xPosition = constraints.maxWidth / ((placeables.size + 1) * 2)



        // Place children in the parent layout

        placeables.forEachIndexed { index, placeable ->

            // Position item on the screen

            placeable.place(x = xPosition, y = 0)



            // Record the y co-ord placed up to

            xPosition += (constraints.maxWidth / ((placeables.size + 1) * 0.8f)).roundToInt()

        }

    }

}

复制代码

Compose中可以使用Layout{...}对Composable进行自定义布局，content{...}中定义参与布局的子Composable。

跟传统Android视图一样，自定义布局需要先后经历measure、layout两步。

• measrue： measurables返回所有待测量的子Composable，constraints类似于MeasureSpec，封装父容器对子元素的布局约束。measurable.measure()中对子元素进行测量


• layout：placeables返回测量后的子元素，依次调用placeable.place()对雨滴进行布局，通过xPosition预留雨滴在x轴的间隔

经过layout之后，通过 modifier.rotate(30f) 对Composable进行旋转，完成最终效果：

4. 雪天效果

雪天效果的关键在于雪花的飘落。

雪花的绘制

雪花的绘制非常简单，用一个圆圈代表一个雪花

Canvas(modifier) {



	val radius = size / 2

	

	drawCircle( //白色填充

		color = Color.White,

		radius = radius,

		style = FILL

	)



	 drawCircle(// 黑色边框

	 	color = Color.Black,

	    radius = radius,

		style = Stroke(width = radius * 0.5f)

	)

}

复制代码

雪花飘落动画

雪花飘落的过程相对于雨滴坠落要复杂一些，由三个动画组成:

1. 下落：改变y轴坐标：0f ~ 2.5f


2. 左右飘移：改变x轴的offset：-1f ~ 1f


3. 逐渐消失：改变alpha：1f ~ 0f

借助InfiniteTransition同步控制多个动画，代码如下：

@Composable

private fun Snowdrop(

	modifier: Modifier = Modifier,

	durationMillis: Int = 1000 // 雪花飘落动画的druation

) {



	//循环播放的Transition

    val transition = rememberInfiniteTransition()



	//1. 下降动画：restart动画

    val animateY by transition.animateFloat(

        initialValue = 0f,

        targetValue = 2.5f,

        animationSpec = infiniteRepeatable(

            tween(durationMillis, easing = LinearEasing),

            RepeatMode.Restart

        )

    )



	//2. 左右飘移：reverse动画

    val animateX by transition.animateFloat(

        initialValue = -1f,

        targetValue = 1f,

        animationSpec = infiniteRepeatable(

            tween(durationMillis / 3, easing = LinearEasing),

            RepeatMode.Reverse

        )

    )



	//3. alpha值：restart动画，以0f结束

    val animateAlpha by transition.animateFloat(

        initialValue = 1f,

        targetValue = 0f,

        animationSpec = infiniteRepeatable(

            tween(durationMillis, easing = FastOutSlowInEasing),

        )

    )



    Canvas(modifier) {



        val radius = size.width / 2



		// 圆心位置随AnimationState改变，实现雪花飘落的效果

        val _center = center.copy(

            x = center.x + center.x * animateX,

            y = center.y + center.y * animateY

        )



        drawCircle(

            color = Color.White.copy(alpha = animateAlpha),//alpha值的变化实现雪花消失效果

            center = _center,

            radius = radius,

        )



        drawCircle(

            color = Color.Black.copy(alpha = animateAlpha),

            center = _center,

            radius = radius,

            style = Stroke(width = radius * 0.5f)

        )

    }

}

复制代码

animateY的targetValue设为2.5f是为了让雪花的运动轨迹更长，看起来更加真实

雪花的自定义布局

像雨滴一样，对雪花也使用Layout自定义布局

@Composable

fun Snow(

    modifier: Modifier = Modifier,

    animate: Boolean = false,

) {



    Layout(

        modifier = modifier,

        content = {

        	//摆放三个雪花，分别设置不同duration，增加随机性

            Snowdrop( modifier.fillMaxSize(), 2200)

            Snowdrop( modifier.fillMaxSize(), 1600)

            Snowdrop( modifier.fillMaxSize(), 1800)

        }

    ) { measurables, constraints ->

        val placeables = measurables.mapIndexed { index, measurable ->

            val height = when (index) {

            	// 雪花的height不同，也是为了增加随机性

                0 -> constraints.maxHeight * 0.6f

                1 -> constraints.maxHeight * 1.0f

                2 -> constraints.maxHeight * 0.7f

                else -> 0f

            }

            measurable.measure(

                constraints.copy(

                    minWidth = 0,

                    minHeight = 0,

                    maxWidth = constraints.maxWidth / 5, // snowdrop width

                    maxHeight = height.roundToInt(),

                )

            )

        }



        layout(constraints.maxWidth, constraints.maxHeight) {

            var xPosition = constraints.maxWidth / ((placeables.size + 1))



            placeables.forEachIndexed { index, placeable ->

                placeable.place(x = xPosition, y = -(constraints.maxHeight * 0.2).roundToInt())



                xPosition += (constraints.maxWidth / ((placeables.size + 1) * 0.9f)).roundToInt()

            }

        }

    }

}

复制代码

最终效果如下：

5. 晴天效果

通过一个旋转的太阳代表晴天效果

太阳的绘制

太阳的图形由中心圆形和围绕圆环的等分线段组成。

@Composable

fun Sun(modifier: Modifier = Modifier) {



    Canvas(modifier) {



        val radius = size.width / 6

        val stroke = size.width / 20



        // draw circle

        drawCircle(

            color = Color.Black,

            radius = radius + stroke / 2,

            style = Stroke(width = stroke),

        )

        drawCircle(

            color = Color.White,

            radius = radius,

            style = Fill,

        )



        // draw line



        val lineLength = radius * 0.2f

        val lineOffset = radius * 1.8f

        (0..7).forEach { i ->



            val radians = Math.toRadians(i * 45.0)



            val offsetX = lineOffset * cos(radians).toFloat()

            val offsetY = lineOffset * sin(radians).toFloat()



            val x1 = size.width / 2 + offsetX

            val x2 = x1 + lineLength * cos(radians).toFloat()



            val y1 = size.height / 2 + offsetY

            val y2 = y1 + lineLength * sin(radians).toFloat()



            drawLine(

                color = Color.Black,

                start = Offset(x1, y1),

                end = Offset(x2, y2),

                strokeWidth = stroke,

                cap = StrokeCap.Round

            )

        }

    }

}

复制代码

均分360度，每间隔45度画一条线段，cos计算x轴坐标，sin计算y轴坐标。

太阳的旋转

太阳的旋转动画很简单，通过Modifier.rotate不断转动Canvas即可。

@Composable

fun Sun(modifier: Modifier = Modifier) {



	//循环动画

    val animateTween by rememberInfiniteTransition().animateFloat(

        initialValue = 0f,

        targetValue = 360f,

        animationSpec = infiniteRepeatable(tween(5000), RepeatMode.Restart)

    )



    Canvas(modifier.rotate(animateTween)) {// 旋转动画



        val radius = size.width / 6

        val stroke = size.width / 20

        val centerOffset = Offset(size.width / 30, size.width / 30) //圆心偏移量



        // draw circle

        drawCircle(

            color = Color.Black,

            radius = radius + stroke / 2,

            style = Stroke(width = stroke),

            center = center + centerOffset //圆心偏移

        )

       	

       	//...略

    }

}

复制代码

此外，DrawScope提供了rotate的API，也可以实现旋转效果。

最后我们给太阳的圆心增加一个偏移量，让转动更加活泼：

6. 动画的组合、切换

在实现了Rain、Snow、Sun等图形后，就可以使用这些图形组合成各种天气效果了。

将图形组合成天气

Compose的声明式语法非常有利于UI的组合：

比如，多云转阵雨，我们摆放Sun、Cloud、Rain等元素后，通过Modifier调整各自位置即可：

@Composable

fun CloudyRain(modifier: Modifier) {

	Box(modifier.size(200.dp)){

		Sun(Modifier.size(120.dp).offset(140.dp, 40.dp))

		Rain(Modifier.size(80.dp).offset(80.dp, 60.dp))

		Cloud(Modifier.align(Aligment.Center))

	}

}

复制代码

让动画切换更加自然

当在多个天气动画之间进行切换时，我们希望能实现更自然的过渡。实现思路是将组成天气动画的各元素的Modifier配置变量化，然后通过Animation不断改变

假设所有的天气都由Cloud、Sun、Rain组成，无非就是offset、size、alpha值的不同：

ComposeInfo

data class IconInfo(

    val size: Float = 1f, 

    val offset: Offset = Offset(0f, 0f),

    val alpha: Float = 1f,

) 

复制代码

//天气组合信息，即Sun、Cloud、Rain的位置信息

data class ComposeInfo(

    val sun: IconInfo,

    val cloud: IconInfo,

    val rains: IconInfo,



) {

    operator fun times(float: Float): ComposeInfo =

        copy(

            sun = sun * float,

            cloud = cloud * float,

            rains = rains * float

        )



    operator fun minus(composeInfo: ComposeInfo): ComposeInfo =

        copy(

            sun = sun - composeInfo.sun,

            cloud = cloud - composeInfo.cloud,

            rains = rains - composeInfo.rains,

        )



    operator fun plus(composeInfo: ComposeInfo): ComposeInfo =

        copy(

            sun = sun + composeInfo.sun,

            cloud = cloud + composeInfo.cloud,

            rains = rains + composeInfo.rains,

        )

}



复制代码

如上，ComposeInfo中持有各种元素的位置信息，运算符重载用于跟随Animation计算当前最新值。

定义不同天气的ComposeInfo如下：

//晴天

val SunnyComposeInfo = ComposeInfo(

    sun = IconInfo(1f),

    cloud = IconInfo(0.8f, Offset(-0.1f, 0.1f), 0f),

    rains = IconInfo(0.4f, Offset(0.225f, 0.3f), 0f),

)



//多云

val CloudyComposeInfo = ComposeInfo(

    sun = IconInfo(0.1f, Offset(0.75f, 0.2f), alpha = 0f),

    cloud = IconInfo(0.8f, Offset(0.1f, 0.1f)),

    rains = IconInfo(0.4f, Offset(0.225f, 0.3f), alpha = 0f),

)



//雨天

val RainComposeInfo = ComposeInfo(

    sun = IconInfo(0.1f, Offset(0.75f, 0.2f), alpha = 0f),

    cloud = IconInfo(0.8f, Offset(0.1f, 0.1f)),

    rains = IconInfo(0.4f, Offset(0.225f, 0.3f), alpha = 1f),

)



复制代码

ComposedIcon

接着，定义ComposedIcon，消费ComposeInfo绘制天气组合的UI

@Composable

fun ComposedIcon(modifier: Modifier = Modifier, composeInfo: ComposeInfo) {



	//各元素的ComposeInfo

    val (sun, cloud, rains) = composeInfo

    

    Box(modifier) {



		//应用ComposeInfo到Modifier

        val _modifier = remember(Unit) {

            { icon: IconInfo ->

                Modifier

                    .offset( icon.size * icon.offset.x, icon.size * icon.offset.y )

                    .size(icon.size)

                    .alpha(icon.alpha)

            }

        }



        Sun(_modifier(sun))

        Rains(_modifier(rains))

        AnimatableCloud(_modifier(cloud))

    }

}

复制代码

ComposedWeather

最后，定义ComposedWeather，通过动画更新当前的ComposedIcon：

@Composable

fun ComposedWeather(modifier: Modifier, composedIcon: ComposedIcon) {



    val (cur, setCur) = remember { mutableStateOf(composedIcon) }

    var trigger by remember { mutableStateOf(0f) }



    DisposableEffect(composedIcon) {

        trigger = 1f

        onDispose { }

    }



	//创建动画（0f ~ 1f)，用于更新ComposeInfo

    val animateFloat by animateFloatAsState(

        targetValue = trigger,

        animationSpec = tween(1000)

    ) {

    	//当动画结束时，更新ComposeWeather到最新state

        setCur(composedIcon)

        trigger = 0f

    }



	//根据AnimationState计算当前ComposeInfo

    val composeInfo = remember(animateFloat) {

        cur.composedIcon + (weatherIcon.composedIcon - cur.composedIcon) * animateFloat

    }



	//使用最新的ComposeInfo显示Icon

    ComposedIcon(

        modifier,

        composeInfo

    )

}

复制代码

到此，我们就实现了天气动画的自然过度了。

public interface TvState{

    public void nextChannerl();

    public void prevChannerl();

    public void turnUp();

    public void turnDown();

}



public class PowerOffState implements TvState{

    public void nextChannel(){}

    public void prevChannel(){}

    public void turnUp(){}

    public void turnDown(){}

    

}





public class PowerOnState implements TvState{

    public void nextChannel(){

        System.out.println("下一频道");

    }

    public void prevChannel(){

        System.out.println("上一频道");

    }

    public void turnUp(){

        System.out.println("调高音量");

    }

    public void turnDown(){

        System.out.println("调低音量"); 

    }

    

}



public interface PowerController{

    public void powerOn();

    public void powerOff();

}



public class TvController implements PowerController{

    TvState mTvState;

    public void setTvState(TvStete tvState){

        mTvState=tvState;

    }

    public void powerOn(){

        setTvState(new PowerOnState());

        System.out.println("开机啦");

    }

    public void powerOff(){

        setTvState(new PowerOffState());

        System.out.println("关机啦");

    }

    public void nextChannel(){

        mTvState.nextChannel();

    }

    public void prevChannel(){

        mTvState.prevChannel();

    }

    public void turnUp(){

        mTvState.turnUp();

    }

    public void turnDown(){

        mTvState.turnDown();

    }

    

}





public class Client{

    public static void main(String[] args){

        TvController tvController=new TvController();

        tvController.powerOn();

        tvController.nextChannel();

        tvController.turnUp();

        

        tvController.powerOff();

        //调高音量，此时不会生效

        tvController.turnUp();

    }





}

Kotlin 的 out 和 in

和 Java 泛型一样，Kolin 中的泛型本身也是不可变的。

不过换了一种表现形式：

• 使用关键字 out 来支持协变，等同于 Java 中的上界通配符 ? extends。


• 使用关键字 in 来支持逆变，等同于 Java 中的下界通配符 ? super。

val appleShop: Shop<out Fruit>

val fruitShop: Shop<in Apple>

复制代码

它们完全等价于：

Shop<? extends Fruit> appleShop;

Shop<? super Apple> fruitShop;

复制代码

换了个写法，但作用是完全一样的。out 表示，我这个变量或者参数只用来输出，不用来输入，你只能读我不能写我；in 就反过来，表示它只用来输入，不用来输出，你只能写我不能读我。

泛型的上下界约束

上面讲的都是在使用的时候再对泛型进行限制，我们称之为「上界通配符」和「下界通配符」。那我们可以在函数设计的时候，就设置这个限制么？

可以的可以的。

比如：

open class Animal

class PetShop<T : Animal?>(val t: T)

复制代码

等同于 Java 的：

class PetShop<T extends Animal> {

    private T t;



    PetShop(T t) {

        this.t = t;

    }

}

复制代码

这样，我们在设计宠物店类 PetShop 就给支持的泛型设置了上界约束，支持的泛型类型必须是 Animal 的子类。所以我们使用的话：

class Cat : Animal()



val catShop = PetShop(Cat())

val appleShop = PetShop(Apple())

                      // 👆 报错：Type mismatch. Required: Animal? Found: Apple

复制代码

很明显，Apple 并不是 Animal 的子类，当然不满足 PetShop 泛型类型的上界约束。

那....可以设置多个上界约束么？

当然可以，在 Java 中，给一个泛型参数声明多个约束的方式是，使用 &：

class PetShop<T extends Animal & Serializable> {

                      // 👆 通过 & 实现了两个上界，必须是 Animal 和 Serializable 的子类或实现类

    private T t;



    PetShop(T t) {

        this.t = t;

    }

}

复制代码

而在 Kotlin 中舍弃了 & 这种方式，而是增加了 where 关键字：

open class Animal

class PetShop<T>(val t: T) where  T : Animal?, T : Serializable

复制代码

通过上面的方式，就实现了多个上界的约束。

Kotlin 的通配符 *

前面我们说的泛型类型都是在我们需要知道参数类型是什么类型的，那如果我们对泛型参数的类型不感兴趣，有没有一种方式处理这个情况呢？

有的有的。

在 Kotlin 中，可以用通配符 * 来替代泛型参数。比如：

val list: MutableList<*> = mutableListOf(1, "nanchen2251")

list.add("nanchen2251")

      // 👆 报错：Type mismatch. Required: Nothing Found: String

复制代码

这个报错确实让人匪夷所思，上面用通配符代表了 MutableList 的泛型参数类型。初始化里面也加入了 String 类型，但在新 add 字符串的时候，却发生了编译错误。

而如果是这样的代码：

val list: MutableList<Any> = mutableListOf(1, "nanchen2251")

list.add("nanchen2251")

      //  👆 不再报错

复制代码

看来，所谓的通配符作为泛型参数并不等价于 Any 作为泛型参数。MutableList<*> 和 MutableList<Any> 并不是同一种列表，后者的类型是确定的，而前者的类型并不确定，编译器并不能知道这是一种什么类型。所以它不被允许添加元素，因为会导致类型不安全。

不过细心的同学肯定发现了，这个和前面泛型的协变非常类似。其实通配符 * 不过是一种语法糖，背后也是用协变来实现的。所以：MutableList<*> 等价于 MutableList<out Any?>，使用通配符与协变有着一样的特性。

在 Java 中，也有一样意义的通配符，不过使用的是 ? 作为通配。

List<?> list = new ArrayList<Apple>(); 

复制代码

Java 中的通配符 ? 也等价于 ? extends Object。

多个泛型参数声明

那可以声明多个泛型么？

可以的可以的。

HashMap 不就是一个典型的例子么？

class HashMap<K,V>

复制代码

多个泛型，可以通过 , 进行分割，多个声明，上面是两个，实际上多个都是可以的。

class HashMap<K: Animal, V, T, M, Z : Serializable>

复制代码

泛型方法

上面讲的都是都是在类上声明泛型类型，那可以声明在方法上么？

可以的可以的。

如果你是一名 Android 开发，View 的 findViewById 不就是最好的例子么？

public final <T extends View> T findViewById(@IdRes int id) {

    if (id == NO_ID) {

        return null;

    }

    return findViewTraversal(id);

}

复制代码

很明显，View 是没有泛型参数类型的，但其 findViewById 就是典型的泛型方法，泛型声明就在方法上。

上述写法改写成 Kotlin 也非常简单：

fun <T : View?> findViewById(@IdRes id: Int): T? {

    return if (id == View.NO_ID) {

        null

    } else findViewTraversal(id)

}

复制代码

Kotlin 的 reified

前面有说到，由于 Java 中的泛型存在类型擦除的情况，任何在运行时需要知道泛型确切类型信息的操作都没法用了。比如你不能检查一个对象是否为泛型类型 T 的实例：

<T> void printIfTypeMatch(Object item) {

    if (item instanceof T) { // 👈 IDE 会提示错误，illegal generic type for instanceof



    }

}

复制代码

Kotlin 里同样也不行：

fun <T> printIfTypeMatch(item: Any) {

    if (item is T) { // 👈 IDE 会提示错误，Cannot check for instance of erased type: T

        println(item)

    }

}

复制代码

这个问题，在 Java 中的解决方案通常是额外传递一个 Class<T> 类型的参数，然后通过 Class#isInstance 方法来检查：

                               👇

<T> void check(Object item, Class<T> type) {

    if (type.isInstance(item)) {

               👆

    }

}

复制代码

Kotlin 中同样可以这么解决，不过还有一个更方便的做法：使用关键字 reified 配合 inline 来解决：

  👇          👇

inline fun <reified T> printIfTypeMatch(item: Any) {

    if (item is T) { // 👈 这里就不会在提示错误了



    }

}

复制代码

上面的 Gson 解析的时候用的非常广泛，比如咱们项目里就有这样的扩展方法：

inline fun <reified T> String?.toObject(type: Type? = null): T? {

    return if (type != null) {

        GsonFactory.GSON.fromJson(this, type)

    } else {

        GsonFactory.GSON.fromJson(this, T::class.java)

    }

}

复制代码

总结

本文花了非常大的篇幅来讲 Kotlin 的泛型和 Java 的泛型，现在再回过头去回答文首的几个问题，同学你有谱了吗？如果还是感觉一知半解，不妨多看几遍。