Kotlin 程序是什么样子的？在Kotlin中一切都是对象，没有像Java中那样的原始基本类型，这是非常有帮助的，因为我们可以使用一致的方式来处理所有的可用的类型。很有可能你觉得 Kotlin 语言有点古怪，充满了 var field: String这样的语法，然而读完本文之后，你将不再对这些语法感到陌生。

一、基本类型

上文说过，在 Kotlin 中所有东西都是对象， 在这个意义上讲我们可以在任何变量上调⽤成员函数和属性。有些类型是内置的，因为他们的实现是优化过的，但是⽤户看起来他们就像普通的类。当然，像integer、float、boolean等类型仍然存在，但是它们全部都会作为对象存在的。

一些基本的工作方式都是与Java非常相似的，比如：

• 定义包
  包的声明应处于源⽂件顶部：

package my.demo
import java.util.*
// ……

• 注释

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

但是一些基本类型也有一些明显的不同之处，比如：

• 数字类型中不会自动转型。
  举个例子，你不能给Double变量分配一个Int，必须要做一个明确的类型转换：

val i: Int=7
val d: Double = i.toDouble()

是的你没有看错，Kotlin每句话后面是不需要分号的！

• 字符（Char）不能直接作为一个数字来处理。
  在需要时我们需要把他们转换为一个数字：

val c: Char = 'c'
val i: Int = c.toInt()

• 位运算也有一点不同。
  在Android中，我们经常在flags中使用“或”，下面对比来说明：
• Java

int bitwiseOr = FLAG1 | FLAG2;
int bitwiseAnd = FLAG1 & FLAG2;

• Kotlin

val bitwiseOr = FLAG1 or FLAG2
val bitwiseAnd = FLAG1 and FLAG2

还有很多其他的位操作符，比如sh1、shs、ushr、xor、inv等，我们需要的时候，可以在Kotlin官网查看。

• 字面上可以写明具体的类型。
  这个不是必须的，但是一个通用的 Kotlin 实际上是可以省略变量的类型的，我们可以让编译器自己去推断出具体的类型。

val i = 12 // An Int
val iHex = 0x0f // 一个十六进制的Int类型
val l = 3L // A Long
val d = 3.5 // A Double
val f = 3.5F // A Float

• 一个String可以像数组那样访问，并且被迭代：

val s = "Example"
val c = s[2] // 这是一个字符'a'
// 迭代String
val s = "Example"
for(c in s){
    print(c)
}

二、基本语法

这里我们先说一说Kotlin中的变量：

变量可以很简单地定义成可变(var)和不可变（val）的变量。这个与Java中使用的final很相似。但是不可变在Kotlin（和其它很多现代语言）中是一个很重要的概念。

一个不可变对象意味着它在实例化之后就不能再去改变它的状态了。如果你需要一个这个对象修改之后的版本，那就会再创建一个新的对象，这让编程更加具有健壮性和预估性。在Java中，大部分的对象是可变的，那就意味着任何可以访问它这个对象的代码都可以去修改它，从而影响整个程序的其它地方。

不可变对象也可以说是线程安全的，因为它们无法去改变，也不需要去定义访问控制，因为所有线程访问到的对象都是同一个。所以在Kotlin中，如果我们想使用不可变性，我们编码时思考的方式需要有一些改变。一个重要的概念是：尽可能多地使用val。除了个别情况（特别是在Android中，有很多类我们是不会去直接调用构造函数的），大多数时候是可以的。

接下来说一说如何定义变量以及其他类型:

• 定义局部变量
• ⼀次赋值 （只读） 的局部变量:

val a: Int = 1 // 立即赋值
val b = 2 // 自动推断出 `Int` 类型
val c: Int // 如果没有初始值类型不能省略
c = 3 // 明确赋值

• 可变变量：

var x = 5
x += 1

• 定义函数
• 带有两个 Int 参数、 返回 Int 的函数：

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 {
      println("sum of $a and $b is ${a + b}")
}

• Unit 返回类型可以省略：

fun printSum(a: Int, b: Int) {
      println("sum of $a and $b is ${a + b}")
}

• 字符串模板

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

• 使用区间 （range）
• 使用 in 运算符来检测某个数字是否在指定区间内：

val x = 10
val y = 9
if (x in 1..y+1) {
      println("fits in range")
}

• 检测某个数字是否在指定区间外:

val list = listOf("a", "b", "c")
if (-1 !in 0..list.lastIndex) {
      println("-1 is out of range")
}
if (list.size !in list.indices) {
      println("list size is out of valid list indices range too")
}

• 区间迭代:

for (x in 1..5) {
      print(x)
}

• 或数列迭代：

for (x in 1..10 step 2) {
      print(x)
}
for (x in 9 downTo 0 step 3) {
      print(x)
}

• 使用集合
• 对集合进行迭代:

for (item in items) {
        println(item)
}

• 使用 in 运算符来判断集合内是否包含某实例：

when {
      "orange" in items -> println("juicy")
      "apple" in items -> println("apple is fine too")
}

强大的 when表达式 我们会在以后更详细地说明，相关语法下文回继续介绍。

• 使⽤ lambda 表达式来过滤（filter）和映射（map）集合：

fruits
      .filter { it.startsWith("a") }
      .sortedBy { it }
      .map { it.toUpperCase() }
      .forEach { println(it) }

更多的 lambda表达式 的用法，我们会在以后给出！

三、控制流

（1）If 表达式

• 在 Kotlin 中，if是⼀个表达式， 即它会返回⼀个值，因此不需要三元运算符（条件 ? 然后 : 否则）， 因为普通的 if 就能胜任这个⻆⾊。

// 传统用法
var max = a
if (a < b) max = b
// With 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
}

如果你使用 if 作为表达式而不是语句（例如：返回它的值或者把它赋给变量），该表达式需要有 else 分支。

（2）When 表达式

• When 取代了类Java的 switch 操作符，其最简单的形式如下：

when (x) {
      1 -> print("x == 1")
      2 -> print("x == 2")
      else -> { // 注意这个块
          print("x is neither 1 nor 2")
      }
}

when 将它的参数和所有的分支条件顺序比较， 直到某个分支满足条件。
when 既可以被当做表达式使用也可以被当做语句使用。如果它被当做表达式，符合条件的分支的值就是整个表达式的值，而且此时必须有 else 分支，除非编译器能够检测出所有的可能情况都已经覆盖了； 如果当做语句使用，则忽略个别分支的值。（像If⼀样， 每⼀个分支可以是⼀个代码块，它的值是块中最后的表达式的值。）

• 如果很多分支需要用相同的方式处理， 则可以把多个分支条件放在⼀起， 用逗号分隔：

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

• 我们可以用任意表达式 （而不只是常量） 作为分⽀条件：

when (x) {
      parseInt(s) -> print("s encodes x")
      else -> print("s does not encode x")
}

• 我们也可以检测⼀个值在（in）或者不在（!in）⼀个区间或者集合中：

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")
}

• 另⼀种可能性是检测⼀个值是（is）或者不是（!is）⼀个特定类型的值：
  由于智能转换， 你可以访问该类型的方法和属性而无需任何额外的检测。

fun hasPrefix(x: Any) = when(x) {
    is String -> x.startsWith("prefix")
    else -> false
}

• when也可以用来取代 if-else if 链：
  如果不提供参数， 所有的分支条件都是简单的布尔表达式， 而当⼀个分支的条件为真时则执行该分支。

when {
    x.isOdd() -> print("x is odd")
    x.isEven() -> print("x is even")
    else -> print("x is funny")
}

（3）For 循环

• for 循环可以对任何提供迭代器 （iterator） 的对象进行遍历：

for (item in collection) print(item)

• 循环体可以是⼀个代码块：
  这一点和Java很像！

for (item: Int in ints) {
    // ……
}

如上所述，for 可以循环遍历任何提供了迭代器的对象，即：有⼀个成员函数或者扩展函数iterator() ，它的返回类型有⼀个成员函数或者扩展函数next() ，并且有⼀个成员函数或者扩展函数hasNext()返回Boolean，这三个函数都需要标记为operator。

• 如果你想要通过索引遍历一个数组或者一个list，你可以这么做：
  对数组的 for 循环会被编译为并不创建迭代器的基于索引的循环。

for (i in array.indices)
    print(array[i])

注意这种“在区间上遍历”会编译成优化的实现而不会创建额外对象。

• 或者你可以用库函数 withIndex：

for ((index, value) in array.withIndex()) {
      println("the element at $index is $value")
}

（4）While 循环

• while 和 do..while 照常使⽤

// while
while (x > 0) {
      x--
}
// do while
do {
      val y = retrieveData()
} while (y != null)   // y 在此处可见

四、属性

属性与Java中的字段是相同的，但是更加强大，它做的事情是字段加上getter加上setter，我们通过一个例子来比较他们的不同之处。

• 这是Java中字段安全访问和修改所需要的代码：

public class Person {
    private String name;
    public String getName() {
        return name;
    }
    public void setName(String name) { 
        this.name = name;
    }
}
// ......
Person person = new Person();
person.setName("name");
String name = person.getName();

• 在Kotlin中，只需要一个属性就可以了：

public class Person {
    var name: String = ""
}
// ......
val person = Person()
person.name = "name"
val name = person.name

如果没有任何指定，属性会默认使用getter和setter。当然它也可以修改为你自定义的代码，并且不修改存在的代码：

public classs Person {
    var name: String = ""
        get() = field.toUpperCase()
        set(value){
            field = "Name: $value"
        }
}

如果需要在getter和setter中访问这个属性自身的值，它需要创建一个backing field。我们可以使用 field 这个预留字段来访问，它会被编译器找到正在使用的并自动创建。

需要注意的是，如果我们直接调用了属性，那我们会使用setter和getter而不是直接访问这个属性，backing field只能在属性访问器内访问。

就如在前面章节提到的，当操作Java代码的时候，Kotlin将允许使用属性的语法去访问在Java文件中定义的getter、setter方法。编译器会直接链接到它原始的getter、setter方法，所以当我们直接访问属性的时候不会有性能开销。

额外的几个函数：

通过数据类，我们可以方便地得到很多有趣的函数，一部分是来自属性，正如我们上面所说（编写getter和setter函数）：

• equals():它可以比较两个对象的属性来确保他们是相同的。
• hashCode():我们可以得到一个hash值，也是从属性中计算出来的。
• copy():你可以拷贝一个对象，可以根据你的需要去修改里面的属性，我们会在以后的例子中看到。
• 一系列可以映射对象到变量中的函数:我们之后会说道这个。

好了，至此为止，你已经全方位的掌握了Kotlin中最基本最核心的语法，可以动手开始实践了，关于更为高阶的知识点，比如：扩展函数、委托属性、依赖注入等会在接下来的文章中写到，欢迎大家关注！