从Java到Kotlin有多远？

相对于Java来说，Kotlin真的是太简洁了.

Kotlin新鲜的地方

1、去掉了分号（如无必要，勿增实体），看起来非常的neat
2、听说再也不会空指针了（只要不用'！！'）（下面会解释）
3、所有一切皆为对象（好像JS）

Java与Kotlin的一些区别

类的声明

上一篇文章，我们看到了Kotlin声明的一个类，是这样的

class MainActivity : AppCompatActivity() {
  ...
}

这里我们到了继承的方式使用冒号来表示，并且还可以在声明中添加一个主构造。另外权限修饰符也变成默认了，在Kotlin中默认是public
而Java默认是default（同包下可以访问），下面就是Kotlin的修饰符代表的含义。

image.png

构造：

//在 Kotlin 中的一个类可以有一个主构造函数和一个或多个次构造函数。主构造函数是类头的一部分：它跟在类名（和可选的类型参数）后。没有修饰可以省略
class Person constructor(firstName: String) {
}
//主构造函数不能包含任何的代码。初始化的代码可以放到以 init 关键字作为前缀的初始化块（initializer blocks）中：
class Customer(name: String) {
    init {
        logger.info("Customer initialized with value ${name}")
    }
}
//类也可以声明前缀有 constructor的次构造函数：
class Person {
    constructor(parent: Person) {
        parent.children.add(this)
    }
}
//如果类有一个主构造函数，每个次构造函数需要委托给主构造函数， 可以直接委托或者通过别的次构造函数间接委托。委托到同一个类的另一个构造函数用 this 关键字即可：
class Person(val name: String) {
    constructor(name: String, parent: Person) : this(name) {
        parent.children.add(this)
    }
}

基本类型

Java有byte, short, int, long, float, double, boolean, char八种基本类型，对于Kotlin来说可以说没有基本类型，因为所有的类型都是对象，可以说与一般的引用类型无异了。但Kotlin对与数字和字符来说，当需要可空引用时，数字和字符会被装箱。装箱操作不会保留同一性（不是同一个对象）。

fun main(args: Array<String>) {
    val a: Int = 10000
    println(a === a) // 输出“true”
    val boxedA: Int? = a
    val anotherBoxedA: Int? = a
    println(boxedA == anotherBoxedA)//输出true
    println(boxedA === anotherBoxedA)//输出false
}

上述的例子==比较的是值，===比较的是对象地址，与Java有些不太一样。不过对于Int来说Kotin会内置-128到127这些Int对象，这些范围内的装箱还是同一个对象，与Java是一样的。对布尔值来说，封箱操作会保留同一性，因为系统会内置两个Boolean对象。

另外Kotlin的数组使用的Array<T>来表示，还有IntArray，ByteArray等可以直接拿来用。

对于字符串来说还有这种操作？

//原生字符串 使用三个引号（"""）分界符括起来，内部没有转义并且
//可以包含换行和任何其他字符:
//你可以通过 trimMargin() 函数去除前导空格：
//默认 | 用作边界前缀，但你可以选择其他字符并作为参数传入，比//如 trimMargin(">")。
val text = """
    |Tell me and I forget.
    |Teach me and I remember.
    |Involve me and I learn.
    |(Benjamin Franklin)
    """.trimMargin()

变量与属性

对于变量的定义，java是先声明变量的类型，然后变量的名称，还可以有各种修饰符。而Kotlin只有两种，val和var。val用于声明不变量(类似于java的final变量，只能赋值一次)，var声明可变量可以多次赋值。变量类型甚至可以省略，自动判断。

        //一次赋值（只读）的局部变量
        val a: Int = 1  // 立即赋值
        val b = 2   // 自动推断出 `Int` 类型
        val c: Int  // 如果没有初始值类型不能省略
        c = 3       // 明确赋值
        //可变变量
          var x = 5 // 自动推断出 `Int` 类型
         x += 1

声明一个属性的完整语法是
var <propertyName>[: <PropertyType>] [= <property_initializer>]
[<getter>]
[<setter>]
中括号包含的可以没有，会使用默认的。如果不想让外部赋值，则可以这样。这样外部只能拿到值但是不能改变值了。

var i: Int = 1
  private set

函数

Java使用void或者返回类型来定义函数，Kotlin使用关键词fun来定义，而且可以用=来直接返回结果，甚至省略返回类型。特别像JavaScript。

//带返回参数类型
fun sum(a: Int, b: Int): Int {
    return a  + b
}
//或者不带返回参数类型，自动推断函数返回类型
fun sum(a: Int, b: Int) = a + b

//函数不返回值
fun printSum(a: Int, b: Int): Unit{
    XXX
}
//或者省略Unit
fun printSum(a: Int, b: Int) {
    XXX
}

Java中有静态函数，而Kotlin却没有，不过Kotlin提供了类的扩展函数，类似于Java的静态函数，不过这个扩展函数也是通过这个类的对象调用的。同理静态变量也通过这种方法来扩展。

class Test {
}
fun Test.test() {
  //扩展函数
}
var i: Int = 1 //通过Test().i调用，所有对象的i值相同

流程控制

• if
  Kotlin中if条件可以放到方法中外，还可以写成表达式，如果代码简单还可以省略大括号

val max = if (a > b) {
    print("Choose a")
    a
} else {
    print("Choose b")
    b
}
// 作为表达式
val max = if (a > b) a else b

• when
  类似于Java的switch语句，一个例子概括

when (x) {
    0, 1 -> print("x == 0 or x == 1")
    2 -> print("x==2")
    else -> print("otherwise")
}

• 循环
  Kotlin在循环中经常使用到关键词in

//一行代码省略大括号
for (item in collection) print(item)
//代码块
for (item: Int in ints) {
    // ……
}
//索引遍历
for (i in array.indices) {
    print(array[i])
}

非空判断

在Kotlin中当某个变量的值可以为 null 的时候，必须在声明处的类型后添加 ? 来标识该引用可为空。如果如果标识了程序就会返回null，不会执行空后的语句。
如果不标识那么就编译不过，当然也可以使用!!来放过这个可能的null，这样就会抛出一个空指针了。

a?.length()//如果a为null，就不会执行length()了
a!!.length()//可能会抛出空指针

位运算

位运算的效率毋庸置疑，但是开发中却很少人用，要想程序运行的快，善用位运算还是很重要的，成为高级开发工程师必不可缺的一步。

这是完整的位运算列表（只用于 Int 和 Long）：
    • shl(bits) – 有符号左移 (Java 的 <<)
    • shr(bits) – 有符号右移 (Java 的 >>)
    • ushr(bits) – 无符号右移 (Java 的 >>>)
    • and(bits) – 位与
    • or(bits) – 位或
    • xor(bits) – 位异或
        • inv() – 位非

其他一些关键字

• range
  Kotlin提供了很实用区间工具，满足我们对数字区间条件的各种判断。

for (i in 1..4) print(i) // 输出“1234”
for (i in 4..1) print(i) // 什么都不输出（默认正序）
for (i in 4 downTo 1) print(i) // 输出“4321”
for (i in 1..4 step 2) print(i) // 输出“13” 可以+2跳
for (i in 4 downTo 1 step 2) print(i) // 输出“42”
for (i in 1 until 10) {   // i in [1, 10) 排除了 10（区间边界）
     println(i)
}

• ${}
  在字符串中把表达式放到大括号中就可以替换字符串中了，让字符串更加灵活。
• companion
  伴生对象，只能通过类名作为限定符来调用，很像Java的静态方法，在运行时他们仍然是真实对象的实例成员，而且，例如还可以实现接口：

interface Factory<T> {
    fun create(): T
}
class MyClass {
    companion object : Factory<MyClass> {
        override fun create(): MyClass = MyClass()
    }
}

• 数据类：data关键字标记，data class XX
• 跳转标签
  Java可以在循环分支前写 XXX:来标记这个循环，而Kotlin使用@符号来标记。例如：

loop@ for (i in 1..100) {
    for (j in 1..100) {
        if (……) break@loop
    }
}

Kotlin的一些默认规范

命名来说，与Java的命名规范是一样的。Kotlin语言有自己的很多习惯用法，可以让代码变得很短，可读性很强。善用Kotlin提供的一些好用的特性。

然后还有就是冒号和空格之类的注意一下，最好和官方推荐的一致。

另外，对于Kotlin来说，函数可以获取值，所以我们也可以通过函数来取值。但是底层算法优先使用的属性而不是函数，因此我们还是尽量使用属性来满足自己的需求。

还需要多用才能熟练

官方文档是大家入门的最好的资料，而且还有中文版https://www.kotlincn.net/docs/reference/