初学Kotlin——在自定义View里的应用

程序员桔子

于 2024-05-23 21:30:00 发布

阅读量1.5k

点赞数 38

文章标签： kotlin 微信开发语言

本文链接：https://blog.csdn.net/Karka_/article/details/139040652

版权

什么是Kotlin

Kotlin，它是JetBrains开发的基于JVM的面向对象的语言。2017年的时候被Google推荐Android的官方语言，同时Android studio 3.0正式支持这门语言，在这个编译器上创建一个Kotlin项目，非常方便，甚至可以Java转为Kotlin。

我主要是在通过实现自定义`View`过程中,说一下`Kotlin`与`Java`的异同,其实两者非常相似

对Kotlin语法不是太了解的，可以先去看看它的官方翻译文档

以Barchart-Kotlin开始说起

Barchart-Kotlin是我用Kotlin写的一个简易灵活的柱状图库，喜欢的可以点个star！

1.类的属性

在一个类里面我们需要定义一些属性来保存数据和状态

我们先来看看Java代码，在BarChartView定义了一些属性

 private SpeedLinearLayoutManger mLayoutManager;
    private BarChartAdapter mAdapter;
    private ItemOnClickListener mClickListener;
    private int mDefaultWidth = 150;

然后我们再看看Kotlin是怎么定义这些属性的，下面的是Kotlin代码

 private lateinit var mLayoutManager: SpeedLinearLayoutManger
    private lateinit var mAdapter: BarChartAdapter
    private var mClickListener: ItemOnClickListener? = null
    private val mDefaultWidth = 150

你会发现不一样的声明方式，但重要的是var和val这两个关键字

var代表的是可变的变量，相当于现在Java声明变量的方式

val代表的是不可变的变量，初始化后不能再修改，相当于加了final关键字的变量

而且在Kotlin中属性是需要初始化的，没有值的时候你可以赋值null,不然编译会报错。加上?的意思是你不确定是否是这个类型，或者说是否为null。如果觉得实在是不方便你的使用逻辑，你可以使用这两种方式延迟初始化。

懒初始化 by lazy

lazy是指推迟一个变量的初始化时机，只有在使用的时候才会去实例化它。适用于一个变量直到使用时才需要被初始化。在我这个项目里面没有使用by lazy,它大致的用法是这样的

val data: Data by lazy {
    Data(number,string)
   }

延迟初始化 lateinit

lateinit是指你保证接下来在使用之前或者使用的时候会实例化它,不然你就会crash掉，这不就跟我们使用Java属性的方式一样么。。。它适用于一些view和必须用到数据结构的初始化，我觉得还是谨慎使用比较好。

2.空安全

Kotlin可以说是分了两个大类型，可空类型和不可空类型，这样做的原因是它希望在编译阶段就把空指针这问题显式的检测出来，把问题留在了编译阶段，让程序更加健壮。它通过?来表达可为空。

mClickListener?.invoke1(position)
mClickListener?.invoke2(position)
mClickListener?.invoke3(position)

如果mClickListener为null的话，后面的语句是不会执行的。而且Kotlin提供了更加简洁的操作符let

mListener?.let {  
it.invoke1(position)
it.invoke2(position)
it.invoke3(position)  
}

只有在非空的情况下才执行let里面的操作，非常简洁。

3.构造器

通过简单了解之后，我们开始写一个自定义View，我们需要继承View,Java的实现方式是这样的

public class BarChart extends View {

    public BarChart(Context context) {
        super(context);
    }

    public BarChart(Context context, @Nullable AttributeSet attrs) {
        super(context, attrs);
    }

    public BarChart(Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
    }

用Kotlin你可以实现的更简洁

class BarChart @JvmOverloads constructor(context: Context, attrs: AttributeSet? = null, defStyleAttr: Int = 0)
    : View(context, attrs, defStyleAttr) {
    
    private val mContext: Context = context

    init { }

你可以在init代码块里面获得构造函数的传参，当然你也可以直接在声明属性的时候获得，@JvmOverloads 如果你没有加上这个注解，它只能重载相匹配的的构造函数，而不是全部。

而且可能你也发现了，你可以在传参里面初始化，这相对于Java来说，灵活太多

fun shadow(width:Int=100,height:Int = 180){ }
//你可以这么使用
shadow()
shadow(140)
shadow(140,200)

4.UI布局

一般用我们创造view的布局是xml,Kotlin也是支持的，但是它更推荐你使用Anko的布局方式。

那是什么是Anko呢,Anko是JetBrains开发的一个强大的库，它主要的目的是用来替代以前xml的方式来使用代码生成UI布局的，它包含了很多的非常有帮助的函数和属性来避免让你写很多的模版代码。

有兴趣的你可以去看看它的源码与更多使用方式 – Anko

首先你要在Gradle里添加Anko的引用

// Anko Layouts
compile "org.jetbrains.anko:anko-recyclerview-v7:$anko_version"
compile "org.jetbrains.anko:anko-recyclerview-v7-coroutines:$anko_version"
compile "org.jetbrains.anko:anko-sdk25:$anko_version"
compile "org.jetbrains.anko:anko-appcompat-v7:$anko_version"
// Coroutine listeners for Anko Layouts
compile "org.jetbrains.anko:anko-sdk25-coroutines:$anko_version"
compile "org.jetbrains.anko:anko-appcompat-v7-coroutines:$anko_version"

然后你可以在代码里写UI布局的代码了，就是用Kotlin代码替代xml

 private fun createView(attrs: AttributeSet? = null, defStyleAttr: Int = 0) {

   var height = dip(150)
   attrs?.let {
            val typeArray = mContext.obtainStyledAttributes(it, R.styleable.BarChartView, defStyleAttr, 0)
            height = typeArray.getDimension(R.styleable.BarChartView_chart_height, dip(150).toFloat()).toInt()
            typeArray.recycle()
        }

    verticalLayout {
            lparams(width = matchParent, height = matchParent)

            frameLayout {
                lparams(width = matchParent, height = wrapContent)

                mLineView = view {
                    backgroundColor = R.color.gray_light
                }.lparams(width = matchParent, height = dip(0.5f)) {
                    gravity = Gravity.BOTTOM
                    bottomMargin = dip(9)
                }

                mBarView = recyclerView {
                    lparams(width = matchParent, height = height)
                }
            }

            mDateView = relativeLayout {
                lparams(width = matchParent, height = wrapContent) {
                    leftPadding = dip(10)
                    rightPadding = dip(10)
                }

                mLeftTv = textView {
                    textSize = 15f
                }

                mRightTv = textView {
                    textSize = 15f
                }.lparams(width = wrapContent, height = wrapContent) {
                    alignParentRight()
                }
            }
        }
    }

可以从代码里看见verticalLayout(其实就是LinearLayout的vertical模式)包裹了frameLayout和relativeLayout,里面又有各自的子view,而且你会发现xml有的属性这里也有，调用起来非常的简洁明了，熟练xml的来写这个，我觉得上手应该会很快，它的缺点就是没有预览效果，以及实现复杂的view结构的时候会比较繁琐，考验盲写的功力了。。。。

5.扩展函数

扩展函数是Kotlin非常方便实用的一个功能，它可以让我们随意的扩展SDK的库，你如果觉得SDK的api不够用，这个时候你可以用扩展函数完全去自定义。

例如你需要这样来获取颜色，每次你都需要一个上下文context

mColor = ContextCompat.getColor(mContext, R.color.primary)

那你可以通过扩展Context这个SDK的类来实现更方便的使用

fun Context.color(colorRes: Int) = ContextCompat.getColor(this, colorRes)
fun View.color(colorRes: Int) = context.color(colorRes)

而且为了更方便在View里面使用，又扩展了View。在第一个方法里面可以发现getColor所需要的this上下文，就是Context。同样，View里面的context是getContext()所得到，也就是View里面本身具有的公有方法。

这其实是很惊艳的功能

那我们可以想一想为啥可以这样做，我们知道的是Kotlin和Java都是在Jvm上运行的，既然都是编译成class字节码，那我们是不是可以通过字节码来了解一些事情。

通过Android studio 3.0上的Tools的工具Show Kotlin Bytecode,可以将刚才的扩展函数的代码编译成字节码

 // access flags 0x19
  public final static color(Landroid/content/Context;I)I
    @Lorg/jetbrains/annotations/NotNull;() // invisible, parameter 0
   L0
    ALOAD 0
    LDC "$receiver"
    INVOKESTATIC kotlin/jvm/internal/Intrinsics.checkParameterIsNotNull (Ljava/lang/Object;Ljava/lang/String;)V
   L1
    LINENUMBER 12 L1
    ALOAD 0
    ILOAD 1
    INVOKESTATIC android/support/v4/content/ContextCompat.getColor (Landroid/content/Context;I)I
    IRETURN
   L2
    LOCALVARIABLE $receiver Landroid/content/Context; L0 L2 0
    LOCALVARIABLE colorRes I L0 L2 1
    MAXSTACK = 2
    MAXLOCALS = 2

  // access flags 0x19
  public final static color(Landroid/view/View;I)I
    @Lorg/jetbrains/annotations/NotNull;() // invisible, parameter 0
   L0
    ALOAD 0
    LDC "$receiver"
    INVOKESTATIC kotlin/jvm/internal/Intrinsics.checkParameterIsNotNull (Ljava/lang/Object;Ljava/lang/String;)V
   L1
    LINENUMBER 14 L1
    ALOAD 0
    INVOKEVIRTUAL android/view/View.getContext ()Landroid/content/Context;
    DUP
    LDC "context"
    INVOKESTATIC kotlin/jvm/internal/Intrinsics.checkExpressionValueIsNotNull (Ljava/lang/Object;Ljava/lang/String;)V
    ILOAD 1
    INVOKESTATIC shadow/barchart/ExtensionsKt.color (Landroid/content/Context;I)I
    IRETURN
   L2
    LOCALVARIABLE $receiver Landroid/view/View; L0 L2 0
    LOCALVARIABLE colorRes I L0 L2 1
    MAXSTACK = 3
    MAXLOCALS = 2

这就是编译后的字节码，看不懂是吧，我也看不懂。。但是我们可以反编译啊，生成Java代码

 public static final int color(@NotNull Context $receiver, int colorRes) {
      Intrinsics.checkParameterIsNotNull($receiver, "$receiver");
      return ContextCompat.getColor($receiver, colorRes);
   }

   public static final int color(@NotNull View $receiver, int colorRes) {
      Intrinsics.checkParameterIsNotNull($receiver, "$receiver");
      Context var10000 = $receiver.getContext();
      Intrinsics.checkExpressionValueIsNotNull(var10000, "context");
      return color(var10000, colorRes);
   }

通过反编译我们可以知道这是个静态函数，Intrinsics.checkParameterIsNotNull($receiver, "$receiver");这个函数只起到了判空的作用，真正的代码是return ContextCompat.getColor($receiver, colorRes);这个不就是我们刚刚用的Java代码嘛。

重点是$receiver接收的对象，接收的是Context实例，这样的话就可以调用这个类的所有公有方法和公有属性，而且它是静态函数，它可以通过类直接调用。所以扩展函数的实现只不过是加了一个需要当前对象的静态方法，调用的时候传入一个当前对象而已。

我们刚刚用到了反编译，因为我们知道Kotlin和Java的生成字节码是一样的，那我们可以了解一下Kotlin的编译过程，它跟Java的区别是什么。可以看一下这篇文章Kotlin编译过程分析

通过这篇文章你可以了解到Kotlin在编译过程中，与Java是大致相同的,只是在最后生成目标代码的时候做了很多类似于封装的事情，生成相同的语法结构，Kotlin将我们本来在代码层做的一些封装工作转移到了编译后端阶段。那我们可不可以在学习Kotlin的时候去这样理解，其实Kotlin是一种封装了Java的强大的语法糖，Java做不到的事情，Kotlin其实也做不到，例如对象只能访问公有属性。

6.数据类

在Kotlin中你要实现数据类是非常简单的，并不需要手动加上get/set方法

data class BarItem(
        private val barData: BarData,
        var select: Boolean = false) {
    fun getData(): Double {
        return barData.getData()
    }

    fun getTag(): String {
        return barData.getTag()
    }
}

在这个类里面你会发现，我还声明了两个方法，我需要的是BarData里的数据，但又不仅仅只需要这个数据，所以我声明了一个类来封装它，其实这个相当于装饰者模式了。Kotlin有更好的方式实现这个模式

data class BarItem(
        private val barData: BarData,
        var select: Boolean = false) : BarData by barData

7.when

在BarChartView里用到一个与switch语法类似的语句

 mSelectPosition = when (mStyle) {
            ScrollStyle.DEFAULT -> mDataList.size - 1
            ScrollStyle.START -> 0
            ScrollStyle.NONE -> -1
            ScrollStyle.CUSTOM -> mSelectPosition
            else -> { }
        }

它是起到了跟switch一样的作用,并且更强大，因为它是表达式，所以是有返回值的，在Kotlin中控制流大都是表达式，都是可以有返回值的。

8.集合

Kotlin是区分可变集合和不可变集合的，它给你提供这两种选择。

 //不可变
 Set<out T>
 Map<K, out V>
 List<out T>
 //可变
 MutableSet<T>
 MutableMap<K, V>
 MutableList<T>

不可变的集合提供只读属性，例如size,get等,Kotlin不提供专门的语法结构创建list或者set,是用标准库获取的，我们可以看一下它的源码是怎样实现。

/**
 * Returns an immutable list containing only the specified object [element].
 * The returned list is serializable.
 * @sample samples.collections.Collections.Lists.singletonReadOnlyList
 */
@JvmVersion
public fun <T> listOf(element: T): List<T> = java.util.Collections.singletonList(element)

/**
 * Returns an empty new [MutableList].
 * @sample samples.collections.Collections.Lists.emptyMutableList
 */
@SinceKotlin("1.1")
@kotlin.internal.InlineOnly
public inline fun <T> mutableListOf(): MutableList<T> = ArrayList()

从源码可以看见这是Java的java.util.Collections.singletonList和ArrayList，这就可以理解为啥不可变和可变的了。。。

总结

Kotlin相对于Java,更像是封装了Java的强大语法糖，使用了更简洁的语法提高了生产力。

接下来我将给各位同学划分一张学习计划表！

学习计划

那么问题又来了，作为萌新小白，我应该先学什么，再学什么？
既然你都问的这么直白了，我就告诉你，零基础应该从什么开始学起：

阶段一：初级网络安全工程师

接下来我将给大家安排一个为期1个月的网络安全初级计划，当你学完后，你基本可以从事一份网络安全相关的工作，比如渗透测试、Web渗透、安全服务、安全分析等岗位；其中，如果你等保模块学的好，还可以从事等保工程师。

综合薪资区间6k~15k

1、网络安全理论知识（2天）
①了解行业相关背景，前景，确定发展方向。
②学习网络安全相关法律法规。
③网络安全运营的概念。
④等保简介、等保规定、流程和规范。（非常重要）

2、渗透测试基础（1周）
①渗透测试的流程、分类、标准
②信息收集技术：主动/被动信息搜集、Nmap工具、Google Hacking
③漏洞扫描、漏洞利用、原理，利用方法、工具（MSF）、绕过IDS和反病毒侦察
④主机攻防演练：MS17-010、MS08-067、MS10-046、MS12-20等

3、操作系统基础（1周）
①Windows系统常见功能和命令
②Kali Linux系统常见功能和命令
③操作系统安全（系统入侵排查/系统加固基础）

4、计算机网络基础（1周）
①计算机网络基础、协议和架构
②网络通信原理、OSI模型、数据转发流程
③常见协议解析（HTTP、TCP/IP、ARP等）
④网络攻击技术与网络安全防御技术
⑤Web漏洞原理与防御：主动/被动攻击、DDOS攻击、CVE漏洞复现

5、数据库基础操作（2天）
①数据库基础
②SQL语言基础
③数据库安全加固

6、Web渗透（1周）
①HTML、CSS和JavaScript简介
②OWASP Top10
③Web漏洞扫描工具
④Web渗透工具：Nmap、BurpSuite、SQLMap、其他（菜刀、漏扫等）

那么，到此为止，已经耗时1个月左右。你已经成功成为了一名“脚本小子”。那么你还想接着往下探索吗？

阶段二：中级or高级网络安全工程师（看自己能力）

综合薪资区间15k~30k

7、脚本编程学习（4周）
在网络安全领域。是否具备编程能力是“脚本小子”和真正网络安全工程师的本质区别。在实际的渗透测试过程中，面对复杂多变的网络环境，当常用工具不能满足实际需求的时候，往往需要对现有工具进行扩展，或者编写符合我们要求的工具、自动化脚本，这个时候就需要具备一定的编程能力。在分秒必争的CTF竞赛中，想要高效地使用自制的脚本工具来实现各种目的，更是需要拥有编程能力。

零基础入门的同学，我建议选择脚本语言Python/PHP/Go/Java中的一种，对常用库进行编程学习
搭建开发环境和选择IDE，PHP环境推荐Wamp和XAMPP，IDE强烈推荐Sublime；

Python编程学习，学习内容包含：语法、正则、文件、网络、多线程等常用库，推荐《Python核心编程》，没必要看完

用Python编写漏洞的exp,然后写一个简单的网络爬虫

PHP基本语法学习并书写一个简单的博客系统

熟悉MVC架构，并试着学习一个PHP框架或者Python框架 (可选)

了解Bootstrap的布局或者CSS。