戳上面的蓝字关注我们哦！

最近在学kotlin,虽然还没有像其他博主一样立马就爱上它.但是不得不说,kotlin对比起java还是有不少优势的.

1、语法简洁

首先是语法比较简洁,能不简单处理的就不啰嗦.

1.1、变量与常量

变量通过var关键字定义,常量通过val关键字定义.既支持类型推倒也支持显示声明类型.这样的话定义变量和常量写起来会比java简洁一些:

var intVar = 1 var stringVar: String = "abc" val INT_VALUE = 1

1.2、类

在kotlin中,类可以通过class关键字定义.支持在主构造方法中用var或者val关键字直接定义成员变量,例如下面的name和author,当然也支持在类结构体中定义成员变量,如price.

class Book(var name: String, val author: String, p: Int) {    var price = p        private set     fun isTheSameAuthor(other: Book): Boolean {        return author == other.author    }}

与java中不同的是,kotlin中所有的类成员变量都是通过类访问器get和set去访问成员变量的,例如下面的代码中对price的调用并不是直接操作price变量,而是通过get/set访问器去访问的.所以我们可以将price的set访问器设置为私有的,这样的话就不能在外部去设置price的值了:

var book = Book("book", "author", 100)println(book.price) book.price = 123

假设我们用java去实现上面的Book类,我们需要写成下面这个样子.是不是感觉java的语法会啰嗦很多?实际上下面的java代码我还去掉了空指针处理和final关键字修饰.所以实际上代码量会更大.kotlin中短短的七行代码,java中要实现完全一模一样的功能,起码需要数十行代码.

public class Book {   private int price;   private String name;   private String author;   public Book(String name, String author, int p) {      this.name = name;      this.author = author;      this.price = p;   }   public boolean isTheSameAuthor(Book other) {      return Intrinsics.areEqual(this.author, other.author);   }   public int getPrice() {      return this.price;   }   private void setPrice(int var1) {      this.price = var1;   }   public String getName() {      return this.name;   }   public void setName(String var1) {      this.name = var1;   }   public String getAuthor() {      return this.author;   }}

1.3、数据类

在kotlin中,我们还有可以用data class去定义单纯只是保存数据的数据类:

data class Person(var name: String, var age: Int)

有的同学可能会会,数据类和普通的类有什么区别呢?让我们看下下面的代码就一目了然了:

data class PersonData(var name: String, var age: Int)class PersonClass(var name: String, var age: Int)var dataA = PersonData("jack", 18)var dataB = PersonData("jack", 18)println(dataA) println(dataB) println(dataA == dataB) var classA = PersonClass("peter", 20)var classB = PersonClass("peter", 20)println(classA) println(classB) println(classA == classB)

假设用java去实现的话就不知道这一行的kotlin代码需要多少行才能实现了.

1.4、object 对象

我们能使用object关键字直接实现单例模式:

object DataBaseHelper {  ...}

它翻译成java是这样的:

public class DataBaseHelper {  public static final DataBaseHelper INSTANCE;  private DataBaseHelper() {  }  static {    INSTANCE = new DataBaseHelper();  }}

2、命名参数

kotlin支持命名参数。当一个方法的参数数目特别多的时候,命名参数就很有用了。例如String.regionMatches方法有五个参数:

public boolean regionMatches(boolean ignoreCase, int toffset,            String other, int ooffset, int len) {    ...}

在调用的时候一眼很难看出哪个实参有什么作用:

String str = new String("hello world!");String sub = new String("WORLD");System.out.println(str.regionMatches(true, 6, sub, 0, 5));

而在kotlin中可以用命名参数将每个实参对应的形参注明出来,简直一目了然:

val str = "hello world!"val sub = "WORLD"println(str.regionMatches(thisOffset = 6, other = sub, otherOffset = 0, length = 5, ignoreCase = true))//命名参数可以用不同于函数声明的参数顺序传参println(str.regionMatches(ignoreCase = true, thisOffset = 6, other = sub, otherOffset = 0, length = 5))

而且使用命名参数的话可以不遵循方法声明的时候的参数顺序传参,因为我们已经将哪个实参传给哪个形参都标明了.

3、空指针安全

在kotlin中,每个类型都有其对应的可空类型,只有可空类型才能被赋值为null:

var a: Int = 1 var b: Int? var c: String = "" var d: String? = null var e: Float = 1.0f var f: Float? = 2.0f a = null b = null c = null d = null e = null f = null

非空类型不可能为null,所以不用考虑空指针的问题.只有可空类型有可能为null,这个时候必须指定它为null的时候的行为.

可以用"?."做判空处理,或者使用"!!."在空指针的情况下抛出空指针异常:

fun foo(str : String?){    println(str?.length)     println(str!!.length) }

foo方法翻译成java是这样的:

public final void foo(@Nullable String str) {  Integer var2 = str != null?Integer.valueOf(str.length()):null;  System.out.println(var2);  if(str == null) {    Intrinsics.throwNpe();   }  int var3 = str.length();  System.out.println(var3);}

很多文章在介绍kotlin的可空类型的时候都是以简化了判空处理的优点来介绍的.例如下面java方法中的判空处理,用kotlin只需要一行代码就可以了:

public Character front(String str) {    if (str != null){        return str.charAt(0);    }    return null;}fun front(str: String?): Char? {   return str?.get(0);}

但是在我看来,可空类型非空类型的意义并不在帮我们做简化了判空处理的代码.更重要的一点是明确指出了哪些变量是可能为空的,同时明确了为空的时候的调用应该怎么处理.

对于非空类型,它永远不可能为空,我们不需要考虑它的空指针问题.而对于可空类型,我们需要明确指定在它为空的时候的调用抛出异常亦或进行执行.这样其实缩小了空指针异常的范围,同时也减小了空指针对程序稳定安全的破坏性.

4、字符串模板

在kotlin字符串中可以用"$"符号标识一个表达式,该表达式的值会被计算出来放到字符串中:

val str = "abc"println("$str.length is ${str.length}") // 结果为 "abc.length is 3"

比起java用字符串拼接或者String.format的方式去处理都要优雅得多.

5、高阶函数和Lambda表达式的支持

在java中实现观察者模式,我们往往需要额外定义一个监听者的接口,这种监听者接口往往也只有一个方法,其实实际上属于比较冗余的代码,没有很大的实际价值:

public class Button {    private OnClickListener mListener;    public void setOnClickListener(OnClickListener listener) {        mListener = listener;    }    public interface OnClickListener {        void onClick(Button button);    }}

而在kotlin中我们可以将函数直接作为一个对象保存起来,再也不用为监听者单独定义一个接口了:

class Button {  var listener: ((Button) -> Unit)? = null  fun click() {    listener?.invoke(this)  }}var btn = Button()btn.listener = { print("on click") }btn.click()

6、泛型

在java泛型中存在类型通配符,用"? extends T"指定类参数的上限,用"? super T"指定类型参数的下限.

至于什么时候使用哪一种,在《Effect java》 中给出了PECS原则:

PECS: producer-extends,consumer-super

在生产者中使用"? extends T",在消费者中使用"? super T".

java中使用类型的关系去设计了通配符,这样做的确在实现上是比较清晰的.但是我个人其实更加喜欢kotlin中直接通过功能去规定类型安全的类型上下界.

public <T> void copy(List<? super T> dest, List<? extends T> src) {  ...}

List<? super T> dest 是消费者,数据将会放到这里.而List<? extends T> src是生产者,数据从这里提供.

实际上看copy这个java方法,在定义的时候需要稍微思考一下才能确定哪个用super哪个用extends.但是如果你用kotlin的话想都不用想,消费者用in,生产者用out:

fun <T> copy(dest: Array<in T>, src: Array<out T>) {  ...}

直接用in/out这种功能描述是不是比java用super/extends这种类型描述直接了很多?

泛型这部分参考了《Kotlin极简教程》,这本书真的不错,强烈推荐.而大家如果对java泛型有兴趣的话可以去可空《Effect java》的相关章节或者也可以去看看我之前写的两篇文章 《java泛型那些事》、《再谈Java泛型》

7、无缝调用java

当然,一个语言就算做的再好,但是没有一个健全的生态的话是很难被大众接受的.kotlin能够火起来,甚至被谷歌爸爸钦定为安卓的官方推荐语言.一个很重要的原因就是它可以无缝与java相互调用.以前写的java代码不用任何处理就能直接在kotlin中使用,而java也能无缝调用kotlin代码.

实际上在安卓中,编译的时候kotlin代码就会被编译成java代码,所以它们其实是等价的.

作者 | 嘉伟咯

地址 | https://www.jianshu.com/p/f57e7a7ac707

声明 | 本文是 嘉伟咯 原创，已获授权发布，未经原作者允许请勿转载