包括：
1. kotlin代码组织结构
2. when语法
3. 循环迭代语法
4. try表达式
1. 代码组织结构
和JAVA一样，kotlin也可以使用"包"来组织代码文件，和JAVA的语法一样，使用package定义包，使用import导入包
但是也有许多不同，例如JAVA中通常包名就对应了类文件的存放路径，比如package cn.java.ch1下有一个User类，那么
对应的Java源文件名应该叫User，位于cn/java/ch1这个文件夹下。但是kotlin没有这个要求，文件名你可以随便起。
文件也可以随便放，文件内想定义几个类，或者是没有类，直接定义顶级函数，都随你。基本没有任何限制
同一个包下的定义的函数，属性等可以直接在其他文件中使用，不同包的如果需要引用，则需要使用import语句，语法和JAVA一样
通过一个例子来看一下：
package action.kotlin.ch2
import java.util.*
/**
* Created by user on 2017/10/9.
*/
class Rectangle(val height: Int, val width: Int) {
val isSquare: Boolean
get() = height == width
}
fun createRandomRectangle(): Rectangle {
//使用Java的Random类，需要导包
val random = Random()
return Rectangle(random.nextInt(), random.nextInt())
}
fun main(args: Array<String>) {
val rectangle = createRandomRectangle()
val square = rectangle.isSquare
println(square)
}
上边的代码中，函数createRandomRectangle使用了Random类，需要导入java.util包
在另外一个包下新建文件，内容如下：
package action.kotlin.ch2.example
import action.kotlin.ch2.Rectangle
/**
* Created by user on 2017/10/9.
*/
fun main(args: Array<String>) {
val rectangle = Rectangle(20, 20)
println(rectangle.isSquare)
}
这个文件和上边的文件不在同一个包，因此用到另一个包中的类时，需要使用import语句进行导入。同样可以导入另一个文件的顶级函数
用法和JAVA基本是一致的。
2. when语法和枚举
首先建个文件，声明一个枚举类型，来说明when语法的使用
enum class Color(val r: Int, val g: Int, val b: Int) {
RED(255, 0, 0), ORANGE(255, 165, 0),
YELLOW(255, 255, 0), GREEN(0, 255, 0), BLUE(0, 0, 255),
INDIGO(75, 0, 130), VIOLET(238, 130, 238);
//fun rgb() = (r * 256 + g) * 256 + b
}
fun getMnemonic(color: Color) =
when (color) {
Color.RED -> "Richard"
Color.ORANGE -> "Of"
Color.YELLOW -> "York"
Color.GREEN -> "Gave"
Color.BLUE -> "Battle"
Color.INDIGO -> "In"
Color.VIOLET -> "Vain"
}
fun main(args: Array<String>) {
val color = getMnemonic(Color.BLUE)
println(color)
}
enum是关键字，声明枚举类型使用的。类名后边的括号中是构造参数，先明白那个是构造就够了，后续的文章中关于类的学习部分会详细说的
这里的意思就是声明了一些枚举值，并使用构造函数中的参数来赋值枚举项
getMnemonic函数，需要一个Color类型的枚举值，根据枚举值不同返回不同的字符串给调用方
main函数调用getMnemonic函数，传递Color.BLUE，函数会返回对应的Battle，这里主要看when的语法结构
when后的括号中是你要判断的参数，when的大括号体内就是一个个的分支判断了。所以不用when，我们也可以使用if判断来代替。
至于箭头语法，相信用过JDK8的应该不陌生，就是所谓的lambada表达式了。整个语法和JAVA中的switch case很像，但是明显的区别就是when语法不需要break
如果现在我想让参数为Color.BLUE和或者Color.GREEN时，返回一样的字符串，该如何做？很简单
Color.GREEN, Color.BLUE -> "Gave"
改成这样即可，多个判断分支使用逗号隔开，就是这么简单
去掉枚举的类名前缀，直接使用枚举常量：
如果不想带Color前缀，也简单，首先导入枚举类。导入语句如下：
import action.kotlin.ch2.enumtest.Color.*
然后when的判断中直接写：
GREEN, BLUE -> "Gave"
无需再带Color前缀了。
关于when的分支判断，还有一些组合使用方式，这里不多说了，以后用到会介绍
3. 迭代循环：
kotlin支持while和do while循环，这两种形式的循环迭代和JAVA中的写法没有区别，参考JAVA的即可
3.1 范围操作符
kotlin中有一个名为范围操作符的东西。写作：.. 两个点，例如我想声明一个变量，这个变量包含数字1到10，可以如下声明：
val oneToTen = 1 .. 10
接着可以使用for，while等循环语句来迭代访问，以for循环为例：
for(i in oneToTen) println(i)
上边for循环就是kotlin中for循环的语法，使用 for(var in collections)的语法来进行for迭代
3.2 downTo语法：
kotlin提供了downTo关键字用来反向迭代，例子：
for(i in 100 downTo 1 step 1) print("$i ")
反向迭代一百次，每次输出迭代的值，downTo指定从100迭代到的下限值，step指定了迭代的步阶
4. kotlin中的异常：
4.1 抛出异常：
fun main(args: Array<String>) {
test(500)
}
fun test(percentage: Int) {
if (percentage !in 0..100) {
throw IllegalArgumentException(
"A percentage value must be between 0 and 100: $percentage")
}
}
上述代码的test函数检测参数是否在0-100之间，如果不是抛出异常，可以直接使用java中的异常类。语言和java也没什么不同
4.2 try catch finally
fun main(args: Array<String>) {
val res = caculate(7, 0)
println(res)
}
fun caculate(one: Int, two: Int): Int {
var result: Int = 0
try {
result = one / two
} catch (e: ArithmeticException) {
println("Can't be divided by Zero. $e")
}finally {
//do something
}
return result
}
这个例子函数计算两个数相除，除0引发异常，捕获并作相应处理，和JAVA中也并没有什么不同，唯一的区别就是e: Exception
这里遵循kotlin声明变量的语法：变量名: 类型
