前言

kotlin是一种在Java虚拟机上运行的静态类型编程语言，由JetBrains设计开发并开源。kotlin可以像class文件一样编译成Java字节码，在JVM上运行，也可以编译成JavaScript，方便在没有JVM的设备上运行。在2017年的Google I/O大会上，Google宣布kotlin成为Android官方开发语言。

kotlin和Java相比有什么优点
(1)代码简洁。相比较于Java代码，kotlin大量使用了高阶函数和lambda语法保证在较少的代码下实现同等的功能。
(2)非空判断。在Java中，很容易出现问题或者应用程序闪退或者crash的原因很大一部分是因为空指针异常所导致的，而kotlin中则加入了非常友好的非空处理，可以很大程度上避免出现由于非空导致程序在运行过程中出现的异常。
(3)kotlin特有的扩展属性，不再需要Java工具类，对开发者而言更加友好。
(4)跨平台。kotlin不仅支持生成.class文件运行在JVM上，同样也支持生成JavaScript运行在没有JVM支持的设备上。

当然，kotlin的优点不仅仅只是这些，还有很多其他的有待我们发现，既然Google 官方早在几年前就将它作为Android开发的官方语言，必然有它的道理，所以，接下来我们就一起来看看kotlin到底有什么魅力吧。

语法

kotlin的语法在很大程度上和Java类似，所以对于Java老司机来说，学习kotlin是很容易的事情，Java语言以.class作为文件结尾，而在kotlin中以.kt作为结尾。

变量（常量）定义

可变变量定义：var 关键字

var <标识符> : <类型> = <初始化值>

不可变变量定义：val 关键字

// val 关键字，只能赋值一次的变量(类似Java中final修饰的变量)
var <标识符> : <类型> = <初始化值>

无论是变量还是常量都可以没有初始化值，但是需要注意的是，在声明的变量或者常量作为类里面的全局使用的时候必须进行初始化操作，否则会报错，而在函数里面则非必需。

变量.png

需要强调的是，在Java中，声明变量或者常量需要显性的告知所归属的类型，而在kotlin中则无效显示，可交给编译器进行判断

var x = 5        // 系统自动推断变量类型为Int

const关键字
在Kotlin中通过val定义的变量，只有get方法，没有set方法，所以只能读不能写。但是其get方法可以复写，从而造成val定义的变量，有可能会发生值变化。所以针对这个问题，我们需要采用const关键字。在Kotlin中除了val关键字定义一个常量外，还提供了一个const关键字标识一个常量。const修饰的val变量相当于java中 static final是真正意义上的java常量。但是在实际编码中我们无法直接使用const val，而必须得这样写

// companion object类似于Java的static
companion object {
      const val C : Int = 0
}

函数定义

函数定义使用关键字 fun，参数格式为：参数 : 类型

有返回值的函数

fun sum(a: Int, b: Int): Int {   // Int 参数，返回值 Int
    return a + b
}

public fun sum(a: Int, b: Int): Int = a + b   // public 方法则必须明确写出返回类型

无返回值的函数

// Unit的可以不写，系统默认的就是Unit
fun printSum(a: Int, b: Int): Unit { 
    print(a + b)
}

可变长参数函数 vararg

fun vars(vararg v:Int){
    for(vt in v){
        print(vt)
    }
}

// 测试
fun main(args: Array<String>) {
    vars(1,2,3,4,5)  // 输出12345
}

匿名函数

fun main(args: Array<String>) {
    val sumLambda: (Int, Int) -> Int = {x,y -> x+y}
    println(sumLambda(1,2))  // 输出 3
}

注释

// 这是一个单行注释

/* 这是一个多行的
   块注释。 */

字符串模板

$ 表示一个变量名或者变量值
$varName 表示变量值
${varName.fun()} 表示变量的方法返回值

var a = 1
// 模板中的简单名称：
val s1 = "a is $a" 

a = 2
// 模板中的任意表达式：
val s2 = "${s1.replace("is", "was")}, but now is $a"

NULL检查机制

kotlin的空安全设计对于声明可为空的参数，在使用时候要进行空判断处理，处理的方式有两种：
（1）字段后加!!像Java一样抛出异常。
（2）字段后加?在值为空的时候不做处理直接返回null或者配合?:做空判断处理。

//类型后面加?表示可为空
var age: String? = "23" 
//抛出空指针异常
val ages = age!!.toInt()
//不做处理返回 null
val ages1 = age?.toInt()
//age为空返回-1
val ages2 = age?.toInt() ?: -1

类型检测及自动类型转换

我们可以使用 is 运算符检测一个表达式是否某类型的一个实例(类似于Java中的instanceof关键字)。

fun getStringLength(obj: Any): Int? {
  if (obj is String) {
    // 做过类型判断以后，obj会被系统自动转换为String类型
    return obj.length 
  }

区间

区间表达式由具有操作符形式 .. 的 rangeTo 函数辅以 in 和 !in 形成。

for (i in 1..4) print(i) // 输出“1234”

for (i in 4..1) print(i) // 什么都不输出,因为在使用in的时候必须保证前面的数字小于后面的数字

if (i in 1..10) { // 等同于 1 <= i && i <= 10
    println(i)
}

// 使用 step 指定步长
for (i in 1..4 step 2) print(i) // 输出“13”

for (i in 4 downTo 1 step 2) print(i) // 输出“42”


// 使用 until 函数排除结束元素
for (i in 1 until 10) {   // i in [1, 10) 排除了 10
     println(i)
}

需要强调的是，使用 ../downTo 既包前又包后，使用 until 只包前不包后

基本数据类型

kotlin的基本数值类型包括Byte、Short、Int、Long、Float、Double 等。不同于 Java 的是，字符不属于数值类型，是一个独立的数据类型。

除此之外，还有

boolean：
boolean数据类型表示一位的信息；
只有两个取值：true 和 false；
这种类型只作为一种标志来记录 true/false 情况；
默认值是 false；
例子：boolean one = true。

char：
char 类型是一个单一的 16 位 Unicode 字符；
最小值是 \u0000（十进制等效值为 0）；
最大值是 \uffff（即为 65535）；
char 数据类型可以储存任何字符；
例子：char letter = 'A';。

Kotlin 中没有基础数据类型，只有封装的数字类型，你每定义的一个变量，其实 Kotlin 帮你封装了一个对象，这样可以保证不会出现空指针。数字类型也一样，所以在比较两个数字的时候，就有比较数据大小和比较两个对象是否相同的区别了。在 Kotlin 中，三个等号 === 表示比较对象地址，两个 == 表示比较两个值大小。

fun main(args: Array<String>) {
    val a: Int = 10000
    println(a === a) // true，值相等，对象地址相等

    //经过了装箱，创建了两个不同的对象
    val boxedA: Int? = a
    val anotherBoxedA: Int? = a

    //虽然经过了装箱，但是值是相等的，都是10000
    println(boxedA === anotherBoxedA) //  false，值相等，对象地址不一样
    println(boxedA == anotherBoxedA) // true，值相等
}

类型转换

每种数据类型都有下面的这些方法，可以转化为其它的类型：

toByte(): Byte
toShort(): Short
toInt(): Int
toLong(): Long
toFloat(): Float
toDouble(): Double
toChar(): Char

位操作符

对于Int和Long类型，还有一系列的位操作符可以使用，分别是：

shl(bits) – 左移位 (Java’s <<)
shr(bits) – 右移位 (Java’s >>)
ushr(bits) – 无符号右移位 (Java’s >>>)
and(bits) – 与
or(bits) – 或
xor(bits) – 异或
inv() – 反向

实际上，在开发过程中，我们使用到的较多的是and、or这两个

数组

数组用类 Array 实现，并且还有一个 size 属性及 get 和 set 方法，由于使用 [] 重载了 get 和 set 方法，所以我们可以通过下标很方便的获取或者设置数组对应位置的值。

fun main(args: Array<String>) {
    //[1,2,3]
    val a = arrayOf(1, 2, 3)
    //[0,2,4]
    val b = Array(3, { i -> (i * 2) })
    //读取数组内容
    println(a[0])    // 输出结果：1
    println(b[1])    // 输出结果：2
}

条件控制

IF 表达式

一个 if 语句包含一个布尔表达式和一条或多条语句。

// 传统用法
var max = a 
if (a < b) max = b

// 使用 else 
var max: Int
if (a > b) {
    max = a
} else {
    max = b
}
 
// 作为表达式
val max = if (a > b) a else b

我们也可以把 IF 表达式的结果赋值给一个变量。

val max = if (a > b) {
    print("Choose a")
    a
} else {
    print("Choose b")
    b
}

When 表达式

when 将它的参数和所有的分支条件顺序比较，直到某个分支满足条件。
when 既可以被当做表达式使用也可以被当做语句使用。如果它被当做表达式，符合条件的分支的值就是整个表达式的值，如果当做语句使用， 则忽略个别分支的值。
when 类似其他语言的 switch 操作符。其最简单的形式如下：

when (x) {
    1 -> print("x == 1")
    2 -> print("x == 2")
    else -> { // 注意这个块
        print("x 不是 1 ，也不是 2")
    }
}

但是相比较Java的switch而言，when更加强大，它不仅能满足同一个类型的条件判断，同时还能满足多种类型的判断

when (x) {
    in 1..10 -> print("x is in the range")
    in validNumbers -> print("x is valid")
    !in 10..20 -> print("x is outside the range")
    else -> print("none of the above")
}

循环控制

For循环

for 循环可以对任何提供迭代器（iterator）的对象进行遍历，语法如下:

// 遍历对象
for (item in collection) print(item)

// 通过索引遍历
for (i in array.indices) {
    print(array[i])
}

// 同步获取key和value
for ((index, value) in array.withIndex()) {
    println("the element at $index is $value")
}

while和do...while循环

while是最基本的循环，它的结构为：

while( 布尔表达式 ) {
  //循环内容
}

do…while 循环对于 while 语句而言，如果不满足条件，则不能进入循环。但有时候我们需要即使不满足条件，也至少执行一次。
do…while 循环和 while 循环相似，不同的是，do…while 循环至少会执行一次。

返回和跳转

Kotlin 有三种结构化跳转表达式：
(1)return。默认从最直接包围它的函数或者匿名函数返回。
(2) break。终止最直接包围它的循环。
(3) continue。继续下一次最直接包围它的循环。

fun main(args: Array<String>) {
    for (i in 1..10) {
                if (i==3) continue  // i 为 3 时跳过当前循环，继续下一次循环
                println(i)
                if (i==4)return  // i 为 4 时 结束运行的函数
                if (i>7) break   // i 为 8 时 跳出循环
            }
}

这里需要强调的是，很多时候尽管return和break看起来差不多，其实二者完全不是一个概念，break更多的是作用在中断循环，而return则是直接结束当前函数。

Break 和 Continue 标签

在 Kotlin 中任何表达式都可以用标签（label）来标记。 标签的格式为标识符后跟 @ 符号，例如：abc@、fooBar@都是有效的标签。 要为一个表达式加标签，我们只要在其前加标签即可。

loop@ for (i in 1..100) {
    for (j in 1..100) {
        if (……) break@loop // 代表直接跳出被标记为loop的for循环
    }
}

关于kotlin的基础篇到这里就到一段落了，下一篇我们就开始进入到类文件，继续来看看kotlin的魅力。