1.函数

• 声明一个函数

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

函数的声明以关键字fun开始，函数名紧跟其后sum，接下来是括号括起来的参数列表。参数列表的后面跟着返回类型，它们之间用一个冒号隔开。

示例代码

fun main(args: Array<String>) {
    println(sum(1, 2))
    println(sum2(3, 4))
    myPrint(3,7)
}

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

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

fun myPrint(a: Int, b: Int): Unit {//Unit可以省略掉
    println("$a + $b = ${a + b}")//字符串模板
}

-运行结果

3
7
3 + 7 = 10

2. 变量（可变变量和不可变量）

• 声明变量的关键字有两个：
   1. val(来自于value)----不可变引用。使用val声明的变量不能在初始化之后再次赋值。它对应的是Java的final变量。即常量。
   2. var(来自variable)-----可变引用。这种变量的值可以被改变。这种声明对应的时普通（非final）的Java变量。即变量。
• 示例代码：

fun multiply(a: Int, b: Int) = a * b

//import com.leofight.kotlin2.multiply

import com.leofight.kotlin2.multiply as myMultiply

fun main(args: Array<String>) {
    val a: Int = 1 //常量 val相当于final
    val b = 2

    var c: Int //变量 var定义变量
    c = 3
    c = 4

    var d = 3
    d = 4

    println(d)

    //kotlin注释
    /**
     * kotlin注释
     */

    /*
    /*
       kotlin 注释
     */
     */

    var x = 10
    var y: Byte = 20

    x = y.toInt() //kotlin 不允许把 byte 赋值给 int

    println(x)

    //println(multiply(2,3))//需要导入Calculation中的multiply
    println(myMultiply(2, 3))


    val m = intArrayOf(1, 2, 3)

    //m = intArrayOf(4,5)//不可修改

    m.set(0, 4)//常量中第一个元素修改成4

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


}

• 运行结果

4
20
6
4
2
3

3. 流程控制

语句和表达式
 在kotlin中，if是表达式，而不是语句。语句和表达式的区别在于，表达式有值，并且能作为另一个表达式的一部分使用；而语句总是包围着它的代码块中的顶层元素，并且没有自己的值。在Java中，所有的控制结构都是语句。而在Kotlin中，除了循环（for、do和do/while)以为大多数控制结构都是表达式。这种结合控制结构和其他表达式的能力让你可以简明扼要地表示许多常见的模式。

• 示例代码

fun main(args: Array<String>) {

    //第一种方式
    var x1 = 10
    var y1 = 20

    var max1: Int
    var min1: Int

    if (x1 > y1) {
        max1 = x1
        min1 = y1
    } else {
        max1 = y1
        min1 = x1
    }

    println("max1 = $max1,min1 = $min1")

    //第二种方式，等同方法一

    var x2 = 10
    var y2 = 20

    var max2 = if (x2 > y2) x2 else y2
    var min2 = if (x2 > y2) y2 else x2

    println("max2 = $max2,min2 = $min2")

    //第三种方式
    var x3 = 10
    var y3 = 20

    var max3 = if (x3 > y3) {
        println("x3 > y3")
        x3
    } else {
        println("x3 <= y3")
        y3
    }

    var min3 = if (x3 > y3) {
        println("x3 > y3")
        y3
    } else {
        println("x3 <= y3")
        x3
    }

    println("max3 = $max3,min3 = $min3")

}

• 运行结果

max1 = 20,min1 = 10
max2 = 20,min2 = 10
x3 <= y3
x3 <= y3
max3 = 20,min3 = 10

4. Kotlin中的异常

• 示例代码

fun main(args: Array<String>) {
    println(conver2Int("123"))

    printMultiply("2", "3")

    printMultiply("2", "a")

    printMultiply2("3", "4")
}

fun conver2Int(str: String): Int? {//？ 类似optional 可能为空 防止空指针异常
    try {
        return str.toInt()
    } catch (ex: NumberFormatException) {
        return null
    }
}

fun printMultiply(a: String, b: String) {
    var a2Int = conver2Int(a)
    var b2Int = conver2Int(b)

    if (null != a2Int && null != b2Int) {
        println(a2Int * b2Int)
    } else {
        println("param not int")
    }
}

fun printMultiply2(a: String, b: String) {
    var a2Int = conver2Int(a)
    var b2Int = conver2Int(b)

    //println(a2Int * b2Int) //无法编译通过 required int found int？

    if (null == a2Int) {
        println("param not int")
    } else if (null == b2Int) {
        println("param not int")
    } else {
        println(a2Int * b2Int)
    }
}

• 运行结果

123
6
param not int
12

和Java最大区别就是throws子句没出现在代码中。Kotlin不区分受检查异常和未受检查异常。不用指定函数抛出的异常，而且可以处理也可以不处理异常。