kotlin官方文档中文翻译(一)基础语法,习惯用法,编码习惯
2017-07-23 14:38
846 查看
基本语法
定义包
包的声明应处于源文件顶部:package my.demo import java.util.* // ……
目录与包的结构无需匹配:源代码可以在文件系统的任意位置。
定义函数
带有两个 Int 参数、返回 Int 的函数://sampleStart fun sum(a: Int, b: Int): Int { return a + b } //sampleEnd fun main(args: Array<String>) { print("sum of 3 and 5 is ") println(sum(3, 5)) }
将表达式作为函数体、返回值类型自动推断的函数:
//sampleStart fun sum(a: Int, b: Int) = a + b //sampleEnd fun main(args: Array<String>) { println("sum of 19 and 23 is ${sum(19, 23)}") }
函数返回无意义的值:
//sampleStart fun printSum(a: Int, b: Int): Unit { println("sum of $a and $b is ${a + b}") } //sampleEnd fun main(args: Array<String>) { printSum(-1, 8) }
Unit 返回类型可以省略:
//sampleStart fun printSum(a: Int, b: Int) { println("sum of $a and $b is ${a + b}") } //sampleEnd fun main(args: Array<String>) { printSum(-1, 8) }
定义局部变量
一次赋值(只读)的局部变量:fun main(args: Array<String>) { //sampleStart val a: Int = 1 // 立即赋值 val b = 2 // 自动推断出 `Int` 类型 val c: Int // 如果没有初始值类型不能省略 c = 3 // 明确赋值 //sampleEnd println("a = $a, b = $b, c = $c") }
可变变量:
fun main(args: Array<String>) { //sampleStart var x = 5 // 自动推断出 `Int` 类型 x += 1 //sampleEnd println("x = $x") }
注释
正如 Java 和 JavaScript,Kotlin 支持行注释及块注释。// 这是一个行注释 /* 这是一个多行的 块注释。 */
与 Java 不同的是,Kotlin 的块注释可以嵌套。
使用字符串模板
fun main(args: Array<String>) { //sampleStart var a = 1 // 模板中的简单名称: val s1 = "a is $a" a = 2 // 模板中的任意表达式: val s2 = "${s1.replace("is", "was")}, but now is $a" //sampleEnd println(s2) }
使用条件表达式
//sampleStart fun maxOf(a: Int, b: Int): Int { if (a > b) { return a } else { return b } } //sampleEnd fun main(args: Array<String>) { println("max of 0 and 42 is ${maxOf(0, 42)}") }
使用 if 作为表达式
//sampleStart fun maxOf(a: Int, b: Int) = if (a > b) a else b //sampleEnd fun main(args: Array<String>) { println("max of 0 and 42 is ${maxOf(0, 42)}") }
使用可空值及 null 检测
当某个变量的值可以为 null 的时候,必须在声明处的类型后添加 ? 来标识该引用可为空。
如果 str 的内容不是数字返回 null :
fun parseInt(str: String): Int? { // …… }
使用返回可空值的函数:
fun parseInt(str: String): Int? { return str.toIntOrNull() } //sampleStart fun printProduct(arg1: String, arg2: String) { val x = parseInt(arg1) val y = parseInt(arg2) // 直接使用 `x * y` 可能会报错,因为他们可能为 null if (x != null && y != null) { // 在空检测后,x 和 y 会自动转换为非空值(non-nullable) println(x * y) } else { println("either '$arg1' or '$arg2' is not a number") } } //sampleEnd fun main(args: Array<String>) { printProduct("6", "7") printProduct("a", "7") printProduct("a", "b") }
或者
fun parseInt(str: String): Int? { return str.toIntOrNull() } fun printProduct(arg1: String, arg2: String) { val x = parseInt(arg1) val y = parseInt(arg2) //sampleStart // …… if (x == null) { println("Wrong number format in arg1: '${arg1}'") return } if (y == null) { println("Wrong number format in arg2: '${arg2}'") return } // 在空检测后,x 和 y 会自动转换为非空值 println(x * y) //sampleEnd } fun main(args: Array<String>) { printProduct("6", "7") printProduct("a", "7") printProduct("99", "b") }
使用类型检测及自动类型转换
is 运算符检测一个表达式是否某类型的一个实例。 如果一个不可变的局部变量或属性已经判断出为某类型,那么检测后的分支中可以直接当作该类型使用,无需显式转换://sampleStart fun getStringLength(obj: Any): Int? { if (obj is String) { // `obj` 在该条件分支内自动转换成 `String` return obj.length } // 在离开类型检测分支后,`obj` 仍然是 `Any` 类型 return null } //sampleEnd fun main(args: Array<String>) { fun printLength(obj: Any) { println("'$obj' string length is ${getStringLength(obj) ?: "... err, not a str ing"} ") } printLength("Incomprehensibilities") printLength(1000) printLength(listOf(Any())) }
或者
//sampleStart fun getStringLength(obj: Any): Int? { if (obj !is String) return null // `obj` 在这一分支自动转换为 `String` return obj.length } //sampleEnd fun main(args: Array<String>) { fun printLength(obj: Any) { println("'$obj' string length is ${getStringLength(obj) ?: "... err, not a str ing"} ") } printLength("Incomprehensibilities") printLength(1000) printLength(listOf(Any())) }
甚至
//sampleStart fun getStringLength(obj: Any): Int? { // `obj` 在 `&&` 右边自动转换成 `String` 类型 if (obj is String && obj.length > 0) { return obj.length } return null } //sampleEnd fun main(args: Array<String>) { fun printLength(obj: Any) { println("'$obj' string length is ${getStringLength(obj) ?: "... err, is empty or not a string at all"} ") } printLength("Incomprehensibilities") printLength("") printLength(1000) }
使用 for 循环
fun main(args: Array<String>) { //sampleStart val items = listOf("apple", "banana", "kiwi") for (item in items) { println(item) } //sampleEnd }
或者
fun main(args: Array<String>) { //sampleStart val items = listOf("apple", "banana", "kiwi") for (index in items.indices) { println("item at $index is ${items[index]}") } //sampleEnd }
使用 while 循环
fun main(args: Array<String>) { //sampleStart val items = listOf("apple", "banana", "kiwi") var index = 0 while (index < items.size) { println("item at $index is ${items[index]}") index++ } //sampleEnd }
使用 when 表达式
//sampleStart fun describe(obj: Any): String = when (obj) { 1 -> "One" "Hello" -> "Greeting" is Long -> "Long" !is String -> "Not a string" else -> "Unknown" } //sampleEnd fun main(args: Array<String>) { println(describe(1)) println(describe("Hello")) println(describe(1000L)) println(describe(2)) println(describe("other")) }
使用区间(range)
使用 in 运算符来检测某个数字是否在指定区间内:fun main(args: Array<String>) { //sampleStart val x = 10 val y = 9 if (x in 1..y+1) { println("fits in range") } //sampleEnd }
检测某个数字是否在指定区间外
fun main(args: Array<String>) { //sampleStart 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") } //sampleEnd }
区间迭代:
fun main(args: Array<String>) { //sampleStart for (x in 1..5) { print(x) } //sampleEnd }
或数列迭代:
fun main(args: Array<String>) { //sampleStart for (x in 1..10 step 2) { print(x) } for (x in 9 downTo 0 step 3) { print(x) } //sampleEnd }
使用集合
对集合进行迭代:fun main(args: Array<String>) { val items = listOf("apple", "banana", "kiwi") //sampleStart for (item in items) { println(item) } //sampleEnd }
使用 in 运算符来判断集合内是否包含某实例:
fun main(args: Array<String>) { val items = setOf("apple", "banana", "kiwi") //sampleStart when { "orange" in items -> println("juicy") "apple" in items -> println("apple is fine too") } //sampleEnd }
使用 lambda 表达式来过滤(filter)和映射(map)集合:
fun main(args: Array<String>) { val fruits = listOf("banana", "avocado", "apple", "kiwi") //sampleStart fruits .filter { it.startsWith("a") } .sortedBy { it } .map { it.toUpperCase() } .forEach { println(it) } //sampleEnd }
习惯用法
创建 DTOs(POJOs/POCOs)
data class Customer(val name: String, val email: String)
会为 Customer 类提供以下功能:
所有属性的 getters (对于 var 定义的还有 setters)
equals()
hashCode()
toString()
copy()
所有属性的 component1() 、 component2() ……等等
函数的默认参数
fun foo(a: Int = 0, b: String = "") { …… }
过滤 list
val positives = list.filter { x -> x > 0 }
或者可以更短:
val positives = list.filter { it > 0 }
String 内插
println("Name $name")
类型判断
when (x) { is Foo //-> …… is Bar //-> …… else //-> …… }
遍历 map/pair型list
for ((k, v) in map) { println("$k -> $v") }
使用区间
for (i in 1..100) { …… } // 闭区间:包含 100 for (i in 1 until 100) { …… } // 半开区间:不包含 100 for (x in 2..10 step 2) { …… } for (x in 10 downTo 1) { …… } if (x in 1..10) { …… }
只读 list
val list = listOf("a", "b", "c")
只读 map
val map = mapOf("a" to 1, "b" to 2, "c" to 3)
访问 map
println(map["key"]) map["key"] = value
延迟属性
val p: String by lazy { // 计算该字符串 }
扩展函数
fun String.spaceToCamelCase() { …… } "Convert this to camelcase".spaceToCamelCase()
创建单例
object Resource { val name = "Name" }
If not null 缩写
val files = File("Test").listFiles() println(files?.size)
If not null and else 缩写
val files = File("Test").listFiles() println(files?.size ?: "empty")
if null 执行一个语句
val data = …… val email = data["email"] ?: throw IllegalStateException("Email is missing!")
if not null 执行代码
val data = …… data?.let { …… // 代码会执行到此处, 假如data不为null }
返回when表达式
fun transform(color: String): Int { return when (color) { "Red" -> 0 "Green" -> 1 "Blue" -> 2 else -> throw IllegalArgumentException("Invalid color param value") } }
“try/catch”表达式
fun test() { val result = try { count() } catch (e: ArithmeticException) { throw IllegalStateException(e) } // 使用 result }
“if”表达式
fun foo(param: Int) { val result = if (param == 1) { "one" } else if (param == 2) { "two" } else { "three" } }
返回类型为 Unit 的方法的 Builder 风格用法
fun arrayOfMinusOnes(size: Int): IntArray { return IntArray(size).apply { fill(-1) } }
单表达式函数
fun theAnswer() = 42
等价于
fun theAnswer(): Int { return 42 }
单表达式函数与其它惯用法一起使用能简化代码,例如和 when 表达式一起使用:
fun transform(color: String): Int = when (color) { "Red" -> 0 "Green" -> 1 "Blue" -> 2 else -> throw IllegalArgumentException("Invalid color param value") }
对一个对象实例调用多个方法 ( with )
class Turtle { fun penDown() fun penUp() fun turn(degrees: Double) fun forward(pixels: Double) } val myTurtle = Turtle() with(myTurtle) { // 画一个 100 像素的正方形 penDown() for(i in 1..4) { forward(100.0) turn(90.0) } penUp() }
Java 7 的 try with resources
val stream = Files.newInputStream(Paths.get("/some/file.txt")) stream.buffered().reader().use { reader -> println(reader.readText()) }
对于需要泛型信息的泛型函数的适宜形式
// public final class Gson { // …… // public <T> T fromJson(JsonElement json, Class<T> classOfT) throws JsonSyntaxExc eption { // …… inline fun <reified T: Any> Gson.fromJson(json): T = this.fromJson(json, T::class.java)
使用可空布尔
val b: Boolean? = …… if (b == true) { …… } else { // `b` 是 false 或者 null }
编码规范
命名风格
如果拿不准的时候,默认使用Java的编码规范,比如:使用驼峰法命名(并避免命名含有下划线)
类型名以大写字母开头
方法和属性以小写字母开头
使用 4 个空格缩进
公有函数应撰写函数文档,这样这些文档才会出现在 Kotlin Doc 中
冒号
类型和超类型之间的冒号前要有一个空格,而实例和类型之间的冒号前不要有空格:interface Foo<out T : Any> : Bar { fun foo(a: Int): T }
Lambda表达式
在lambda表达式中, 大括号左右要加空格,分隔参数与代码体的箭头左右也要加空格 。lambda表达应尽可能不要写在圆括号中
list.filter { it > 10 }.map { element -> element * 2 }
在非嵌套的短lambda表达式中,最好使用约定俗成的默认参数 it 来替代显式声明参数名 。
在嵌套的有参数的lambda表达式中,参数应该总是显式声明。
类头格式化
有少数几个参数的类可以写成一行:class Person(id: Int, name: String)
具有较长类头的类应该格式化,以使每个主构造函数参数位于带有缩进的单独一行中。 此外,右括号应该另起一行。如果我们使用继承,那么超类构造函数调用或者实现接口列表应位于与括号相同的行上:
class Person( id: Int, name: String, surname: String ) : Human(id, name) { // …… }
对于多个接口,应首先放置超类构造函数调用,然后每个接口应位于不同的行中:
class Person( id: Int, name: String, surname: String ) : Human(id, name), KotlinMaker { // …… }
构造函数参数可以使用常规缩进或连续缩进(双倍的常规缩进)。
Unit
如果函数返回 Unit 类型,该返回类型应该省略:fun foo() { // 省略了 ": Unit" }
函数还是属性
很多场合无参的函数可与只读属性互换。 尽管语义相近,也有一些取舍的风格约定。底层算法优先使用属性而不是函数:不会抛异常
O(1) 复杂度
计算廉价(或缓存第一次运行)
不同调用返回相同结果
相关文章推荐
- kotlin官方文档中文翻译(三) 类和对象
- Kotlin习惯用语和编码风格[转自Kotlin中文文档]
- hadoop2官方文档中文翻译---索引
- velocity基本语法--官方文档翻译
- odoo8 官方web客户端开发文档翻译3---Widgets Basics(基础窗口组件)
- Redis 3.0中文官方文档翻译计划(3)
- TensorFlow 官方文档 Programmer's Guide 中文翻译 —— 引言
- GitLab 官方安装文档中文翻译
- SWFUpload 2.5.0版 官方说明文档 中文翻译版
- urllib2模块中文翻译与学习 - Python 2.7.8官方文档
- Tornado官方文档,中文翻译(一)
- React-navigation 官方文档中文翻译(二) Nesting Navigators
- Dojo1.11官方教程文档翻译(4.5)使用声明式语法
- EXTJS4官方文档翻译系列一:类系统和编码规范
- Sencha Cmd 6 和 Ext JS 6 指南文档(部分官方文档中文翻译)
- Kotlin官方文档翻译—概述
- RxJava 官方文档中文翻译
- Android Design 安卓官方设计文档中文翻译——第一部分:引导
- OAuth2.0官方文档中文翻译
- React-navigation 官方文档中文翻译(一) Hello Mobile Navigation