google为什么选择kotlin？kotlin如何解决java开发痛点【续】？

时间 2020-07-17

标签 google 为什么选择 kotlin 如何解决 java 发痛栏目 Google 繁體版

原文原文链接

上篇，kotlin如何解决java开发痛点，让程序员happier 写的很长，大叔觉得在快餐式学习的时代，没几我的会看到最后。没想到，看完整篇的掘友还很多。html

@懒洋君 鼓励大叔，让大叔再写一篇，多写几个痛点，说是会来给大叔点赞，但愿不是骗大叔的~ 哈~java

今天这篇比上篇还长，你还会看完整篇吗？哈哈哈~~python

1、google为什么选择kotlin？

咱们先来聊点有趣的八卦：谷歌为什么选择kotlin，而不是继续改造java？android

谷歌选择kotlin的缘由真的是由于kotlin比java更好用吗？git

大叔能够确定的说，“kotlin比java更好用”，这确定不是谷歌选择kotlin的缘由。程序员

以谷歌的研发实力，彻底有能力，参与到java的发展中来，让java变的愈来愈好用。甚至比kotlin还要好用。github

2011~2014年java连续三年拖更，2014年~2017年，又拖更三年。面试

以后恢复了发版节奏【1年2个版本】。随后的更新确实让java愈来愈好用了。编程

甚至有些人说，java愈来愈像kotlin了。bash

咱们在上一篇中讨论的：

kotlin字符串支持，三引号""" java14也有这个特性了。【java14今年三月份发布的】

kotlin的use函数，自动关闭closeable java7 也有try-with-resources的写法，解决相似的问题。

咱们下文会讨论的：

when表达式，java14，switch也支持了相似的表达式了。

智能类型转换 java14的类型转换也开始愈来愈智能了。

说这么多，想表达的观点就是: java彻底能够愈来愈好用。谷歌彻底能够参与到java的迭代，让java愈来愈好用，甚至能够坐等sun公司借鉴更多语言的特性。没有必要伤筋动骨，把android首选语言换成kotlin，说实话这么多开发者，换一门语言的成本得有多高。并非全部开发者都像掘友们还有大叔这样热爱学习。

谷歌选择kotlin的最直接缘由，是由于sun公司碰瓷。

2010开始sun公司起诉谷歌:在Android上使用Java代码侵犯版权和专利权。

历史是惊人的类似。sun公司曾经成功碰瓷过微软。哈哈哈。。。

13年后，sun公司，故技重施，你说谷歌愿意重蹈微软的覆辙吗？

咱们再来，看看android官方网站，关于room的java的教程：

All rights reserved. Java is a registered trademark of Oracle and/or its affiliates.

谷歌的用到java的教程中，明确标出了：版权全部。Java是Oracle公司全部。

谷歌选择kotlin只是为了摆脱专利诉讼而已。固然kotlin本身也争气。确实表现优异。

再请你们吃一个瓜：

google前CEO，埃里克·施密特，担任过sun公司高管，并且是特别高的那种。

1983年，施密特加盟Sun公司，前后担任首席技术官和首席执行官。

首任工程部副总裁韦恩.罗森（Wayne Rosen），也曾经任职过sun公司。

以上，只是大叔我的观点，纯属意淫，没有sun公司和谷歌公司的实锤资料。请你们保持独立思考。

2、kotlin如何解决java开发痛点【续】？

咱们进入今天的第二个主题。继续一个个语法特性来说，kotlin如何解决java开发痛点。

没有看上一篇 kotlin如何解决java开发痛点，让程序员happier 的朋友们，能够先看下上一篇，这样会更有连续性。

2.1 操做符：== 和 ===

咱们先从一道java考题入手。大叔仍是一位亮仔的时候，被这道题折磨的痛并快乐着，哈哈~

大多数 java老鸟都认识这道题。

JavaEqualMain.java

public static void intEqual(){
  Integer int127First = 127;
  Integer int127Second = 127;
  System.out.println("int127First == int127Second :" + (int127First == int127Second));

  Integer int128First = 128;
  Integer int128Second = 128;
  System.out.println("int128First == int128Second :" + (int128First == int128Second));

}
复制代码

大叔的灵魂拷问：日志会输出什么？

眼熟吗，是否是面试的时候遇到过？

是否是大学考试的时候考过？哈哈~

日志输出：

int127First == int127Second :true
int128First == int128Second :false
复制代码

原理解析：

public static void intEqual(){
  Integer int127First = 127;
  Integer int127Second = 127;
  //由于 -128到127 的整数 都在常量池里
  //因此 int127First 与 int127Second 指向了，常量池中同一个对象，因此这里输出true
  System.out.println("int127First == int127Second :" + (int127First == int127Second));

  Integer int128First = 128;
  Integer int128Second = 128;
  //由于128不在常量池里，因此 int128First和int128Second 是不一样的对象，因此这里输出false
  System.out.println("int128First == int128Second :" + (int128First == int128Second));

}
复制代码

咱们再来看看 kotlin的代码：

KtEqualMain.kt

fun intEqual() {
  val int127First = 127
  val int127Second = 127
  println("int127First == int127Second :" + (int127First == int127Second))

  val int128First = 128
  val int128Second = 128
  println("int128First == int128Second :" + (int128First == int128Second))

}
复制代码

大叔的灵魂拷问：日志会输出什么？

日志输出：

int127First == int127Second :true
int128First == int128Second :true
复制代码

对你没有看错，两个结果都是true。

why？

为何？

kotlin 提供了两个相等操做符 == 和 ===

结构相等 ==：用 equals() 判断相等性

引用相等=== ：判断两个引用是否指向同一对象

大叔自我拷问，结构相等这个操做符有什么用呢？他能解决什么痛点呢？

jvm中存在常量池机制，字符串、部分包装类对象有可能存在常量池，也可能不在常量池。

引用相等运算结果，与常量池耦合，若是两个对象都在常量池中，运算结果为true，若是有一个不在常量池中，或者都不在常量池中，即便两个对象内容相同，运算结果也是false。

致使，引用相等运算，有点复杂，一不留神可能就搞错了。

kotlin的结构相等，跟常量池无关了，直接经过equal方法判断，运算结果与常量池不耦合，无论对象在不在常量池，运算结果都是同样的。

不只减小了初学者的学习成本。也减小了研发老鸟的犯错成本。

三等号“===” kotlin的三等号运算效果，就是java的双等号“==”，熟悉python的朋友，应该一点都不陌生。由于python也是这样的。

而且，而且，而且，kotlin中，结构相等 == 还会帮咱们自动判空。咱们看下面两段代码。

首先是java代码。JavaEqualMain.java

/** * 判断字符串是否相等 */
public static boolean isTextEqual(String str1, String str2){
  if(str1 == str2){
    return true;
  }
  if(str1 != null && str2 != null){//由于str1和str2可能有一个为null，因此咱们要判空
    return str1.equals(str2);
  }
  return false;
}
复制代码

咱们再看看看kotlin，怎么实现：KtEqualMain.kt

/** * 判断字符串是否相等 */
fun isTextEqual(str1: String?, str2: String?): Boolean {
  return str1 == str2
}
复制代码

是的，你没有看错，kotlin就是这么简洁。

kotlin的 isTextEqual()方法，会编译器被翻译成isTextEqual2()：

fun isTextEqual2(str1: String?, str2: String?):Boolean{
    return str1?.equals(str2) ?: (str2 === null)
}
复制代码

上面这段代码段，是官网文档的解释。www.kotlincn.net/docs/refere…

kotlin不熟悉的同窗，可能会比较迷茫。

大叔把他改一下，你就明白了。

fun isTextEqual3(str1: String?, str2: String?):Boolean{
  if (str1 == null){
    return str2 == null
  }
  return str1.equals(str2)
}
复制代码

这就是，会自动判空的缘由。

总结一下：

kotlin 提供了两个相等操做符 == 和 ===

== 【结构相等】，用 equals() 检测。

至关于调用 Object.equals() 方法，而且处理了，对象为null状况，无需手动判空处理。

=== 【引用相等】，两个引用是否指向同一对象

至关于java的 ==

再来个面试考试常考的题

这个题也是面试常考的题，咱们一块儿触类旁通一下哈。

欢迎，老铁们，在评论区说出你的答案：

java代码：JavaEqualMain.java

public static void stringEqual(){
  String strBuilder1 = new StringBuilder("IT互联网大叔").toString();
  String strBuilder2 = new StringBuilder("IT互联网大叔").toString();
  System.out.println("strBuilder1 == strBuilder2 :" + (strBuilder1 == strBuilder2));


  String str1 = "IT互联网大叔";
  String str2 = "IT互联网大叔";
  System.out.println("str1 == str2 :" + (str1 == str2));
}
复制代码

大叔的灵魂拷问：日志会输出什么？

kotlin代码：KtEqualMain.kt

fun stringEqual() {
  val strBuilder1 = StringBuilder("IT互联网大叔").toString()
  val strBuilder2 = StringBuilder("IT互联网大叔").toString()
  println("strBuilder1 == strBuilder2 :" + (strBuilder1 == strBuilder2))


  val str1 = "IT互联网大叔"
  val str2 = "IT互联网大叔"
  println("str1 == str2 :" + (str1 == str2))
}
复制代码

大叔的灵魂拷问：日志会输出什么？

2.2 智能类型转换(Smart Casts)

咱们来看一段Java代码：

public static void close(Object obj) throws IOException {
  //已经判断他是Closeable，依然须要强转
  if(obj instanceof Closeable){
    ((Closeable) obj).close();
  }
}
复制代码

咱们再来看看kotlin

@Throws(IOException::class)
fun close(obj: Any) {
  if (obj is Closeable) {
    obj.close()//obj已是一个Closeable类型了
  }
}
复制代码

咱们继续

再继续

上面这种写法，java代码段是否是看的有点迷茫，看不懂，你忙就对了，大叔也迷茫。

java对泛型的强转，已经严重影响到，代码的可读性了。

kotlin的类型转换，对代码的可读性提高了太多。

2.3 if、when表达式

val max =  if (a > b){
  print("a is bigger")
  a
} else if(a == b){
  print(" a == b")
  a
}else {
  print("b is bigger")
  b
}
//....
复制代码

上面代码也能够用when表达式，实现：

val max = when {
  a > b -> {
    print("a is bigger")
    a
  }
  a == b -> {
    print(" a == b")
    a
  }
  else -> {
    print("b is bigger")
    b
  }
}
复制代码

比java的 三元运算符（条件 ? 而后 : 不然），if表达式可读性要更高，对初学者也更友好。

并且比 三元运算符 更灵活。

另外，java14的switch也变成表达式了。

对了kotlin的try catch，也能够当表达式用。

2.4 解构申明(Destructuring Declarations)

什么是解构申明？解构申明能干什么？

2.4.1 经过解构申明，遍历Map

咱们先来看看，java是怎么遍历Map的。

Map<String, Integer> map = new HashMap<String, Integer>();
map.put("one", 1);
map.put("two", 2);

for (Map.Entry<String, Integer> entry : map.entrySet()) {
  System.out.println(entry.getKey() + "->" + entry.getValue());
}
复制代码

上面的代码，全部java程序员都很是熟悉。

不是大叔吹牛，从大学，到如今，大叔写过的for循环遍历，比你家娃，吃过的盐还多。

能够说这种对Map遍历的方式，已经完全扎根在个人思惟里。我以为全天下全部程序都应该是这么遍历的。

直到有一天，大叔碰见了kotlin的解构申明：

val map = mapOf("one" to 1, "tow" to 2)

for ((key, value) in map) {//经过解构申明来遍历Map
    println("$key->$value")
}
复制代码

一声直呼，我靠，还能这样遍历Map。

这才是人的思惟方式啊，兄弟们啊啊啊。。。。

这种语法是如此的亲切简洁。基本上都不用学习，看一眼就懂这是什么意思。

想一想刚学编程的那会，学c语言，一个for循环遍历就能学一周。。。。

接着咱们找到Maps.kt的源码：

kotlin正是经过 component1() 和 component2() 两个函数实现了Map.Entry类的解构申明。

接着咱们来看一个代码段：

fun main() {
  val people = People("IT互联网大叔", 18)
  var (myName, myAge) = people//注意这行代码，解构申明
  println("my name is $myName, i am $myAge")
}

class People(val name: String, val age: Int) {

  operator fun component1() = name //注意
  operator fun component2() = age  //注意
}
复制代码

由于People重载了函数component1()和component2()，因此能够将其解构成name和age。

咱们一块儿看看kotin是怎么作到的吧。

咱们先来看看他的字节码吧。

什么，字节码？大叔别逗我了。这怎么看？

看起来麻烦？不容易理解。

嗯，大叔很是赞成。

因此大叔准备了另外一份代码段，把上面的字节码反编译成java代码。

这种解构申明的语法，本质是个语法糖，在编译器作了一些优化。

只是编译器帮咱们，调用了people.component1()并帮咱们赋值了。

String myName = people.component1();
int myAge = people.component2();
复制代码

3.4.2 经过解构申明，实现函数返回多个值

众所周知，java的函数只能有一个返回值。不能同时返回多个值。

可是有了解构申明以后，咱们能够伪装，函数能返回多个值，以下代码：

fun main() {
  val (myName, myAge) = getFirstPeople()//返回值为People，咱们能够直接把返回值结构
  println("my name is $myName, i am $myAge")
}

fun getFirstPeople() = People("IT互联网大叔", 18)
复制代码

3.五、无符号整型

咱们知道java里面是没有无符号整型的，可是kotlin有，哈哈哈。

kotlin.UByte: 无符号 8位，范围是 0 到 255
kotlin.UShort: 无符号 16位，范围是 0 到 65535
kotlin.UInt: 无符号 32位，范围是 0 到 2^32 - 1
kotlin.ULong: 无符号 64位，范围是 0 到 2^64 - 1
复制代码

大叔的自我拷问：这能解决啥痛点，劳资java写了这么多年了，没有无符号整形，不是照样写的好好的么。

在痛点3.4 解构申明 里面咱们写了一个类People：

class People(val name: String, val age: Int) {}
复制代码

咱们的age是int类型。int是能够是负数的。

可是 “年龄” 这种东西有负数吗？

咱们把age传进来的时候，是否是要作个数据检查。

假若有同事传了个负数，致使程序出bug，就只能怪本身不严谨。

相似，打破你的认知，java，除以0必定会崩溃吗？ blog里描述的bug。

因而咱们改造了下代码，咱们先假如kotlin没有无符号整型：

class People {
    private val name: String
    private val age: Int

    constructor(name: String, age: Int) {
        this.name = name
        if (age >= 0) {
            this.age = age
        } else {
            this.age = 0
            println("illegal age $age")
        }
    }
}
复制代码

UInt类型，自从有了你，世界变得好美丽 ------ ˙这句要唱出来

class People(val name: String, val age:UByte) {}
复制代码

不只更优雅并且更健壮。

3、结尾

好了，聊完了技术。大叔要开始碎碎念了。

前两天，有位很资深的老鸟，年纪比大叔还要大，跟大叔聊天。

资深的老鸟：“我作的这个需求，要延期了“

大叔：“怎么了？”

资深的老鸟：“这个模块，以前的实现大量使用了LiveData，我还没用过LiveData，并且，他用的好复杂，代码好难看懂啊……”

大叔：“额，那你打算怎么弄？”

资深的老鸟：“我打算，重写一下这个模块，xxx同事，这个LiveData用的太复杂了，一个很简单的逻辑，写的好复杂啊……我改不动……”

资深的老鸟：“哎，这种团队还没普及的技术，最好不要随便乱用吧，并且他用的很复杂，一个很简单的功能，绕来绕去的……搞的如今项目紧张状况下，让我难受……”

大叔：“……”

大叔内心其实挺为这位同事捏把汗的，我以为，他选择了一个很冒险的方式。在这种紧急的状况下，重写一个模块，每每风险只会更高。

掘友们，大家怎么看呢？若是你是老鸟，你会怎么选择？

赞美是一种美德，点个赞再走啊，老铁。💖大叔须要你的赞👍