Kotlin语法（一）

基本语法

1、定义包名

跟java一样，位于文件头部

    package my.demo

    import java.util.*

2、定义方法

以下面方法为例：

    fun sum(a: Int, b: Int): Int {
        return a + b
    }

方法均以fun关键字开头，a: Int, b: Int为方法参数。圆括号后面的: Int为返回值。kotlin语句与java不同的是，它不以 ; 结尾。

kotlin的方法体可以写成是一个表达式，并且返回这个表达式的最后一个语句的值。如下

    fun sum(a: Int, b: Int) = a + b

跟java 无返回值(void)相对应的关键字是Unit，并且此关键字可省略

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

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

3、定义变量

有两个关键字修饰变量
（1）val，只能赋值一次（只读）的变量类型

val a: Int = 1  // 立即赋值
val b = 2   // b是`Int`类型的，可以不用明确指出，由赋值结构可以推断得到 
val c: Int  // Type required when no initializer is provided
c = 3       // deferred assignment

（2）var，可已重新赋值（可读可写）的变量类型

var x = 5 // 由5可以推断是`Int` 类型的
x += 1

4、注释

和java的注释格式一样

// This is an end-of-line comment
/* This is a block comment
   on multiple lines. */

但和java不一样的是kotlin的注释可以互相嵌套使用

5、字符串

和groovy的字符串表达式类似，kotlin也有字符串插值表达式。格式为${变量名称 | 方法表达式},如下

var a = 1
// simple name in template:
val s1 = "a is $a" 
println(s1)

a = 2
// arbitrary expression in template:
val s2 = "${s1.replace("is", "was")}, but now is $a"
println(s2)

打印结果为：
a is 1
a was 1, but now is 2

6、条件表达式

if…elseif…else

fun maxOf(a: Int, b: Int): Int {
    if (a > b) {
        return a
    } else {
        return b
    }
}

if语句也是一个表达式，所以此方法还可以写成

fun maxOf(a: Int, b: Int): Int = if(a > b) a else b

原来的return关键字可以省略，因为表达式默认返回最后一条语句，在此条件表达式中返回a或b。

7、nullable variable(可为null的变量)

kotlin在定义变量的时候有两种形式，一种是not null（值不能为null），另外一种是nullable（可以为空）

val a: Int? = null //?紧跟具体类型则为nullable

8、类型检查及类型自动转换

关键字 is 检查一个表达式是否属于某个类型，如果使用了is关键字检查某个变量并且返回true，则将会根据上下文判断自动转换成这个类型，如

fun getStringLength(obj: Any): Int?{
    if(obj is String){
        return obj.length //obj已经自动转换成了string类型
        }
        return null
}

相对应的还有 !is ，

9、for循环

val items = listOf(1, 2, 3)
for(item in items){
    println(item)
}

or

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

10、while循环

val items = listOf(1, 2, 3)
var index = 0
while(index < items.size){
    println("item at $index is ${items[index]}")
}

11、when表达式

可以代替if…else。kotlin中没有switch…case…语法，when表达式也可以认为是它的增强版。

fun describe(obj: Any): String = 
when(obj){
    1               ->  "one"
    "hello"      ->  "hello"
    is Long     ->  "Long"
    !is String  -> "not a String"
    else          -> "unknown"
}

fun main(args: Array<String>) {
    println(describe(1))
    println(describe("Hello"))
    println(describe(1000L))
    println(describe(2))
    println(describe("other"))
}

//打印结果为
One
Greeting
Long
Not a string
Unknown

12、ranges操作符

• 检查变量x是否在某范围内，如下代码：

fun main(args: Array<String>) {
    val x = 10
    if (x in 1..100) {
        println("fits in range")
    }
}

关键字in表示是否在范围内，操作符..则表示[1, 100]

• 检查一个数字是否不在一个范围内

val list = listOf("a", "b", "c")

if (-1 !in 0..list.lastIndex) {
    println("-1 is out of range")
}

• for循环遍历

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

打印结果为======
1  2   3  4  5

• for根据特定的步距（step）循环遍历，

for (x in 1..10 step 2) {
    print(x)
}

打印结果为=====
1  3  5  7  9

• for向下遍历

for  (x in 9 downTo 0 step 3) {
    print(x)
}

打印结果为======
9  6  3  0

使用downTo，这不是关键字其实是kotlin提供的一种方法格式，可以写成9.downTo(3)，这个以后再详细说明。

• 集合
  遍历一个集合， in关键字可以用在实现了Iterable接口的实例对象。

fun iterate(args: Array<String>) {
    val items = listOf("apple", "banana", "kiwi")
    for (item in items) {
        println(item)
    }
}

检查一个对象是否在一个集合中，可以用in关键字，如下：

fun main(args: Array<String>) {
    val items = setOf("apple", "banana", "kiwi")
    when {
        "orange" in items -> println("juicy")
        "apple" in items -> println("apple is fine too")
    }
}

• 使用lambda表达式对集合进行操作，如下

fun main(args: Array<String>) {
    val fruits = listOf("banana", "avocado", "apple", "kiwi")
    fruits.filter {it.startsWith("a")
    .sortBy {it}
    .map { it.toUpperCase() }
    .forEach { println(it) }}
}

使用lambda表达式时，和groovy语法类似，如果只有一个参数时，这个参数可以省略，并且参数名称为it，可以直接使用。