标签：
包说明应该在源文件的顶部：
1 package my.demo 2 import java.util.* 3 // …
并不要求包与目录匹配：源文件可以在文件系统中的任意地方。
查看：包（2.2）
函数带有Int类型参数，并返回Int类型值：
1 fun sum(a: Int, b: Int): Int { 2 return a+b 3 }
函数体可以是表达式，并可从中推断出返回值类型：
1 fun sum(a: Int, b: Int) = a + b
函数可返回无意义的值：
1 fun pringSum(a: Int, b: Int): Unit { 2 print(a + b) 3 }
Unit 返回值类型可以省略：
1 public fun printSum(a: Int, b: Int) { 2 print(a + b) 3 }
查看：函数（4.1）
一次赋值（只读）局部变量：
1 val a: Int = 1 2 val b: = 1 // 推测为Int 类型 3 val c: Int // 没有初始化就要求说明类型 4 c = 1 // 明确赋值
可变变量：
1 var x = 5 // 推测为Int类型 2 x += 1
查看：属性和域（3.2）
1 fun main(args: Array<String>) { 2 if (args.size == 0) return 3 4 print(“First argument: ${args[0]}”) 5 }
查看：串模板（2.1.5.2）
1 fun max(a: Int, b: Int): Int { 2 if (a > b) 3 return a 4 else 5 return b 6 }
使用if表达式：
1 fun max(a: Int, b: Int) = if (a > b) a else b
查看：if表达式（2.3.1）
当null值可能出现时，引用必须明确标记出可null值。
如果str没有保存一整数，则返回 null：
1 fun parseInt(str: String): Int? { 2 // … 3 }
用函数返回可null值：
1 fun main(args: Array<String>) { 2 if (args.size < 2) { 3 print("Two integers expected") 4 return 5 } 6 7 val x = parseInt(args[0]) 8 val y = parseInt(args[1]) 9 10 // 由于x、y是null，所以使用 x * y 将产生错误。 11 if (x != null && y != null) { 12 // 在null检查后，x 和 y 自动地配置（cast）到非可null 13 print(x * y) 14 } 15 }
或
1 // ... 2 if (x == null) { 3 print("Wrong number format in ‘${args[0]}‘") 4 return 5 } 6 if (y == null) { 7 print("Wrong number format in ‘${args[1]}‘") 8 return 9 } 10 11 // 在null检查后，x 和 y 自动地配置（cast）到非可nul 12 print(x * y)
查看：Null安全（5.7）
is操作符检查表达式是否类型实例。如果对不可变局部的变量或属性进行特定类型检查了，就不需要明确的类型转换。
1 fun getStringLength(obj: Any): Int? { 2 if (obj is String) { 3 // 在这个分支中，`obj`自动转换到`String` 4 return obj.length 5 } 6 7 // 在类型检查分支之外，`obj`仍然是`Any`类型 8 return null 9 }
或
1 fun getStringLength(obj: Any): Int? { 2 if (obj !is String) 3 return null 4 5 // 在这个分支上，`obj`自动转换到`String` 6 return obj.length 7 }
甚至
1 fun getStringLength(obj: Any): Int? { 2 // 在`&&`右手边条件成立时，`obj`自动转换到`String` 3 if (obj is String && obj.length > 0) 4 return obj.length 5 6 return null 7 }
查看：类（3.1.1）和类型转换（5.3）
1 fun main(args: Array<String>) { 2 for (arg in args) 3 print(arg) 4 }
或
1 for (i in args.indices) 2 print(args[i])
查看：for循环（2.3.3）
1 fun main(args: Array<String>) { 2 var i = 0 3 while (i < args.size) 4 print(args[i++]) 5 }
查看：while循环（2.3.4）
1 fun cases(obj: Any) { 2 when (obj) { 3 1 -> print("One") 4 "Hello" -> print("Greeting") 5 is Long -> print("Long") 6 !is String -> print("Not a string") 7 else -> print("Unknown") 8 } 9 }
查看：when表达式（2.3.2）
使用in操作符检查一个数字是否在一个范围内：
1 if (x in 1..y-1) 2 print("OK")
检查一个数字是否超出范围：
1 if (x !in 0..array.lastIndex) 2 print("Out")
遍历整个范围：
1 for (x in 1..5) 2 print(x)
查看：范围（5.2）
遍历一个集合：
1 for (name in names) 2 println(name)
使用in操作符检查一个集合是否一个对象：
1 if (text in names) // 调用names.contains(text) 2 print("Yes")
使用Lambda表达式过滤和映射集合：
1 names 2 .filter { it.startsWith("A") } 3 .sortedBy { it } 4 .map { it.toUpperCase() } 5 .forEach { print(it) }
查看：高阶函数和Lambda表达式（4.2）
这里随机收集了一些经常在Kotlin中使用的习惯用语。如果你有喜欢用于，也请奉献出来。申请内容合并。
1 data class Customer(val name: String, val email: String)
提供带有下列功能的Customer类：
——所有属性的getter (和var的setter)
—— equals()
—— hashCode()
—— toString()
—— copy()
——所有属性的component1()，component2()，…（查看：数据类（3.6））
1 fun foo(a: Int = 0, b: String = “”) {…}
1 val positives = list.filter {x -> x > 0}
或是更简洁写法：
1 val positives = list.filter {it > 0}
1 println(“Name $name”)
1 when (x) { 2 is Foo -> … 3 is Bar -> … 4 else -> … 5 }
1 for ((k, v) in map) { 2 println(“$k -> $v”) 3 }
k，v可以调用任意事。
1 for (i in 1 .. 100) { … } 2 3 for (x in 2 .. 10) { … }
1 val list = listOf(“a”, “b”, “c”)
1 val map = mapOf("a" to 1, "b" to 2, "c" to 3)
1 println(map["key"]) 2 map["key"] = value
1 val p: String by lazy { 2 3 // 计算串 4 5 }
1 fun String.spaceToCamelCase() { ... } 2 3 "Convert this to camelcase".spaceToCamelCase()
1 object Resource { 2 3 val name = "Name" 4 5 }
1 val files = File("Test").listFiles() 2 3 println(files?.size)
1 val files = File("Test").listFiles() 2 3 println(files?.size ?: "empty")
1 val data = ... 2 3 val email = data["email"] ?: throw IllegalStateException("Email is missing!")
1 val data = ... 2 3 data?.let { 4 5 ... // 如果非null，执行这段代码块 6 7 }
1 fun transform(color: String): Int { 2 3 return when (color) { 4 "Red" -> 0 5 "Green" -> 1 6 "Blue" -> 2 7 else -> throw IllegalArgumentException("Invalid color param value") 8 } 9 10 }
1 fun test() { 2 3 val result = try { 4 5 count() 6 7 } catch (e: ArithmeticException) { 8 9 throw IllegalStateException(e) 10 11 } 12 // 与result一起工作 13 }
1 fun foo(param: Int) { 2 3 val result = if (param == 1) { 4 5 "one" 6 7 } else if (param == 2) { 8 9 "two" 10 11 } else { 12 13 "three" 14 15 } 16 }
1 fun arrayOfMinusOnes(size: Int): IntArray { 2 return IntArray(size).apply { fill(-1) } 3 }
1 fun theAnswer() = 42
这可以与其他习惯用语有效的组合在一起，简化代码。如：与when表达式：
1 fun transform(color: String): Int = when (color) { 2 "Red" -> 0 3 "Green" -> 1 4 "Blue" -> 2 5 else -> throw IllegalArgumentException("Invalid color param value") 6 }
1 class Turtle { 2 fun penDown() 3 fun penUp() 4 fun turn(degrees: Double) 5 fun forward(pixels: Double) 6 } 7 8 val myTurtle = Turtle() 9 10 with(myTurtle) { //绘制100pix 正方形 11 penDown() 12 13 for(i in 1..4) { 14 forward(100.0) 15 turn(90.0) 16 } 17 penUp() 18 }
1 val stream = Files.newInputStream(Paths.get("/some/file.txt")) 2 3 stream.buffered().reader().use { reader -> 4 println(reader.readText()) 5 }
这里是一些Kotlin开发语言的目前编码风格。
如有疑问，默认的是Java编码约定，如：
——名称用驼峰式拼写法（并避免在名称中用下划线）
——以大写字母开始
——方法和属性名称以小写字母开始
——用4空格缩进
—— public函数应有文档化，使其能在Kotlin文档中显示
在用冒号分隔类型和子类型时，冒号前需要添加一个空格；而在分隔实例与类型时，冒号前就不需要空格：
1 interface Foo<out T : Any> : Bar { 2 fun foo(a: Int): T 3 }
在Lambda表达式中，空格应该用在花括号两边，以及将参数与函数体分隔的箭头两侧。如果可能，Lambda表达式应该在括号外传递。
1 list.filter { it > 10 }.map { element -> element * 2 }
在简写且没有嵌套的Lambda表达式中，推荐用it约定替代显式的参数申明。而在带有参数的嵌套Lambda表达式中，应该总是显式申明参数。
如果函数返回Unit类型，则返回类型应该省略：
1 fun foo() { // 这里省略了“: Unit”。 2 3 }
标签：
原文地址：http://www.cnblogs.com/figozhg/p/5107750.html
