南京音乐推荐联合社

开启Kotlin编程之旅&Java程序员的思维进化

CodeThings 2019-06-10 13:03:35

本周在部门进行了一场Kotlin分享,于是有了这篇文章

Kotlin编程语言简介

  • 由Intelij IDEA生产商JetBrains开源 

  • 2011年开始,2016年初发布1.0正式版,目前最新1.2.31 

  • 基于JVM平台,JS平台和Native本地平台的编程语言

  • 静态的,支持函数式编程范式

  • 与Java语言极高的兼容和互操作

Kotlin的生态环境

  • GitHub star 2万多 

  • Kotlin在2018 TIOBE 3月份语言排行榜38名 

  • 国外Stackoverflow 发布的2018 Developer Survey Results报告中,75.1%对Kotlin感兴趣

  • Spring 5.0版本将支持Kotlin

  • Kotlin不足:编译器存在优化空间,大范围使用目前只在Android开发领域

Kotlin的语言特性&Kotlin与Java的差异

空指针安全

引用/对象为空时调用报NullPointException异常

Java世界里

Java对空指针的处理的方式有以下:

  1. if判断,过滤null,缺陷:代码冗余

  2. 做一层包装,比如Java世界里,Double,Int 装箱;Java8里Optional包装; 缺陷:代码冗余,额外的包装接口影响运行时性能,即使在代码中到处都使用了Optional,仍然需要处理JDK、Android框架,以及其他第三方库中的方法返回null值。

  3. 使用注解(@nullable,@NotNull) + 插件代码检测;缺陷:这些工具不是标准Java编译过程的一部分,很难保证她们自始至终都被应用,而且很难使用注解标记覆盖所有可能发生错误的地方

Kotlin要怎么做的?

Kotlin世界里

以字符串对象为例

在Java里:

String = String + null

在Kotlin里

String = String  
String?= String + null

因此,String和String?是两种类型。Kotlin中的String?相当于Java里的String

对类型,Kotlin让我们有了新的认识:

  1. Kotlin中,所有常见类型默认都是非空的

  2. 什么是类型?就是对数据的分类,分类的类目里有一类是null

隆重登场, Kotlin的处理

程序执行顺序上出了偏差或是其他原因,对象引用没有建立起来,就会出现空指针,空指针在逻辑上就存在了

  1. ?.调用 把一次null检查和一次方法调用合并成一个操作。

  2. ?: Evlis运算符:问号前面的对象是null么?如果是则返回冒号后面的值,如果不是则返回问号前的值

  3. 拓展函数

data class Person(val name: String, val age: Int){

    fun walk(){
        println("$name is walking")
    }
}

val p = Person("Kotlin",6)
val p2 = null
p2?.walk()

val p3 = p2?:p
println("${p3.name}")

简洁、高效性

  • 好吃的语法糖,少了Java冗余啰嗦;比如类型推断与自动强转,引入数据类data

  • 语言层级提供了大量的非常方便的实现;比如Kotlin的标准库封装了大量对集合操作的快捷方法

  • 命名参数,默认参数

  • 拓展函数 

  • 高阶函数,局部函数实现闭包

kotlin提供了一些特性保证Kotlin简洁高效,比如:

拓展函数

StringUtil.captitalize(s)
s.captitalize

意义:一方面让代码组织的更简洁,另一方面暗合了Java6大设计原则的开闭原则。对原来的类的定义不做修改,而是通过拓展特性来完成(java实现上是通过工具类组合的方式来做的)

运算符重载

set.add(2)
set += 1

中缀调用

1.to("one")
1 to one

get方法约定

 当作成员变量般调用

map.get("key")
map["key"]

invoke约定/对()操作符的重载

有了这个约定,在Kotlin的世界里,一切对象都可以认为是函数了。比如lambda表达式,可以这样使用labmda()就是因为 Kotlin约定了,除非是内联,lambda表达式都会被编译成实现了函数式接口(Function1)的类,这些接口定义了具有对应数量参数的invoke方法

比Java8更接近的函数式/声明式范式

Lambda表达式存在三个简化约定:

  1. 如果lambda表达式,参数类型为空,可以省略参数和箭头

  2. 如果lambda表达式参数类型只有一个,可以省略参数和箭头并使用it作为形参

  3. 如果lambda表达式作为函数的最后一个参数,可以把放到括号外

来一段代码实例

现在有一个需求:添加前缀,分隔符,后缀,打印出某个给定的集合里的所有元素

java实现:

public class SeparatorUtils {

    /**
     *
     * @param collections 集合
     * @param prefix 前缀
     * @param separator 分隔符
     * @param postfix 后缀
     * @param <T> 集合泛型
     * @return 分隔后的结果
     */
    @NotNull
    public static <T> String separate(Collection<T> collections, String prefix , String separator, String postfix) {
        Objects.requireNonNull(collections);
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append(prefix);
        int index = 0;
        for (T t : collections) {
            if(index > 0){
                stringBuilder.append(separator);
            }
            stringBuilder.append(t.toString());
            index ++;
        }
        stringBuilder.append(postfix);
        return stringBuilder.toString();
    }
}

对应Kotlin实现:

@JvmOverloads
public fun <T> separate(
        collection: Collection<T>,
        prefix: String = "(",
        separator: String = ",",
        postfix: String = ")"
): String {
    val stringBuilder = StringBuffer(prefix)
    for ((index, element) in collection.withIndex()) {
        if (index > 0) {
            stringBuilder.append(separator)
        }
        stringBuilder.append(element)
    }
    stringBuilder.append(postfix)
    return stringBuilder.toString()
}

对上述代码作简化,如下

@JvmOverloads
fun <T> separate3(
        collection: Collection<T>,
        prefix: String = "(",
        separator: String = ",",
        postfix: String = ")"
): String {
    return StringBuffer(prefix)
            .apply {
                for ((index, element) in collection.withIndex()) {
                    if (index > 0) {
                        append(separator)
                    }
                    append(element)
                }
                append(postfix)
            }.toString()
}

使用拓展函数,减少一个入参

fun <T> Collection<T>.separateInto(prefix: String = "(",
                                   separator: String = ",",
                                   postfix: String = ")"
): String {
    return separate3(this, prefix, separator, postfix)
}

Kotlin中闭包的实现

一个简易的方法调用次数计数器:

fun compute(): () ->Int{
    var count = 0
    fun inner(): Int{
        count ++
        return count
    }
    return {inner()}
}

调用

val message:() -> Int = compute()
    for(i in 0..3){
        println(message())
    }

输出结果

1234

此时,compute()方法里的count像全局变量,累加记数。简易的访问流程:外部的A访问B函数,B内部的函数C访问B,同时B返回C。

闭包就是这样一种结构:函数嵌套一个访问自己变量的内部函数结构

闭包带给我们两个好处:

  1. 让某个变量保存在内存里,能起到消除不与其他方法通信的成员变量的作用

  2. 外部能访问到函数内部的变量

相关链接

  • 2018 TIOBE 3 月排行榜

  • 2018 Developer Survey Results

  • Spring 5 支持Kotlin

  • Talk is cheap, show me the code出处

Kotlin学习相关链接:

  • JetBrains官网

  • Kotlin官方语言文档

  • GitHub: Kotlin

  • Kotlin的Twitter账号

  • 书籍:Kotlin实战

  • 书籍:Effective Java 中文版(第2版)


Copyright © 南京音乐推荐联合社@2017