├── .gitignore
├── README.md
├── index.html
├── kotlin-tutorial-basic.md
├── notes.md
├── notes.pdf
├── remark-latest.min.js
├── slides.md
└── src
└── com
└── mcxiaoke
└── kotlin
├── Basics.kt
├── ClassesAndInheritance.kt
├── DataClasses.kt
├── Delegation.kt
├── Extensions.kt
├── FunctionsAndLambdas.kt
├── Generics.kt
├── GettingStarted.kt
├── InterfacesAndVisibilityModifiers.kt
├── Interoperability.kt
├── NestedClassesAndEnum.kt
├── Objects.kt
├── Others.kt
├── PropertiesAndFields.kt
├── builders
└── TypeSafeBuilders.kt
└── stdlib
└── Core.kt
/.gitignore:
--------------------------------------------------------------------------------
1 | .idea/
2 | out/
3 | build/
4 | classes/
5 | *.iml
6 | .gradle/
7 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # Kotlin中文教程
2 |
3 | * [Kotlin入门和使用讲稿(PPT)](slides.md)
4 | * [Kotlin入门和使用讲稿(文本)](notes.md)
5 | * [我的学习笔记: Kotlin教程（入门篇）](kotlin-tutorial-basic.md)
6 | * [Kotlin: Java 6 废土中的一线希望](https://realm.io/cn/news/droidcon-michael-pardo-kotlin/)
7 | * [Kotlin: 高级Android开发](https://realm.io/cn/news/oredev-jake-wharton-kotlin-advancing-android-dev/)
8 | * [为什么说Kotlin值得一试](http://mp.weixin.qq.com/s?__biz=MzA3NTYzODYzMg==&mid=404087761&idx=1&sn=d80625ee52f860a7a2ed4c238d2151b6)
9 | * [Kotlin中文站](http://tanfujun.com/kotlin-web-site-cn/)
10 | * [Kotlin官方文档翻译系列（简书）](http://www.jianshu.com/notebooks/2822252/latest)
11 | * [给Android开发者的Kotlin教程](https://github.com/wangjiegulu/kotlin-for-android-developers-zh/blob/master/SUMMARY.md)
12 |
13 | # Awesome-Kotlin
14 |
15 | * [https://github.com/mcxiaoke/awesome-kotlin](https://github.com/mcxiaoke/awesome-kotlin)
16 |
--------------------------------------------------------------------------------
/index.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 | Kotlin
5 |
6 |
80 |
81 |
82 |
84 |
90 |
91 |
92 |
93 |
--------------------------------------------------------------------------------
/kotlin-tutorial-basic.md:
--------------------------------------------------------------------------------
1 | # Kotlin教程：入门篇
2 |
3 | ## Kotlin介绍
4 |
5 | 官网：
6 |
7 | Kotlin是JetBrains在JVM上推出的新一代静态类型编程语言，具备泛型，高阶函数，Lambda，闭包，代理属性等大多数现代编程语言的特性，支持可空类型，语法简洁。Kotlin生来就是为了弥补Java缺失的现代语言的特性，并极大的简化了代码，使得开发者可以编写尽量少的代码，非常适合于Android开发，推荐所有Android开发者学习。
8 |
9 | ### Kotlin安装
10 |
11 | 可以下载单独的Kotlin编译工具，建议直接下载 IntelliJ IDEA 15，然后安装Kotlin插件，创建新项目的时候选择Kotlin支持即可
12 |
13 | 单独安装Kotlin的方法，Unix系列的系统可以使用SDKMAN安装，方法如下：
14 | ```shell
15 | curl -s get.sdkman.io | bash
16 | sdk install kotlin
17 | ```
18 |
19 | OS X系统可以使用Homebrew安装，如下：
20 |
21 | ```shell
22 | brew update
23 | brew install kotlin
24 | ```
25 |
26 | Kotlin版的Hello, World代码如下：
27 |
28 | ```kotlin
29 | fun main(args: Array) {
30 | println("Hello, World!")
31 | }
32 | ```
33 | 如果使用IDEA，点击编辑器窗口main函数左边的标记可以运行代码，命令行需要这样做：
34 |
35 | ```shell
36 | kotlinc hello.kt -include-runtime -d hello.jar
37 | java -jar hello.jar
38 | ```
39 |
40 | ## 基本语法
41 |
42 | 下面开始介绍Kotlin的基本语法
43 |
44 | ### 定义包
45 |
46 | Kotlin和Java一样使用package组织代码，package定义必须放在源文件的顶部，如
47 |
48 | ```kotlin
49 | package com.mcxiaoke.koi
50 | import java.util.*
51 | ```
52 |
53 | import语句也和Java类似
54 |
55 | ```kotlin
56 | import foo.Bar
57 | import foo.*
58 | ```
59 |
60 | 还可以使用`as`关键字解决命名冲突
61 |
62 | ```kotlin
63 | import foo.Bar // Bar is accessible
64 | import bar.Bar as bBar // bBar stands for 'bar.Bar'
65 | ```
66 | import还可以用于导入顶层作用域（不在任何类的内部）定义的函数和属性，可以导入对象内的函数和属性，导入enum常量
67 |
68 | 和Java不同的是，package定义不需要和磁盘上的目录结构保持一致，源文件可以放在任何地方，但是建议保持一致
69 |
70 | ### 定义函数
71 |
72 | Kotlin的main函数是这样的，和Java差不多，Kotlin的函数默认是public的
73 | ```kotlin
74 | fun main(args: Array) {
75 | println("hello, world")
76 | }
77 | ```
78 |
79 | Kotlin的语句不需要分号做结束符，函数用`fun`关键字，个人觉得用`func`更符合习惯，或者用`function`也不错，用`fun`有点不伦不类的
80 |
81 | 下面是有两个Int参数，返回值为Int类型的函数：
82 | ```kotlin
83 | fun sum(a: Int, b: Int): Int {
84 | return a + b
85 | }
86 | ```
87 |
88 | 下面的函数使用一个表达式作为函数体，自动推断返回类型
89 | ```kotlin
90 | fun sum(a: Int, b: Int) = a + b
91 | ```
92 | 如果函数体足够简单，只需要一个表达式，就可以省略大括号，直接将表达式放在等于号 = 后面，就像上面的sum函数一样
93 |
94 | 从上面的例子可以看出，Kotlin的类型声明是放在变量名后面，用冒号:分隔，函数的返回类型也是放在函数声明的后面，大括号之前，也是用冒号:分隔
95 |
96 | 下面的函数的 返回类型为Unit，相当于Java里的Void，即没有返回值，Unit可以省略：
97 |
98 | ```kotlin
99 | fun printSum(a: Int, b: Int): Unit {
100 | print(a + b)
101 | }
102 | ```
103 |
104 | 省略Unit后
105 |
106 | ```kotlin
107 | fun printSum(a: Int, b: Int) {
108 | print(a + b)
109 | }
110 | ```
111 |
112 | ### 定义局部变量
113 |
114 | 定义一次性赋值（只读）的局部变量使用`val`关键字
115 |
116 | ```kotlin
117 | fun localVariables() {
118 | val a: Int = 1
119 | val b = 1 // 自动推导类型为Int
120 | val c: Int // 没有初始值时需要显式制定变量类型
121 | c = 1 // 初始复制
122 | // c = 2 这个是错误的，val定义的只读变量不可重新赋值
123 | }
124 | ```
125 |
126 | `val`大致相当于Java里的final，C/C++里的const，Swift里的let，使用val定义的是不可变量，这种类型的变量有很多优点，后面会提到
127 |
128 | 定义可重复赋值（读写）的变量使用`var`关键字
129 |
130 | ```kotlin
131 | fun mutableVariables() {
132 | var x = 5 // 类型自动推导为Int
133 | x += 1
134 | }
135 | ```
136 |
137 | `var`定义的变量就是大部分编程语言里的普通变量，可读写，可重新赋值，Swift也是使用`var`
138 |
139 |
140 | ### 字符串模板
141 |
142 | Kotlin支持许多动态语言早就支持的字符串模板，与Groovy和Swift类似
143 |
144 | ```kotlin
145 | fun strTemplate() {
146 | val name = "Miufox"
147 | val age = 6
148 | print("I have a cat, name is $name age:$age")
149 |
150 | val a:Int = 2016
151 | val b = 40
152 | print("sum($a+$b) = ${a+b}")
153 |
154 | var args = arrayOf("Cat", "Dog", "Rabbit")
155 | print("Hello ${args[0]}")
156 | }
157 | ```
158 |
159 | 在字符串模板中可以使用变量和表达式，表达式需要使用${}包裹，简单的变量可以省略大括号
160 |
161 | ### 条件表达式
162 |
163 | Kotlin中的if语句和Java类似
164 |
165 | ```kotlin
166 | fun max(a: Int, b: Int): Int {
167 | if (a > b)
168 | return a
169 | else
170 | return b
171 | }
172 | ```
173 |
174 | 使用if表达式，上面的函数可以简化成这样
175 |
176 | ```kotlin
177 | fun max(a: Int, b: Int) = if (a > b) a else b
178 | ```
179 |
180 | ### 空值检查
181 |
182 | Kotlin中，如果一个值可能为null就必须显式标示为`nullable`，使用问号?，下面的函数返回可能为null
183 |
184 | ```kotlin
185 | fun parseInt(str: String): Int? {
186 | // ...
187 | }
188 | ```
189 |
190 | 使用返回值可能为null的函数
191 |
192 | ```kotlin
193 | fun testInt(args: Array) {
194 | if (args.size < 2) {
195 | print("Two integers expected")
196 | return
197 | }
198 | val x = parseInt(args[0]) // Int?
199 | val y = parseInt(args[1])//Int?
200 | if (x != null && y != null) {
201 | // null检查之后，这里自动类型转换为非空值
202 | print(x * y)
203 | }
204 | }
205 |
206 | ```
207 |
208 | 详细的说明可以参考空值安全章节
209 |
210 | ### 类型检查和自动转换
211 |
212 | `is`操作符用于检查某个对象是否是指定的类型，检查完成后自动转换为指定的类型，无需再显式转换
213 |
214 | ```kotlin
215 | fun getStringLength(obj: Any): Int? {
216 | if (obj is String) {
217 | // `obj` 自动转换为 `String`
218 | return obj.length
219 | }
220 | // 在类型检查的if分支外 obj依然是 `Any` 类型
221 | return null
222 | }
223 | ```
224 |
225 | 下面的例子可能更清晰一些
226 |
227 | ```kotlin
228 | fun getStringLength(obj: Any): Int? {
229 | if (obj !is String)
230 | return null
231 | // `obj` 自动转换为 `String` 类型
232 | return obj.length
233 | }
234 | ```
235 |
236 | 甚至可以这样写
237 |
238 | ```kotlin
239 | fun getStringLength(obj: Any): Int? {
240 | // && 右边 obj 已经自动转换为 String 类型
241 | if (obj is String && obj.length > 0)
242 | return obj.length
243 |
244 | return null
245 | }
246 | ```
247 |
248 | ### 循环语句
249 |
250 | for循环使用in操作符，相当于Java的冒号
251 |
252 | ```kotlin
253 | fun forLoop1(args: Array) {
254 | for (arg in args) {
255 | print(arg)
256 | }
257 | }
258 | ```
259 |
260 | 或者这样写，遍历数组，后面会看到更优雅的方法
261 |
262 | ```kotlin
263 | fun forLoop2(args: Array) {
264 | for (i in args.indices) {
265 | print(args[i])
266 | }
267 | }
268 | ```
269 |
270 | while循环和Java类似
271 |
272 | ```kotlin
273 | fun whileLoop1(args: Array) {
274 | var i = 0
275 | while (i < args.size)
276 | print(args[i++])
277 | }
278 | ```
279 |
280 | Kotlin增加的Java没有的when表达式，支持强大的类型匹配功能，这里是一个简单的例子
281 |
282 | ```kotlin
283 | fun cases(obj: Any) {
284 | when (obj) {
285 | 1 -> print("One")
286 | "Hello" -> print("Greeting")
287 | is Long -> print("Long")
288 | !is String -> print("Not a string")
289 | else -> print("Unknown")
290 | }
291 | }
292 | ```
293 |
294 | Range表达式
295 |
296 | ```kotlin
297 | fun range1(x: Int, y: Int) {
298 | if (x in 1..y - 1) {
299 | print("OK")
300 | }
301 | }
302 | ```
303 |
304 | 另一个例子
305 |
306 | ```kotlin
307 | fun range2(x: Int, array: Array) {
308 | if (x !in 0..array.lastIndex) {
309 | print("Out")
310 | }
311 | }
312 |
313 | fun range3(x: Int) {
314 | if (x in 1..5) {
315 | print(x)
316 | }
317 | }
318 | ```
319 |
320 | 使用集合的简单例子，Kotlin支持Java的集合类型，但比Java强大很多
321 |
322 | ```kotlin
323 | // 集合类型
324 | fun names1(names: Array) {
325 | for (name in names) {
326 | println(name)
327 | }
328 | }
329 |
330 | // 检查是否包含
331 | fun names2(text: String, names: Array) {
332 | if (text in names) {
333 | print("Yes")
334 | }
335 | }
336 |
337 | // 使用lambda表达式
338 | fun names3(names: Collection) {
339 | names.filter { it.startsWith("A") }
340 | .sortedBy { it }
341 | .map { it.toUpperCase() }
342 | .forEach { print(it) }
343 | }
344 | ```
345 |
346 | ## 数据类型
347 |
348 | ### 数字类型
349 |
350 | Kotlin提供下列内置类型，与Java的基本数据类型是对应的
351 | ```
352 | Type Bit width
353 | Double 64
354 | Float 32
355 | Long 64
356 | Int 32
357 | Short 16
358 | Byte 8
359 | ```
360 |
361 | ### 字面量
362 |
363 | 十进制: 123
364 | Long类型 以L结尾: 123L
365 | 十六进制: 0x0F
366 | 二进制: 0b00001011
367 | 注意：不支持八进制
368 |
369 | 浮点数默认是Double: 123.5, 123.5e10
370 | Float类型以F或f结尾: 123.5f
371 |
372 | ### 类型转换
373 |
374 | Int类型不是Long类型的子类型，下面的代码无法通过编译
375 | ```kotlin
376 | fun conversation1() {
377 | val a: Int? = 1 // Int 包装类型 (java.lang.Integer)
378 | // val b: Long? = a // Long 包装类型 (java.lang.Long)
379 | // print(a == b) // 结果是false，因为两者类型不一样
380 | val b: Byte = 1 // OK, literals are checked statically
381 | // val i: Int = b // ERROR
382 | val i: Int = b.toInt() // OK: 显式转换
383 | }
384 | ```
385 |
386 | 所有的数字类型都支持下列转换
387 |
388 | ```
389 | oByte(): Byte
390 | toShort(): Short
391 | toInt(): Int
392 | toLong(): Long
393 | toFloat(): Float
394 | toDouble(): Double
395 | toChar(): Char
396 | ```
397 |
398 | ### 算术操作
399 |
400 | Kotlin支持标准的算术操作符，还支持位操作
401 |
402 | ```
403 | shl(bits) – signed shift left (Java’s <<)
404 | shr(bits) – signed shift right (Java’s >>)
405 | ushr(bits) – unsigned shift right (Java’s >>>)
406 | and(bits) – bitwise and
407 | or(bits) – bitwise or
408 | xor(bits) – bitwise xor
409 | inv() – bitwise inversion
410 | ```
411 |
412 | ### 字符
413 |
414 | 字符是Char类型，不能当作数字用，使用单引号包裹
415 | ```kotlin
416 | fun testChar(c: Char) {
417 | // if (c == 1) { // ERROR: incompatible types
418 | // ...
419 | // }
420 | }
421 | ```
422 |
423 | ### 布尔值
424 | 两个值：true和false， &&和||和!三种操作
425 |
426 | ### 数组
427 | Kotlin的数组是Array类型，有get和set方法[]，size属性
428 |
429 | ```kotlin
430 | //数组的部分接口
431 | class Array private constructor() {
432 | val size: Int
433 | fun get(index: Int): T
434 | fun set(index: Int, value: T): Unit
435 | fun iterator(): Iterator
436 | // ...
437 | }
438 |
439 | // 创建数组
440 | fun testArray1() {
441 | val asc = Array(5, { i -> (i * i).toString() })
442 | }
443 |
444 | // Kotlin的数组是不可变的
445 | // 不允许将Array赋值给Array
446 | // Kotlin还有ByteArray, ShortArray, IntArray等类型
447 | fun testArray2() {
448 | val x: IntArray = intArrayOf(1, 2, 3)
449 | x[0] = x[1] + x[2]
450 | }
451 | ```
452 |
453 | ### 字符串
454 | 和Java一样，Kotlin的字符串是不可变的，可以通过[i]访问单个字符
455 |
456 | ```kotlin
457 | fun testString1(str: String) {
458 | for (c in str) {
459 | println(c)
460 | }
461 | }
462 | ```
463 |
464 | 字符串字面量
465 | ```kotlin
466 | fun testString2() {
467 | val s = "Hello, world!\n"
468 | // 或者三引号
469 | val text = """
470 | for (c in "foo")
471 | print(c)
472 | """
473 | }
474 | ```
475 |
476 | 字符串模板
477 | ```kotlin
478 | fun stringTemplate() {
479 | val i = 10
480 | val s = "i = $i" // evaluates to "i = 10"
481 | val x = "abc"
482 | val str = "$x.length is ${x.length}" // "abc.length is 3"
483 | // 可以包含反义字符
484 | val price = "${'$'}9.99"
485 | }
486 | ```
487 |
488 |
489 | ## 习惯用法
490 |
491 | 下面是符合Kotlin习惯的一些用法
492 |
493 | 创建Model，Kotlin中称作数据类（Data Class）
494 | 自动生成 getter/setter/equals/hashCode/toString/copy等
495 | ```kotlin
496 | data class Customer(val name: String, val email: String)
497 | ```
498 |
499 | 函数参数支持默认值
500 | ```kotlin
501 | fun foo(a: Int = 0, b: String = "") {
502 | // do something
503 | }
504 | ```
505 |
506 | 集合数据过滤
507 |
508 | ```kotlin
509 | fun filters(list: Collection) {
510 | val positives1 = list.filter { x -> x > 0 }
511 | // 也可以这样
512 | val positives2 = list.filter { it > 0 }
513 | }
514 | ```
515 |
516 | 字典数据遍历
517 | ```kotlin
518 | fun maps(map: Map) {
519 | for ((k, v) in map) {
520 | println("$k -> $v")
521 | }
522 | }
523 | ```
524 |
525 | 不可变List
526 | ```kotlin
527 | fun readOnlyList() {
528 | val list = listOf("a", "b", "c")
529 | // list.add("d") 错误：不能修改元素
530 | }
531 | ```
532 |
533 | 不可变Map
534 | ```kotlin
535 | fun readOnlyMap() {
536 | val map1 = mapOf("a" to 1, "b" to 2, "c" to 3)
537 | println(map1["a"])
538 | // map2["key"] = 123 错误：不能修改元素
539 | }
540 | ```
541 |
542 | 延迟计算属性
543 | ```kotlin
544 | class LazyDemo {
545 | // val p:String by lazy{
546 | // // compute the string
547 | // }
548 | }
549 | ```
550 |
551 | 支持给已有类型扩展属性和函数，非常强大好用的特性
552 | ```kotlin
553 | fun Int.biggerThanTen(): Boolean {
554 | return this > 10
555 | }
556 |
557 | // 测试一下扩展函数
558 | fun extensions() {
559 | 100.biggerThanTen()
560 | 5.biggerThanTen()
561 | }
562 | ```
563 |
564 | 创建单例对象不要太简单
565 | ```kotlin
566 | object Resource {
567 | val name = "Name"
568 | }
569 | ```
570 |
571 | 可空类型的使用
572 | ```kotlin
573 | //nullable用法
574 | fun testNullable() {
575 | val files = File("Test").listFiles()
576 | println(files?.size)
577 | println(files?.size ?: "empty")
578 | }
579 | ```
580 |
581 | when表达式的另一个例子
582 | ```kotlin
583 | fun transform(color: String): Int {
584 | return when (color) {
585 | "Red" -> 0
586 | "Green" -> 1
587 | "Blue" -> 2
588 | else -> throw IllegalArgumentException("Invalid color param value")
589 | }
590 | }
591 | ```
592 |
593 | 异常的使用和Java几乎一样，除了类型定义在后面
594 | ```kotlin
595 | fun tryCatch() {
596 | val result = try {
597 | // do something
598 | } catch (e: ArithmeticException) {
599 | throw IllegalStateException(e)
600 | }
601 |
602 | // Working with result
603 | }
604 | ```
605 |
606 | if表达式的另一个例子，可以有返回值
607 | ```kotlin
608 | fun ifExp(param: Int) {
609 | val result = if (param == 1) {
610 | "one"
611 | } else if (param == 2) {
612 | "two"
613 | } else {
614 | "three"
615 | }
616 | }
617 | ```
618 |
619 | with的用法，先看一个例子，后面再细说
620 | ```kotlin
621 | class Turtle {
622 | fun penDown() { }
623 | fun penUp() {}
624 | fun turn(degrees: Double) { }
625 | fun forward(pixels: Double) { }
626 | }
627 |
628 | // 如果你要调用某个对象的多个函数，可以这样用
629 | fun withExp() {
630 | val turtle = Turtle()
631 | with(turtle) { //draw a 100 pix square
632 | penDown()
633 | for (i in 1..4) {
634 | forward(100.0)
635 | turn(90.0)
636 | }
637 | penUp()
638 | }
639 | }
640 | ```
641 |
642 | ### 编码风格
643 |
644 | * 使用驼峰不要使用下划线
645 | * 类型名是用大写字母开头
646 | * 方法和属性名小写开头
647 | * 使用四个空格的缩进
648 | * 公开方法应该有文档
649 |
650 | 冒号前后有空格，大括号两边有空格，箭头两边有空格，举例
651 |
652 | ```kotlin
653 | list.filter { it > 10 }.map { element -> element * 2 }
654 | ```
655 |
656 |
--------------------------------------------------------------------------------
/notes.md:
--------------------------------------------------------------------------------
1 | # Kotlin入门和使用（讲稿）
2 |
3 | zhangxiaoke@douban.com 2016.03.24
4 |
5 | ------
6 |
7 | ## Intro
8 |
9 | ### Java 有哪些问题？
10 |
11 | - 空引用（Null references）：连空引用的发明者都成这是个 billion-dollar 错误（参见)。不论你费多大的功夫，你都无法避免它。因为 Java 的类型系统就是不安全的。
12 |
13 | - 原始类型（Raw types）：我们在开发的时候总是会为了保持兼容性而卡在范型原始类型的问题上，我们都知道要努力避免 raw type 的警告，但是它们毕竟是在语言层面上的存在，这必定会造成误解和不安全因素。
14 |
15 | - 协变数组（Covariant arrays）：你可以创建一个 string 类型的数组和一个 object 型的数组，然后把 string 数组分配给 object 数组。这样的代码可以通过编译，但是一旦你尝试在运行时分配一个数给那个数组的时候，他就会在运行时抛出异常。
16 |
17 | - Java 8 存在高阶方法（ higher-order functions ），但是他们是通过 SAM 类型 实现的。SAM 是一个单个抽象方法，每个函数类型都需要一个对应的接口。如果你想要创建一个并不存在的 lambda 的时候或者不存着对应的函数类型的时候，你要自己去创建函数类型作为接口。
18 |
19 | - 泛型中的通配符：诡异的泛型总是难以操作，难以阅读，书写，以及理解。对编译器而言，异常检查也变得很困难。
20 |
21 | - 不够灵活，缺乏扩展能力：我们不能给不是我们自己写的 types、classes 或者 interfaces 增加新的方法。长时间以来，我们都会采用 util 类，杂乱无章地堆砌着我们代码或者或者揉在同一个 util package 里面。如果这是解决方案的话，它肯定不理想。
22 |
23 | - 语法繁琐，不够简洁：Java 肯定不是最简洁的语言。这件事本身不是件坏事，但是事实上存在太多的常见的冗余。这会带来潜在的错误和缺陷。在这之前，我们还要处理安卓 API 带来的问题。
24 |
25 | ------
26 |
27 | ## Features
28 |
29 | - Lambdas
30 | - Data classes
31 | - Function literals
32 | - Extension functions
33 | - Null safety
34 | - Smart casts
35 | - String templates
36 | - Properties
37 | - Class delegation
38 | - Type inference
39 | - Range expressions
40 |
41 | ### Kotlin 有几个核心的目标：
42 |
43 | - 简约：帮你减少实现同一个功能的代码量。
44 | - 易懂：让你的代码更容易阅读，同时易于理解。
45 | - 安全：移除了你可能会犯错误的功能。
46 | - 通用：基于 JVM 和 Javascript，你可以在很多地方运行。
47 | - 互操作性：这就意味着 Kotlin 和 Java 可以相互调用，目标是 100% 兼容。
48 |
49 | ### Kotlin的特性
50 |
51 | 刚才我们提到过的这些缺陷，Kotlin 通常直接移除了那些特性。同时它也加了一些新的特性：
52 |
53 | - Lambda 表达式
54 | - 数据类 (Data classes)
55 | - 函数字面量和内联函数（Function literals & inline functions）
56 | - 函数扩展 (Extension functions)
57 | - 空安全（Null safety）
58 | - 智能转换（Smart casts）
59 | - 字符串模板（String templates）
60 | - 主构造函数（Primary constructors）
61 | - 类委托（Class delegation）
62 | - 类型推断（Type inference）
63 | - 单例（Singletons）
64 | - 声明点变量（Declaration-site variance）
65 | - 区间表达式（Range expressions）
66 |
67 | 我们将在这篇文章里提及以上大多数特性。Kotlin 之所以能跟随者 JVM 的生态系统不断地进步，是因为他没有任何限制。它编译出来的正是 JVM 字节码。在 JVM 看来，它就跟其他语言一样样的。事实上，如果你在 IntelliJ 或者 Android Studio 上用 Kotlin 的插件，它自带里一个字节码查看器，可以显示每个方法生成的 JVM 字节码。
68 |
69 | ------
70 |
71 | # Syntax
72 |
73 | ------
74 |
75 | ## Variables
76 |
77 | ```kotlin
78 | // hello.kt
79 | package com.kotlin.demo
80 |
81 | val a: Int = 1
82 | val b = 1
83 | val c: Int
84 | c = 1
85 | // c = 2
86 | var x = 5
87 | x += 1
88 |
89 | // val text: String = "Hello, World"
90 | val text = "Hello, World"
91 |
92 | // val ints: Array = arrayOf(1,2,3,4)
93 | val ints = arrayOf(1,2,3,4)
94 |
95 | var a: String = "abc"
96 | a = null // compilation error
97 |
98 | var b: String? = "abc"
99 | b = null // ok
100 | ```
101 |
102 | ### 类型声明
103 |
104 | - 包的声明应处于源文件顶部，目录与包的结构无需匹配，源代码可以在文件系统的任意位置。
105 | - 在 Kotlin 里，得把参数名放在前面，参数类型放在后面，用一个冒号隔开。
106 | - 常量（使用 val 关键字声明），相当于Java里的final，如果没有初始值，声明常量时，常量的类型不能省略。
107 | - 变量（使用 var 关键字声明），类型可以省略，自动推断出 Int 类型
108 | - 正如 Java 和 JavaScript，Kotlin 支持行注释及块注释，与 Java 不同的是，Kotlin 的块注释可以嵌套。
109 | - 当某个变量的值可以为 null 的时候，必须在声明处的类型后添加 ? 来标识该引用可为空。
110 |
111 | ### 类型推导
112 |
113 | 你可能在其他语言中看到过类型推导。在 Java 里，我们需要自己声明类型，变量名，以及数值。
114 |
115 | 在 Kotlin 里，顺序有些不一样，你先声明变量名，然后是类型，然后是分配值。很多情况下，你不需要声明类型。一个字符串字面量足以指明这是个字符串类型。字符，整形，长整形，单浮点数，双浮点数，布尔值都是可以无需显性声明类型的。
116 |
117 | 只要 Kotlin 可以推导，这个规则同样适用与其他一些类型。通常，如果是局部变量，当你在声明一个值或者变量的时候你不需要指明类型。在一些无法推导的场景里，你才需要用完整的声明变量语法指明变量类型。
118 |
119 | ------
120 |
121 | ## Define Function
122 |
123 | ```kotlin
124 | fun sum(a: Int, b: Int): Int {
125 | return a + b
126 | }
127 |
128 | fun sum(a: Int, b: Int) = a + b
129 |
130 | fun printSum(a: Int, b: Int): Unit {
131 | print(a + b)
132 | }
133 |
134 | fun printSum(a: Int, b: Int) {
135 | print(a + b)
136 | }
137 |
138 | fun main(args: Array) {
139 | println("Hello, World!")
140 | }
141 | ```
142 |
143 | ### 定义函数
144 |
145 | - 声明函数的关键字是 fun，fun 后面跟的是函数的名称，然后括号包裹起来的是函数参数，这个跟 Java 类似。
146 |
147 | - 这是带有两个 Int 参数、返回 Int 的函数。可以将表达式作为函数体、返回值类型自动推断的函数。函数返回无意义的值，Unit 返回类型可以省略。Kotlin的函数和Java类似，但不需要定义在类内部。
148 |
149 | - 函数的返回类型在最后，这个跟 Java 放在前面形式不太一样。如果一个函数没有返回任何类型，可以返回一个 Unit 类型，当然也可以省略。调用 Kotlin 标准库中的函数 println 就能打印 Hello World 出来，实际上它最终调用了 Java 的 system.out.println。
150 |
151 | ------
152 |
153 | ## If Expressions
154 |
155 | ```kotlin
156 | fun max(a: Int, b: Int): Int {
157 | if (a > b)
158 | return a
159 | else
160 | return b
161 | }
162 |
163 | fun max(a: Int, b: Int) = if (a > b) a else b
164 |
165 | // As expression
166 | val max = if (a > b) a else b
167 |
168 | val max = if (a > b) {
169 | print("Choose a")
170 | a
171 | }
172 | else {
173 | print("Choose b")
174 | b
175 | }
176 | ```
177 |
178 | ### If表达式
179 |
180 | - 在 Kotlin 中，if是一个表达式，即它会返回一个值。 因此就不需要三元运算符（条件 ? 然后 : 否则），因为普通的 if 就能胜任这个角色。
181 |
182 | - if的分支可以是代码块，最后的表达式作为该块的值。如果你使用 if 作为表达式而不是语句（例如：返回它的值或者 把它赋给变量），该表达式需要有 else 分支。
183 |
184 | ------
185 |
186 | ## Loop
187 |
188 | ```kotlin
189 | fun forLoop1(args: Array) {
190 | for (arg in args) {
191 | print(arg)
192 | }
193 | }
194 |
195 | fun forLoop2(args: Array) {
196 | for (i in args.indices) {
197 | print(args[i])
198 | }
199 | }
200 |
201 | fun whileLoop1(args: Array) {
202 | var i = 0
203 | while (i < args.size)
204 | print(args[i++])
205 | }
206 | ```
207 |
208 | ### FOR循环
209 |
210 | - for 循环可以对任何提供迭代器（iterator）的对象进行遍历，循环体可以是一个代码块。
211 |
212 | - for 可以循环遍历任何提供了迭代器的对象。即：
213 | - 有一个成员函数或者扩展函数 iterator()，它的返回类型
214 | - 有一个成员函数或者扩展函数 next()，并且
215 | - 有一个成员函数或者扩展函数 hasNext() 返回 Boolean
216 |
217 | - 对数组的 for 循环会被编译为并不创建迭代器的基于索引的循环，注意这种“在区间上遍历”会编译成优化的实现而不会创建额外对象，如果你想要通过索引遍历一个数组或者一个 list，你可以用.indices或array.withIndex。
218 |
219 | - while 和 do..while 照常使用。
220 |
221 | ------
222 |
223 | ## When
224 |
225 | ```kotlin
226 | when (x) {
227 | 0, 1 -> print("x == 0 or x == 1")
228 | 3 -> print("x == 3")
229 | 4 -> print("x == 4")
230 | else -> print("otherwise")
231 | }
232 |
233 | when (x) {
234 | in 1..10 -> print("x is in the range")
235 | in validNumbers -> print("x is valid")
236 | !in 10..20 -> print("x is outside the range")
237 | else -> print("none of the above")
238 | }
239 | ```
240 |
241 | ### When语句和表达式
242 |
243 | - when 取代了类 C 语言的 switch 操作符
244 | - when 将它的参数和所有的分支条件顺序比较，直到某个分支满足条件
245 | - when 既可以被当做表达式使用也可以被当做语句使用
246 | - 如果它被当做表达式， 符合条件的分支的值就是整个表达式的值
247 | - 如果当做语句使用， 则忽略个别分支的值
248 | - 如果很多分支需要用相同的方式处理，则可以把多个分支条件放在一起，用逗号分隔
249 | - 我们可以用任意表达式（而不只是常量）作为分支条件
250 | - 我们也可以检测一个值在（in）或者不在（!in）一个区间或者集合中
251 | - 另一种可能性是检测一个值是（is）或者不是（!is）一个特定类型的值
252 | - when 也可以用来取代 if-else if链
253 | - 如果不提供参数，所有的分支条件都是简单的布尔表达式，而当一个分支的条件为真时则执行该分支
254 |
255 | ------
256 |
257 | ## Returns
258 |
259 | ```kotlin
260 | return.
261 | break.
262 | continue.
263 |
264 | loop@ for (i in 1..100) {
265 | for (j in 1..100) {
266 | if (...)
267 | break@loop
268 | }
269 | }
270 |
271 | fun foo() {
272 | ints.forEach lit@ {
273 | if (it == 0) return@lit
274 | print(it)
275 | }
276 | }
277 | ```
278 |
279 | ### 返回和跳转
280 |
281 | - Kotlin 有三种结构化跳转操作符
282 | - return.默认从最直接包围它的函数或者匿名函数返回。
283 | - break.终止最直接包围它的循环。
284 | - continue.继续下一次最直接包围它的循环。
285 |
286 | - 在 Kotlin 中任何表达式都可以用标签（label）来标记。
287 |
288 | - 我们可以用标签限制 break 或者continue，标签限制的 break 跳转到刚好位于该标签指定的循环后面的执行点。 continue 继续标签指定的循环的下一次迭代。
289 |
290 | - Kotlin 有函数字面量、局部函数和对象表达式。因此 Kotlin 的函数可以被嵌套。 标签限制的 return 允许我们从外层函数返回。 最重要的一个用途就是从 lambda 表达式中返回。
291 |
292 | - 这个 return 表达式从最直接包围它的函数即 foo 中返回。 （注意，这种非局部的返回只支持传给内联函数的 lambda 表达式。） 如果我们需要从 lambda 表达式中返回，我们必须给它加标签并用以限制 return。
293 |
294 | ------
295 |
296 | ## Strings
297 |
298 | ```kotlin
299 | for (c in str) {
300 | println(c)
301 | }
302 |
303 | val s = "Hello, world!\n"
304 |
305 | val text = """
306 | for (c in "foo")
307 | print(c)
308 | """
309 |
310 | val s = "abc"
311 | val str = "$s.length is ${s.length}"
312 |
313 | var args = arrayOf("Cat", "Dog", "Rabbit")
314 | print("Hello ${args[0]}")
315 | ```
316 |
317 | ### 字符串说明
318 |
319 | - 字符串用 String 类型表示。字符串是不可变的。 字符串的元素——字符可以使用索引运算符访问: s[i]。 可以用 for 循环迭代字符串。
320 |
321 | - Kotlin 有两种类型的字符串字面值: 转义字符串可以有转义字符，以及原生字符串白可以包含换行和任意文本。转义字符串很像 Java 字符串。
322 |
323 | - 原生字符串 使用三个引号（"""）分界符括起来，内部没有转义并且可以包含换行和任何其他字符。
324 |
325 | - 字符串可以包含模板表达式 ，即一些小段代码，会求值并把结果合并到字符串中。 模板表达式以美元符（$）开头，由一个简单的名字构成，或者用花括号扩起来的任意表达式。
326 |
327 | - 原生字符串和转义字符串内部都支持模板。 如果你需要在原生字符串中表示字面值 $ 字符（它不支持反斜杠转义），你可以用三引号语法。
328 |
329 | - 字符串字面值用单引号括起来: '1'。 特殊字符可以用反斜杠转义。 支持这几个转义序列：\t、 \b、\n、\r、\'、\"、\\ 和 \$。 编码其他字符要用 Unicode 转义序列语法：'\uFF00'。
330 |
331 | ------
332 |
333 | ## Basic Types
334 |
335 | ```kotlin
336 | Type Bit width
337 | --------------------------------------
338 | Double 64
339 | Float 32
340 | Long 64
341 | Int 32
342 | Short 16
343 | Byte 8
344 | ```
345 |
346 | ```kotlin
347 | val a: Int = 10000
348 | print(a === a) // Prints 'true'
349 | val boxedA: Int? = a
350 | val anotherBoxedA: Int? = a
351 | print(boxedA === anotherBoxedA) // !!!Prints 'false'!!!
352 | ```
353 |
354 | ### 数据类型
355 |
356 | - 在 Kotlin 中，所有东西都是对象，在这个意义上讲所以我们可以在任何变量上调用成员函数和属性。有些类型是内置的，因为他们的实现是优化过的。但是用户看起来他们就像普通的类。本节我们会描述大多数这些类型：数字、字符、布尔和数组。
357 |
358 | - Kotlin 处理数字在某种程度上接近 Java，但是并不完全相同。例如，对于数字没有隐式拓宽转换（如 Java 中 int 可以隐式转换为long——译者注)，另外有些情况的字面值略有不同。
359 |
360 | - 注意在 Kotlin 中字符不是数字。
361 |
362 | - 在 Java 平台数字是物理存储为 JVM 的原生类型，除非我们需要一个可空的引用（如 Int?）或泛型。 后者情况下会把数字装箱。
363 |
364 | - 由于不同的表示方式，较小类型并不是较大类型的子类型。 如果它们是的话，就会出现下述问题。
365 |
366 | ```kotlin
367 | // 假想的代码，实际上并不能编译：
368 | val a: Int? = 1 // 一个装箱的 Int (java.lang.Integer)
369 | val b: Long? = a // 隐式转换产生一个装箱的 Long (java.lang.Long)
370 | print(a == b) // 惊！这将打印 "false" 鉴于 Long 的 equals() 检测其他部分也是 Long
371 | ```
372 |
373 | - 因此较小的类型不能隐式转换为较大的类型。 这意味着在不进行显式转换的情况下我们不能把 Byte 型值赋给一个 Int 变量。
374 |
375 | - 缺乏隐式类型转换并不显著，因为类型会从上下文推断出来，而算术运算会有重载做适当转换。例如
376 |
377 | ```kotlin
378 | val l = 1L + 3 // Long + Int => Long
379 | ```
380 |
381 | ### 编码风格
382 |
383 | - 使用驼峰不要使用下划线
384 | - 类型名是用大写字母开头
385 | - 方法和属性名小写开头
386 | - 使用四个空格的缩进
387 | - 公开方法应该有文档
388 | - 冒号前后有空格，大括号两边有空格，箭头两边有空格，举例
389 |
390 | ```kotlin
391 | list.filter { it > 10 }.map { element -> element * 2 }
392 | ```
393 |
394 | ------
395 |
396 | class: center, middle
397 |
398 | # Classes and Objects
399 |
400 | ------
401 |
402 | ## Classes
403 |
404 | ```kotlin
405 | class Invoice {
406 | }
407 |
408 | class Empty
409 |
410 | class Person(name: String) {
411 | }
412 |
413 | class Person(name: String) {
414 | val customName = name.toUpperCase()
415 | }
416 |
417 | class Person(val firstName: String, val lastName: String,
418 | var age: Int) {
419 | // ...
420 | }
421 | ```
422 |
423 | ### 定义一个类
424 |
425 | - 类的定义要通过 class 关键字，跟 Java 里的一样，关键字后是类名。Kotlin 有一个主构造函数，我们可以直接将构造函数参数列表写在类的声明处，还可以直接用 var 或者 val 关键字将参数声明为成员变量（又称：类属性）
426 |
427 | - 这个类声明被花括号包围，包括类名、类头(指定其类型参数,主构造 函数等)和这个类的主干。类头和主干都是可选的； 如果这个类没有主干，花括号可以被省略。
428 |
429 | - 在Kotlin中的类可以有主构造函数和一个或多个二级构造函数。主构造 函数是类头的一部分:它跟在这个类名后面（和可选的类型参数）。
430 |
431 | - 如果这个主构造函数没有任何注解或者可见的修饰符，这个constructor 关键字可以被省略。
432 |
433 | - 请注意，主构造的参数可以在初始化模块中使用。它们也可以在 类体内声明初始化的属性。事实上，声明属性和初始化主构造函数,Kotlin有简洁的语法
434 |
435 | ```kotlin
436 | class Person(val firstName: String, val lastName: String, var age: Int) {
437 | // ...
438 | }
439 | ```
440 |
441 | ------
442 |
443 | ## Constructors
444 |
445 | ```kotlin
446 | class Person constructor(name: String) {
447 | val fixName = name.toUpperCase()
448 | }
449 |
450 | class Person {
451 | constructor(parent: Person) {
452 | parent.children.add(this)
453 | }
454 | }
455 |
456 | class Person(name: String) {
457 | init {
458 | logger.info("Person initialized with value ${name}")
459 | }
460 | }
461 |
462 | val invoice = Invoice()
463 | val customer = Customer("Joe Smith")
464 | ```
465 |
466 | ### 构造函数
467 |
468 | Kotlin 中，类可以拥有多个构造函数，这一点跟 Java 类似。但你也可以有一个主构造函数。下面的例子是我们从上面的例子里衍生出来的，在函数头里添加了一个主构造函数
469 |
470 | 当然，更好的方法是：直接在主构造函数里定义这些属性，定义的方法是在参数名前加上 var 或者 val 关键字，val 是代表属性是常量。
471 |
472 | 在主构造函数里，可以直接用这些参数变量赋值给类的属性，或者用构造代码块来实现初始化。
473 |
474 | - 这个主构造函数不能包含任何的代码。初始化的代码可以被放置 在initializer blocks（初始的模块），以init为关键字作为前缀
475 | - 与普通属性一样,主构造函数中声明的属性可以是 可变的（var）或者是只读的（val）
476 | - 如果构造函数有注解或可见性修饰符，这个constructor关键字是必需的
477 | - 类也可以拥有被称为”二级构造函数”(为了实现Kotlin向Java一样拥有多个构造函数)，通常被加上前缀constructor
478 | - 如果类有一个主构造函数,每个二级构造函数需要委托给主构造函数, 直接或间接地通过另一个二级函数。委托到另一个使用同一个类的构造函数 用this关键字
479 | - 要创建一个类的实例，我们调用构造函数，就好像它是普通的函数
480 |
481 | ------
482 |
483 | ## Inheritance
484 |
485 | ```kotlin
486 | class Example // Implicitly inherits from Any
487 |
488 | open class Base(p: Int)
489 |
490 | class Derived(p: Int) : Base(p)
491 | ```
492 |
493 | ```kotlin
494 | open class Base {
495 | open fun v() {}
496 | fun nv() {}
497 | }
498 | class Derived() : Base() {
499 | override fun v() {}
500 | }
501 |
502 | open class AnotherDerived() : Base() {
503 | final override fun v() {}
504 | }
505 | ```
506 |
507 | ### 类的继承
508 |
509 | - 在Kotlin所有的类中都有一个共同的父类Any，这是一个默认的父类且没有父类型声明
510 | - Any不属于java.lang.Object;特别是，它并没有任何其他任何成员，甚至连equals()，hashCode()和toString()都没有。
511 | - 要声明一个明确的父类，我们把类型放到类头冒号之后，父类可以（并且必须）在声明继承的地方， 用原始构造函数初始化。
512 | - 如果类没有主构造，那么每个次级构造函数初始化基本类型 使用super{：.keyword}关键字，或委托给另一个构造函数做到这一点。 注意，在这种情况下，不同的二级构造函数可以调用基类型的不同的构造函数。
513 |
514 | ------
515 |
516 | ## Overriding Members
517 |
518 | ```kotlin
519 | open class A {
520 | open fun f() { print("A") }
521 | fun a() { print("a") }
522 | }
523 |
524 | interface B {
525 | fun f() { print("B") } // interface members are 'open' by default
526 | fun b() { print("b") }
527 | }
528 |
529 | class C() : A(), B {
530 | // The compiler requires f() to be overridden:
531 | override fun f() {
532 | super.f() // call to A.f()
533 | super.f() // call to B.f()
534 | }
535 | }
536 | ```
537 |
538 | ### 成员覆盖
539 |
540 | - 我们之前提到过，Kotlin力求清晰显式。不像Java中，Kotlin需要明确的 标注覆盖的成员（我们称之为open）和重写的函数。（继承父类并覆盖父类函数时，Kotlin要求父类必须有open标注，被覆盖的函数必须有open标注，并且子类的函数必须加override标注。）
541 |
542 | - Derived.v()函数上必须加上override标注。如果没写，编译器将会报错。 如果父类的这个函数没有标注open，则子类中不允许定义同名函数，不论加不加override。 在一个final类中（即没有声明open的类），函数上也不允许加open标注。
543 |
544 | - 成员标记为override{：.keyword}的本身是开放的，也就是说，它可以在子类中重写。如果你想禁止重写的，使用final{：.keyword}关键字
545 |
546 | - 在Kotlin中，实现继承的调用通过以下规则：如果一个类继承父类成员的多种实现方法，可以直接在子类中引用， 它必须重写这个成员，并提供其自己的实现（当然也可以使用父类的）。 为了表示从中继承的实现而采取的父类型，我们使用super{：.keyword}在尖括号，如规范的父名super
547 |
548 | - 类和其中的某些实现可以声明为abstract{：.keyword}。 抽象成员在本类中可以不用实现。
549 |
550 | - 需要注意的是，我们并不需要标注一个抽象类或者函数为open - 因为这不言而喻。我们可以重写一个open非抽象成员使之为抽象的。
551 |
552 | ------
553 |
554 | ## Properties
555 |
556 | ```kotlin
557 | public class Address {
558 | public val code:Int = 10015
559 | public var name: String = ...
560 | public var city: String = ...
561 | public var state: String? = ...
562 | public var zip: String = ...
563 | }
564 |
565 | fun copyAddress(address: Address): Address {
566 | val result = Address() // there's no 'new' keyword in Kotlin
567 | result.name = address.name // accessors are called
568 | result.street = address.street
569 | // ...
570 | return result
571 | }
572 |
573 | const val DEPRECATED: String = "deprecated"
574 | const val SOCKET_TIMEOUT = 30*1000L
575 | ```
576 |
577 | ### 类的属性
578 |
579 | - Kotlin的类可以有属性. 这些声明是可变的,用关键字var或者使用只读关键字val
580 | - 要使用一个属性，只需要使用名称引用即可，就相当于Java中的公共字段
581 | - 注意公有的API(即public和protected)的属性，类型是不做推导的。~~ ~~这么设计是为了防止改变初始化器时不小心改变了公有API。
582 |
583 | ### 常量属性的要求
584 |
585 | Properties the value of which is known at compile time can be marked as compile time constants using the const modifier. Such properties need to fulfil the following requirements:
586 |
587 | - Top-level or member of an object
588 | - Initialized with a value of type String or a primitive type
589 | - No custom getter
590 |
591 | ------
592 |
593 | ## Getters and Setters
594 |
595 | ```kotlin
596 | val isEmpty: Boolean
597 | get() = this.size == 0
598 |
599 | var stringRepresentation: String
600 | get() = this.toString()
601 | set(value) {
602 | setDataFromString(value)
603 | }
604 |
605 | var setterVisibility: String = "abc"
606 | // Initializer required, not a nullable type
607 | private set // the setter is private
608 | ```
609 |
610 | ### Getter和Setter
611 |
612 | 声明一个属性的完整语法
613 |
614 | ```kotlin
615 | var : [= ]
616 | []
617 | []
618 | ```
619 |
620 | - 上面的定义中，初始器(initializer)、getter 和 setter 都是可选的。属性类型- (PropertyType)如果可以从初始器或者父类中推导出来，也可以省略。
621 |
622 | - 一个只读属性的语法和一个可变的语法有两方面的不同：1、只读属性的用val开始代替var 2、只读属性不许setter。
623 |
624 | - 如果你需要改变一个访问器或注释的可见性,但是不需要改变默认的实现, 您可以定义访问器而不定义它的实例。
625 |
626 | - 在Kotlin不能有字段。然而,有时有必要有使用一个字段在使用定制的访问器的时候。对于这些目的,Kotlin提供 自动支持,在属性名后面使用 field标识符。
627 |
628 | - 编译器会查看访问器的内部， 如果他们使用了实际字段（或者访问器使用默认实现），那么将会生成一个实际字段，否则不会生成。
629 |
630 | ------
631 |
632 | ## Interface
633 |
634 | ```kotlin
635 | interface MyInterface {
636 | val property: Int // abstract
637 |
638 | val propertyWithImplementation: String
639 | get() = "foo"
640 |
641 | fun bar()
642 | fun foo() {
643 | // optional body
644 | }
645 | }
646 |
647 | class Child : MyInterface {
648 | override val property: Int = 29
649 |
650 | override fun bar() {
651 | // body
652 | }
653 | }
654 | ```
655 |
656 | ### 接口定义
657 |
658 | - 使用关键字 interface 来定义接口。Kotlin 的接口与 Java 8 类似，既包含抽象方法的声明，也包含 实现。与抽象类不同的是，接口无法保存状态。它可以有 属性但必须声明为 abstract或提供访问器实现。
659 |
660 | - 一个类或者对象可以实现一个或多个接口。
661 |
662 | - 实现多个接口时，可能会遇到接口方法名同名的问题。D 可以不用重写 bar()，因为它实现了 A 和 B，因而可以自动继承 B 中 bar() 的实现， 但是两个接口都定义了方法 foo()，为了告诉编译器 D 会继承谁的方法，必须在 D 中重写 foo()。
663 |
664 | ------
665 |
666 | ## Data Class
667 |
668 | ```kotlin
669 | // equals()/hashCode()/toString()/componentN()/copy()
670 |
671 | data class User(val name: String, val age: Int)
672 | data class User(val name: String = "", val age: Int = 0)
673 |
674 | fun copy(name: String = this.name, age: Int = this.age)
675 | = User(name, age)
676 |
677 | val jack = User(name = "Jack", age = 1)
678 | val olderJack = jack.copy(age = 2)
679 |
680 | val jane = User("Jane", 35)
681 | val (name, age) = jane
682 | println("$name, $age years of age")
683 | // prints "Jane, 35 years of age"
684 | ```
685 |
686 | ### 数据类/POJO
687 |
688 | - 我们经常创建一些只是处理数据的类。在这些类里的标准功能经常是 衍生自数据。在Kotlin中，这叫做 数据类 并标记为data。
689 |
690 | - 编译器自动从在主构造函数定义的全部特性中得到以下成员：
691 | - equals()/hashCode() 对，
692 | - toString() 格式是 "User(name=John, age=42)"，
693 | - componentN() functions 对应按声明顺序出现的所有属性，
694 | - copy() 函数（见下面）。
695 |
696 | - 如果有某个函数被明确地定义在类里或者被继承，编译器就不会生成这个函数。
697 |
698 | - 在JVM中，如果生成的类需要含有一个无参的构造函数，则所有的属性必须有默认值。
699 |
700 | - 在很多情况下，我们我们需要对一些属性做修改而其他的不变。 这就是copy()这个方法的来源。对于上文的User类，应该是这么实现这个方法。
701 | - 在标准库提供了Pair和Triple。在很多情况下，即使命名数据类是一个更好的设计选择， 因为这能让代码可读性更强。
702 |
703 | ------
704 |
705 | ## Destructuring Declarations
706 |
707 | ```kotlin
708 | data class Person(val name:String, val age:Int){}
709 |
710 | val person = Person("John",20)
711 | val (name, age) = person
712 |
713 | val name = person.component1()
714 | val age = person.component2()
715 |
716 | for ((a, b) in collection) { ... }
717 | for ((key, value) in map) {
718 | }
719 |
720 | val (result, status) = function(...)
721 |
722 | operator fun Map.iterator(): Iterator>
723 | = entrySet().iterator()
724 | operator fun Map.Entry.component1() = getKey()
725 | operator fun Map.Entry.component2() = getValue()
726 | ```
727 |
728 | ### 解构声明
729 |
730 | - 有时把一个对象_解构_成很多变量很比较方便，这种语法叫做_解构声明_。一个解构声明同时创造多个变量。 我们申明了两个新变量：name 和 age,并且可以独立使用他们。
731 |
732 | - component1() 和 component2() 函数是 principle of conventions widely 在Kotlin 中的另一个例子。 (参考运算符如 + ， *, for-loops 等) 任何可以被放在解构声明右边的和组件函数的需求数字都可以调用它。 当然，这里可以有更多的如 component3() 和 component4()。
733 |
734 | - 变量 a 和 b 从调用从 component1() 和 component2() 返回的集合collection中的对象。
735 |
736 | - 让我们从一个函数中返回两个变量。例如，一个结果对象和一些排序的状态。 在Kotlin中一个简单的实现方式是申明一个data class并且返回他的实例。
737 |
738 | - 可能最好的遍历一个映射的方式就是这样，实现这个接口，于是你可以自由的使用解构声明 for-loops 来操作映射(也可以用在数据类实例的集合等)。
739 |
740 | ------
741 |
742 | ## Nested and Inner Classes
743 |
744 | ```kotlin
745 | class Outer {
746 | private val bar: Int = 1
747 | class Nested {
748 | fun foo() = 2
749 | }
750 | }
751 |
752 | val demo = Outer.Nested().foo() // == 2
753 | ```
754 |
755 | ```kotlin
756 | class Outer {
757 | private val bar: Int = 1
758 | inner class Inner {
759 | fun foo() = bar
760 | }
761 | }
762 |
763 | val demo = Outer().Inner().foo() // == 1
764 | ```
765 |
766 | ### 嵌套类和内部类
767 |
768 | - 在类的内部可以嵌套其他的类，相当于Java里的static内部类。
769 |
770 | - 为了能被外部类访问一个类可以被标记为内部类（“inner” 关键词）。 内部类会带有一个来自外部类的对象的引用
771 |
772 | ------
773 |
774 | ## Enum
775 |
776 | ```kotlin
777 | enum class Direction {
778 | NORTH, SOUTH, WEST, EAST
779 | }
780 |
781 | enum class Color(val rgb: Int) {
782 | RED(0xFF0000),
783 | GREEN(0x00FF00),
784 | BLUE(0x0000FF)
785 | }
786 |
787 | enum class ProtocolState {
788 | WAITING {
789 | override fun signal() = TALKING
790 | },
791 |
792 | TALKING {
793 | override fun signal() = WAITING
794 | };
795 |
796 | abstract fun signal(): ProtocolState
797 | }
798 | ```
799 |
800 | ### 枚举
801 |
802 | - 枚举类的最基本应用是实现类型安全的多项目集合。其中每一个常量（NORTH，SOUTH……）都是一个对象。每一个常量用逗号“,”分隔。
803 |
804 | - 枚举实例也可以被声明为他们自己的匿名类，并同时包含他们相应原本的方法和覆盖基本方法。注意如果枚举类定义了任何成员，你需要像JAVA一样把枚举实例的定义和成员定义用分号分开。
805 |
806 | - 像JAVA一样，枚举类在Kotlin中有合成方法。它允许列举枚举实例并且通过名称返回枚举实例。下面是应用实例 (假设枚举实例名称是EnumClass)。
807 |
808 | - 枚举常量也可以实现Comparable 接口。他们会依照在枚举类中的定义先后以自然顺序排列。
809 | ------
810 |
811 | ## Object
812 |
813 | ```kotlin
814 | val adHoc = object {
815 | var x: Int = 0
816 | var y: Int = 0
817 | }
818 | print(adHoc.x + adHoc.y)
819 |
820 | // Singleton
821 | object Resource {
822 | val name = "Name"
823 | }
824 |
825 | open class A(x: Int) {
826 | public open val y: Int = x
827 | }
828 |
829 | interface B {...}
830 |
831 | val ab = object : A(1), B {
832 | override val y = 15
833 | }
834 | ```
835 |
836 | ### 对象和单例
837 |
838 | - 有些时候我们需要创建一个对某些类做了轻微改变的一个对象，而不用为了它显式地定义一个新的子类。 Java把这种情况处理为匿名内部类。 在Kotlin稍微推广了这个概念，称它们为对象表达式和对象声明。
839 |
840 | - 对象表达式：如果父类型有一个构造函数，合适的构造函数参数必须传递给它。 多个父类型用逗号隔开，跟在冒号后面。
841 |
842 | - 或许，我们需要的仅是无父类的一个对象，那么我们可以简单地写为adHoc这种。
843 | - 就像Java的匿名内部类，在对象表达式里代码可以访问封闭的作用域 （但与Java不同的是，它能访问非final修饰的变量）。
844 |
845 | - 对象声明：单例模式是一种非常有用的模式，而在Kotilin（在Scala之后）中很容易就能声明一个单例。DataProviderManager被称为对象声明。如果有一个object关键字在名字前面，这不能再被称为一个_表达式_。 我们不能把这样的东西赋值给变量，但我们可以通过它的名字来引用它。
846 |
847 | 对象表达式与对象声明语义上的不同
848 |
849 | - 当对象声明被第一次访问的时候,它会被延迟（lazily）初始化
850 | - 当对象表达式被用到的时候，它会被立即执行（并且初始化）
851 |
852 | ------
853 |
854 | ## Companion
855 |
856 | ```kotlin
857 | class MyClass {
858 | companion object Factory {
859 | fun create(): MyClass = MyClass()
860 | }
861 | }
862 |
863 | interface Factory {
864 | fun create(): T
865 | }
866 | class MyClass {
867 | companion object : Factory {
868 | override fun create(): MyClass = MyClass()
869 | }
870 | }
871 |
872 | val x = MyClass.Companion
873 | ```
874 |
875 | ### 伴生对象
876 |
877 | Kotlin 移除了 static 的概念。通常用 companion object 来实现类似功能。
878 |
879 | - 伴生对象：一个对象声明在一个类里可以标志上companion这个关键字
880 | - 伴生对象的成员可以使用类名称作为限定符来调用
881 | - 使用companion关键字时候，伴生对象的名称可以省略
882 | - 注意，虽然伴生对象的成员在其他语言中看起来像静态成员，但在运行时它们 仍然是实体的实例成员，举例来说，我们能用它实现接口
883 | - 然而，在JVM中，如果你使用@JvmStatic注解，你可以让伴生对象的成员生成为实际存在的静态方法和域
884 |
885 | ------
886 |
887 | ## Class Delegation
888 |
889 | ```kotlin
890 | interface Base {
891 | fun print()
892 | }
893 |
894 | class BaseImpl(val x: Int) : Base {
895 | override fun print() { print(x) }
896 | }
897 |
898 | class Derived(b: Base) : Base by b
899 |
900 | fun main() {
901 | val b = BaseImpl(10)
902 | Derived(b).print() // prints 10
903 | }
904 | ```
905 |
906 | ### 类的委托
907 |
908 | 委托是一个大家都知道的设计模式，Kotlin 把委托视为很重要的语言特性。
909 |
910 | - 委托模式是实现继承的一个有效方式。Kotlin原生支持它。一个类 Derived 可以从一个接口 Base继承并且委托所有的共有方法为具体对象。
911 |
912 | - 在父类Derived中的 by-语句表示 b 将会被 储存在 Derived 的内部对象中，并且编译器会生成所有的用于转发给b的Base的方法。
913 |
914 | ------
915 |
916 | ## Delegated Properties
917 |
918 | ```kotlin
919 | class Example {
920 | var p: String by Delegate()
921 | }
922 |
923 | class Delegate {
924 | operator fun getValue(thisRef: Any?,
925 | property: KProperty<*>): String {
926 | return "$thisRef, thank you for delegating
927 | '${property.name}' to me!"
928 | }
929 |
930 | operator fun setValue(thisRef: Any?,
931 | property: KProperty<*>, value: String) {
932 | println("$value has been assigned to
933 | '${property.name} in $thisRef.'")
934 | }
935 | }
936 |
937 | val e = Example()
938 | println(e.p)
939 | // Example@33a17727, thank you for delegating ‘p’ to me!
940 |
941 | e.p = "NEW"
942 | // NEW has been assigned to ‘p’ in Example@33a17727.
943 | ```
944 |
945 | ### 委托属性
946 |
947 | 有一些种类的属性，虽然我们可以在每次需要的时候手动实现它们，但是如果能够把他们只实现一次 并放入一个库同时又能够一直使用它们那会更好。例如：
948 |
949 | - 延迟属性（lazy properties）: 数值只在第一次被访问的时候计算。
950 | - 可观察属性（observable properties）: 监听器得到关于这个特性变化的通知，
951 | - 把所有属性储存在一个map中，而不是每个在单独的字段里。
952 | 为了支持这些(或者其他)例子，Kotlin 采用 委托属性。
953 |
954 | 当我们读取一个Delegate的委托实例 p , Delegate中的getValue()就被调用, 所以它第一变量就是我们从 p 读取的实例,第二个变量代表 p 自身的描述。 (例如你可以用它的名字)。
955 |
956 | 类似的，当我们给 p 赋值, setValue() 函数就被调用. 前两个参数是一样的，第三个参数保存着将要被赋予的值
957 |
958 | ### 属性委托要求
959 |
960 | 这里我们总结委托对象的要求。
961 |
962 | 对于一个 只读 属性 (如 val), 一个委托一定会提供一个 getValue函数来获取下面的参数:
963 |
964 | - 接收者 — 必须与_属性所有者_类型相同或者是其父类(对于扩展属性，类型范围允许扩大),
965 | - 包含数据 — 一定要是 KProperty<*> 的类型或它的父类型,
966 | - 这个函数必须返回同样的类型作为属性（或者子类型）
967 |
968 | 对于一个 可变 属性 (如 var), 一个委托需要额外地提供一个函数 setValue 来获取下面的参数:
969 |
970 | - 接收者 — 同 getValue(),
971 | - 包含数据 — 同 getValue(),
972 | - 新的值 — 必须和属性同类型或者是他的父类型。
973 |
974 | getValue() 或/和 setValue() 函数可能会作为代理类的成员函数或者扩展函数来提供。 当你需要代理一个属性给一个不是原来就提供这些函数的对象的时候，后者更为方便。 两种函数都需要用operator关键字来进行标记
975 |
976 | ### 标准委托
977 |
978 | 标准库中对于一些有用的委托提供了工厂（factory）方法。
979 |
980 | ------
981 |
982 | ## By Lazy
983 |
984 | ```kotlin
985 | val lazyValue: String by lazy {
986 | Log.v("Lazy", "Lazy Init")
987 | "Hello, Lazy!"
988 | }
989 |
990 | fun lazyTest() {
991 | Log.d("Lazy", lazyValue)
992 | Log.d("Lazy", lazyValue)
993 | }
994 | ```
995 |
996 | ```shell
997 | V/Lazy: Lazy Init
998 | D/Lazy: Hello, Lazy!
999 | D/Lazy: Hello, Lazy!
1000 | ```
1001 |
1002 | ### 延迟属性 Lazy
1003 |
1004 | 函数 lazy() 接受一个 lambda 然后返回一个可以作为实现延迟属性的委托 Lazy 实例来: 第一次对于 get()的调用会执行（之前）传递到 lazy()的lamda表达式并记录结果, 后面的 get() 调用会直接返回记录的结果。
1005 |
1006 | 默认地，对于lazy属性的计算是同步锁（synchronized） 的: 这个值只在一个线程被计算，并且所有的线程会看到相同的值。如果初始化代理的同步锁不是必须的，以至于多个线程可以同步地执行，那么将LazyThreadSafetyMode.PUBLICATION作为一个变量传递给lazy()函数。
1007 |
1008 | 而且如果你确定初始化将总是发生在单个线程，那么你可以使用 LazyThreadSafetyMode.NONE 模式, 它不会有任何线程安全的保证和相关的开销。
1009 |
1010 | ------
1011 |
1012 | ## Observable
1013 |
1014 | ```kotlin
1015 | import kotlin.properties.Delegates
1016 |
1017 | class User {
1018 | var name: String by Delegates.observable("") {
1019 | prop, old, new ->
1020 | println("$old -> $new")
1021 | }
1022 | }
1023 |
1024 | fun main(args: Array) {
1025 | val user = User()
1026 | user.name = "first"
1027 | user.name = "second"
1028 | }
1029 |
1030 | // output
1031 | // -> first
1032 | // first -> second
1033 | ```
1034 |
1035 | ### 可观察属性 Observable
1036 |
1037 | Delegates.observable() 需要两个参数：初始值和handler。 这个 handler 会在每次我们给赋值的时候被调用 (在工作完成前). 它有三个参数:一个被赋值的属性，旧的值和新的值
1038 |
1039 | 这个例子输出：
1040 |
1041 | -> first
1042 | first -> second
1043 | 如果你想有能力来截取和“否决”它分派的事件，就使用 vetoable() 取代 observable(). 被传递给 vetoable 的handler会在属性被赋新的值_之前_执行
1044 |
1045 | ------
1046 |
1047 | ## By Map
1048 |
1049 | ```kotlin
1050 | class User(val map: Map) {
1051 | val name: String by map
1052 | val age: Int by map
1053 | }
1054 |
1055 | val user = User(mapOf(
1056 | "name" to "John Doe",
1057 | "age" to 25
1058 | ))
1059 |
1060 | println(user.name) // Prints "John Doe"
1061 | println(user.age) // Prints 25
1062 |
1063 | class MutableUser(val map: MutableMap) {
1064 | var name: String by map
1065 | var age: Int by map
1066 | }
1067 |
1068 | // custom impl by Json
1069 | ```
1070 |
1071 | ### 把属性储存在map中
1072 |
1073 | 一个参加的用例是在一个map里存储属性的值。 这经常出现在解析JSON或者做其他的“动态”的事情应用里头。 在这样的情况下，你需要使用map的实例本身作为代理用于代理属性
1074 |
1075 | 在这个例子中，构造函数会接收一个map参数，委托会从这个map中取值 (通过string类型的key，就是属性的名字)，对于 var的变量，我们可以把只读的Map换成 MutableMap就可以了
1076 |
1077 | ------
1078 |
1079 | # Functions and Lambdas
1080 |
1081 | ------
1082 |
1083 | ## Function Declarations
1084 |
1085 | ```kotlin
1086 | fun double(x: Int): Int {
1087 | }
1088 | val result = double(2)
1089 |
1090 | infix fun Int.shl(x: Int): Int {
1091 | ...
1092 | }
1093 | 1 shl 2
1094 |
1095 | fun read(b: Array, off: Int = 0, len: Int = b.size()) {
1096 | ...
1097 | }
1098 |
1099 | fun printHello(name: String?): Unit {
1100 | if (name != null)
1101 | println("Hello ${name}")
1102 | }
1103 |
1104 | fun printHello(name: String?) {
1105 | ...
1106 | }
1107 | ```
1108 |
1109 | ### 函数声明
1110 | 在Kotlin中，函数声明使用关键字 fun
1111 |
1112 | ### 函数用途
1113 | 调用函数使用传统的方法，调用成员函数使用点表达式
1114 |
1115 | ### 中缀表示法
1116 |
1117 | 函数还可以用中缀表示法，当：1. 他们是成员函数 或者 扩展函数；2. 他们只有一个参数；3. 使用infix关键字声明
1118 |
1119 | ### 单个表达式函数
1120 | 当一个函数返回单个表达式，花括号可以省略并且主体由** =**符号之后指定。显式地声明返回类型可选时,这可以由编译器推断。
1121 |
1122 | ### 显式地返回类型
1123 | 函数模块体必须显式地指定返回类型，除非是用于返回Unit， 在这种情况下，它是可选的。 Kotlin不推断返回类型与函数在模块体的功能，因为这些功能可能在模块体有复杂的控制流程， 对于阅读者（有时甚至编译器）来说返回类型将不明显。
1124 |
1125 | ### 返回Unit的函数
1126 | 如果一个函数不返回任何有用的值，它的返回类型是Unit。Unit是一种只有一个值 - Unit`。这个 值不需要显式地返回。Unit返回类型声明也是可选的，可以省略。
1127 |
1128 | ------
1129 |
1130 | ## Function Arguments
1131 |
1132 | ```kotlin
1133 | fun reformat(str: String,
1134 | normalizeCase: Boolean = true,
1135 | upperCaseFirstLetter: Boolean = true,
1136 | wordSeparator: Char = ' ') {
1137 | ...
1138 | }
1139 |
1140 | reformat(str, true, true, false, '_')
1141 | reformat(str,
1142 | normalizeCase = true,
1143 | upperCaseFirstLetter = true,
1144 | wordSeparator = '_'
1145 | )
1146 | reformat(str, wordSeparator = '_')
1147 |
1148 | val a = arrayOf(1, 2, 3)
1149 | val list = asList(-1, 0, *a, 4)
1150 | ```
1151 |
1152 | ### 参数
1153 | 函数参数是使用Pascal表达式，即 name: type。参数用逗号隔开。每个参数必须有显式类型。
1154 |
1155 | ### 默认参数(缺省参数)
1156 | 函数参数有默认值,当对应的参数是省略。与其他语言相比可以减少数量的过载。默认值定义使用后* * = * *类型的值。
1157 |
1158 | ### 命名参数
1159 | 可以在调用函数时使用命名的函数参数。当一个函数有大量的参数或默认参数时这非常方便。使用命名参数我们可以使代码更具有可读性。可以省略部分参数。
1160 |
1161 | ------
1162 |
1163 | ## Function Usage
1164 |
1165 | ```kotlin
1166 | fun double(x: Int): Int = x * 2
1167 | fun double(x: Int) = x * 2
1168 |
1169 | fun asList(vararg ts: T): List {
1170 | val result = ArrayList()
1171 | for (t in ts) // ts is an Array
1172 | result.add(t)
1173 | return result
1174 | }
1175 |
1176 | val list = asList(1, 2, 3)
1177 |
1178 | val a = arrayOf(1, 2, 3)
1179 | val list = asList(-1, 0, *a, 4)
1180 |
1181 | class Sample() {
1182 | fun foo() { print("Foo") }
1183 | }
1184 |
1185 | Sample().foo()
1186 | ```
1187 |
1188 | ### 数量可变的参数(可变参数)
1189 | 函数的（通常最后一个）参数可以使用’vararg`修饰。内部函数vararg类型T是可见的arrayT,即上面的例子中的ts变量是Array类型。当我们调用vararg函数，我们可以一个接一个传递参数，例如 asList(1, 2, 3)或者，如果我们已经有了一个数组 并希望将其内容传递给函数，我们使用spread 操作符（在数组前面加*）
1190 |
1191 | ### 函数作用域(函数范围)
1192 | 在Kotlin中函数可以在文件顶级声明，这意味着您不需要像一些语言如Java、C#或Scala那样创建一个类来持有一个函数。此外 除了顶级函数功能，Kotlin函数也可以在局部声明，作为成员函数和扩展函数.
1193 |
1194 | ### 局部函数
1195 | Kotlin提供局部函数,即一个函数在另一个函数中，局部函数可以访问外部函数的局部变量（即闭包），所以在上面的例子，the visited是局部变量.
1196 |
1197 | ### 成员函数
1198 | 成员函数是一个函数,定义在一个类或对象里，成员函数调用点符号
1199 |
1200 | ------
1201 |
1202 | ## Higher-order Functions
1203 |
1204 | ```kotlin
1205 | fun lock(lock: Lock, body: () -> T): T {
1206 | lock.lock()
1207 | try {
1208 | return body()
1209 | }
1210 | finally {
1211 | lock.unlock()
1212 | }
1213 | }
1214 | ```
1215 |
1216 | ### 高阶函数
1217 |
1218 | 这是个新奇的术语，它指的是函数可以接收函数，或者函数可以返回函数。
1219 |
1220 | 高阶函数是一种能用函数作为参数或者返回值为函数的一种函数。 lock()是高阶函数中一个比较好的例子，它接收一个lock对象和一个函数，获得锁，运行传入的函数，并释放锁。
1221 |
1222 | 我们分析一下上面的代码：函数body拥有函数类型:() -> T 所以body应该是一个不带参数并且返回T类型的值的函数。 它在try代码块中调用，被lock保护的，当lock()函数被调用时返回他的值。
1223 |
1224 | 如果我们想调用lock()函数，我们可以把另一个函数传递给它作为参数(详见 函数引用)。
1225 |
1226 | ### 内联函数
1227 |
1228 | 使用内联函数有时能提高高阶函数的性能。
1229 |
1230 | ------
1231 |
1232 | ## Higher-order Functions
1233 |
1234 | ```kotlin
1235 | fun List.map(transform: (T) -> R): List {
1236 | val result = arrayListOf()
1237 | for (item in this)
1238 | result.add(transform(item))
1239 | return result
1240 | }
1241 |
1242 | val doubled = ints.map { it -> it * 2 }
1243 |
1244 | strings filter {it.length == 5} sortBy {it} map {it.toUpperCase()}
1245 |
1246 | val names = listOf("Jake", "Jesse", "Matt", "Alec")
1247 | val jakes = names.filter { it == "Jake" }
1248 | ```
1249 |
1250 | ### 高阶函数
1251 |
1252 | 另一个高阶函数的例子是 map() ( MapReduce)
1253 |
1254 | 这些约定可以写成 LINQ-风格 的代码:
1255 |
1256 | ```kotlin
1257 | strings filter {it.length == 5} sortBy {it} map {it.toUpperCase()}
1258 | ```
1259 |
1260 | 在Kotlin中, 如果函数的最后一个参数是一个函数，那么该参数可以在括号外指定：
1261 |
1262 | ```kotlin
1263 | lock (lock) {
1264 | sharedResource.operation()
1265 | }
1266 | ```
1267 |
1268 | ------
1269 |
1270 | ## Function Types
1271 | ```kotlin
1272 | fun max(collection: Collection, less: (T, T) -> Boolean): T? {
1273 | var max: T? = null
1274 | for (it in collection)
1275 | if (max == null || less(max, it))
1276 | max = it
1277 | return max
1278 | }
1279 |
1280 | max(strings, { a, b -> a.length() < b.length() })
1281 |
1282 | fun compare(a: String, b: String): Boolean = a.length() < b.length()
1283 | ```
1284 |
1285 | ### 函数类型
1286 |
1287 | 对于一个接收一个函数作为参数的函数，我们必须为该参数指定一个函数类型。
1288 |
1289 | max函数是一个高阶函数, 也就是说 他的第二个参数是一个函数. 这个参数是一个表达式，但它本身也是一个函数, 也就是函数字面量。
1290 |
1291 | 参数 less 是一个 (T, T) -> Boolean类型的函数, 也就是说less函数接收两个T类型的参数并返回一个Boolean值: 如果第一个比第二个小就返回True.
1292 |
1293 | 在第四行代码里, less 被用作为一个函数: 它传入两个T类型的参数.
1294 |
1295 | 如上所写的是就函数类型, 或者还有命名参数, 如果你想文档化每个参数的含义。
1296 |
1297 | ------
1298 |
1299 | ## Lambda Expressions
1300 |
1301 | ```kotlin
1302 | val sum = { x: Int, y: Int -> x + y }
1303 |
1304 | val sum: (Int, Int) -> Int = { x, y -> x + y }
1305 |
1306 | ints.filter { it > 0 }
1307 |
1308 | fun(x: Int, y: Int): Int = x + y
1309 |
1310 | fun(x: Int, y: Int): Int {
1311 | return x + y
1312 | }
1313 |
1314 | ints.filter(fun(item) = item > 0)
1315 |
1316 | // receier
1317 | val sum = fun Int.(other: Int): Int = this + other
1318 | sum : Int.(other: Int) -> Int
1319 | 1.sum(2)
1320 | ```
1321 |
1322 | ### Lambda表达式
1323 |
1324 | 另外，函数表达式也被称作 lambdas 或者 closures。这里有一个最简单的函数表达式： { it.toString() }。它是一段代码在 “it” 变量上调用了 two-string 函数。“it” 是个 built-in 的名字。当你在写这些函数表达式的时候，如果你只有一个参数传入这段代码，你可以用 “it” 引用，这只是一个你不需要定义参数的方法。
1325 |
1326 | 但是当你需要定义参数的时候，或者不止一个参数要定义的时候，语法就是这样的： { x, y -> x + y }。我们可以创建一段代码，一个函数表达式，输入两个参数，然后把它们相加。如果我们愿意，我们可以显示定义类型。
1327 |
1328 | ### Lambda表达式语法
1329 |
1330 | Lambda 表达式的全部语法形式, 也就是函数类型的字面量, 譬如上面的sum的声明。
1331 |
1332 | 一个 lambda 表达式货匿名函数是一个“函数字面值”, 即 一个未声明的函数，但却立即写为表达式。
1333 |
1334 | 这是非常常见的，一个 lambda 表达式只有一个参数。 如果Kotlin能自己计算出自己的数字签名，我们就可以不去声明这个唯一的参数。并且用 it进行隐式声明。
1335 |
1336 | 请注意，如果函数取另一个函数作为最后一个参数，该 lambda 表达式参数可以放在 括号外的参数列表。 语法细则详见 callSuffix.
1337 |
1338 | ### lambda 表达式
1339 |
1340 | 这里有更详细的描述, 但是为了继续这一段，让我们看到一个简短的概述：
1341 |
1342 | - 一个 lambda 表达式总是被大括号包围着。
1343 | - 其参数（如果有的话）被声明在->之前（参数类型可以省略）
1344 | - 函数体在 -> 后面 (如果存在的话).
1345 |
1346 | ### 匿名函数
1347 |
1348 | 上述 lambda 表达式的语法还少了一个东西： 能够指定函数的返回 类型。在大多数情况下, 这是不必要的。因为返回类型可以被自动推断出来. 然而，如果你需要要明确的指定。你需要一个替代语法。匿名函数看起来很像一个普通函数声明, 只是名字被省略了。
1349 |
1350 | ```kotlin
1351 | fun(x: Int, y: Int): Int = x + y
1352 | ```
1353 |
1354 | ### 闭包
1355 |
1356 | 一个 lambda 表达式或者匿名函数（以及一个本地函数本地函数和一个 对象表达式） 可以访问他的_闭包_,即声明在外范围内的变量。与java不同，在闭包中捕获的变量可以被修改。
1357 |
1358 | ### 带接收者得函数字面值
1359 |
1360 | 这样的函数字面量的类型是一个带receiver的函数类型
1361 |
1362 | kotlin提供了使用一个特定的 receiver对象 来调用一个函数的能力. 在函数体内部，你可以调用 接受者对象 的方法而不需要任何额外的限定符。 这和 扩展函数 有点类似，它允你在函数体内访问接收器对象的成员。
1363 |
1364 | ------
1365 |
1366 | ## Inline Functions
1367 |
1368 | ```kotlin
1369 | lock(l) { foo() }
1370 |
1371 | // compiled
1372 | l.lock()
1373 | try {
1374 | foo()
1375 | }
1376 | finally {
1377 | l.unlock()
1378 | }
1379 |
1380 | inline fun lock(lock: Lock, body: () -> T): T {
1381 | // ...
1382 | }
1383 |
1384 | inline fun foo(inlined: () -> Unit,
1385 | noinline notInlined: () -> Unit) {
1386 | // ...
1387 | }
1388 | ```
1389 |
1390 | ### 内联函数
1391 |
1392 | 内联函数和高阶函数经常一起见到。在某些场景下，当你用到泛型的时候，你可以给函数加上 inline 关键字。在编译时，它会用 lambda 表达式替换掉整个函数，整个函数的代码会成为内联代码。
1393 |
1394 | 使用高阶函数会带来一些运行时间效率的损失：每一个函数都是一个对象，并且都会捕获一个闭包。 即那些在函数体内会被访问的变量。 内存分配(对于函数对象和类)和虚拟调用会引入运行时间开销。
1395 |
1396 | 但是在许多情况下通过内联化 lambda 表达式可以消除这类的开销。 我们通过下面的示例函数来分析上面这些内容。如，lock() 函数可以被很容易地在调用点被内联。
1397 |
1398 | inline修饰符会影响函数体本身以及传递过来的lambdas: 所有的这些会被内联到 调用点。内联本身有时会引起生成的代码数量增加，但是如果我们使用得当(不要内联大的函数)。它将在 性能上有所提升，尤其是在超多态(megamorphic)调用点的循环中。
1399 |
1400 | ### 禁止内联（noinline）
1401 |
1402 | 为了预防 有时候你只希望被（作为参数）传递到一个内联函数的lamdas 只有一些被内联，你可以用 noinline 修饰符标记你的参数
1403 |
1404 | ------
1405 |
1406 | ## Extensions
1407 |
1408 | ```kotlin
1409 | fun MutableList.swap(index1: Int, index2: Int) {
1410 | val tmp = this[index1] // 'this' corresponds to the list
1411 | this[index1] = this[index2]
1412 | this[index2] = tmp
1413 | }
1414 |
1415 | val l = mutableListOf(1, 2, 3)
1416 | l.swap(0, 2) // 'this' inside 'swap()' will hold the value of 'l'
1417 |
1418 | val List.lastIndex: Int
1419 | get() = size - 1
1420 |
1421 | fun Date.isTuesday(): Boolean {
1422 | return getDay() == 2
1423 | }
1424 |
1425 | val tuesday = date.isTuesday();
1426 |
1427 | fun Int.biggerThanTen(): Boolean {
1428 | return this > 10
1429 | }
1430 | ```
1431 |
1432 |
1433 | 声明一个扩展函数，我们需要用一个 接收者类型 也就是被扩展的类型来作为他的前缀。 下面是为MutableList添加一个swap方法，这个this关键字在扩展方法内接受对应的对象（在点符号以前传过来的） 现在，我们可以像一个其他方法一样调用MutableList。
1434 |
1435 | ### 函数扩展
1436 |
1437 | Kotlin和c#、Gosu一样，能够扩展一个类的新功能，而无需继承类或使用任何类型的设计模式，如装饰者。 这通过特殊的声明叫做_extensions_。Kotlin支持_extension functions_ 和 extension properties.
1438 |
1439 | 函数扩展是 Kotlin 最强大的特性之一。
1440 |
1441 | 函数扩展可以是任何整形，字面量或者包装类型，也可以在标记为 final 的类上做类似操作。因为扩展函数不是真的给类增加代码，任何人都没有办法去修改一个类，它实际上是创建了一个静态方法，用语法糖来让扩展函数看着像是类自带的方法一样。
1442 |
1443 | Kotlin 有扩展函数的概念。这不是 Kotlin 语言独有的，但是和其他语言里面我们看到的扩展又不太一样。如果我们在纯 Java 语言的环境下添加一个 date 的方法，我们需要写一个 utils 类或者 dates 类，然后增加一个静态方法。它接收一个实例，然后做些事情，可能会返回一个值。
1444 |
1445 | Kotlin 的一个非常好的功能是，它会自动地转换有 getters 和 setters 综合属性的类型。所以我能够替换 getDay() 为 day，因为这个 day 的属性是存在的。它看起来像一个 field，但是实际上是个 property – getter 和 setter 的概念融合在了一起。
1446 |
1447 |
1448 | ### 扩展的静态解析
1449 |
1450 | 扩展不能真正的修改他们继承的类。通过定义一个扩展，你不能在类内插入新成员， 仅仅是通过该类的实例用点表达式去调用这个新函数。
1451 |
1452 | 我们想强调下扩展方法是被静态分发的，即他们不是接收类型的虚方法。
1453 |
1454 | ### Nullable接收者
1455 |
1456 | 注意扩展可被定义为可空的接收类型。这样的扩展可以被对象变量调用， 即使他的值是null，你可以在方法体内检查this == null，这也允许你 在没有检查null的时候调用Kotlin中的toString()：检查发生在扩展方法的内部的时候
1457 |
1458 | ### 扩展属性
1459 |
1460 | 和方法相似，Kotlin支持扩展属性。注意：由于扩展没有实际的将成员插入类中，因此对扩展来说是无效的 属性是有backing field.这就是为什么初始化其不允许有 扩展属性。他们的行为只能显式的使用 getters/setters.
1461 |
1462 | ### 伴生对象的扩展
1463 |
1464 | 如果一个类定义有一个伴生对象 ，你也可以为伴生对象定义 扩展函数和属性，就像伴生对象的其他普通成员，只用用类名作为限定符去调用他们。
1465 |
1466 | ------
1467 |
1468 | # Stdlib
1469 |
1470 | Kotlin标准库 The Kotlin Standard Library provides living essentials for everyday work with Kotlin. These include:
1471 |
1472 | - 有用的高阶函数 Higher-order functions implementing idiomatic patterns (let, apply, use, synchronized, etc).
1473 |
1474 | - 集合操作的扩展函数 Extension functions providing querying operations for collections (eager) and sequences (lazy).
1475 |
1476 | - 字符串等工具函数 Various utilities for working with strings and char sequences.
1477 |
1478 | - 对JDK文件/线程/IO等类的扩展 Extensions for JDK classes making it convenient to work with files, IO, and threading.
1479 |
1480 | ------
1481 |
1482 | ## Types
1483 |
1484 | ```java
1485 | Java Kotlin
1486 |
1487 | java.lang.Object kotlin.Any!
1488 | java.lang.Cloneable kotlin.Cloneable!
1489 | java.lang.Comparable kotlin.Comparable!
1490 | java.lang.Enum kotlin.Enum!
1491 | java.lang.Annotation kotlin.Annotation!
1492 | java.lang.Deprecated kotlin.Deprecated!
1493 | java.lang.Void kotlin.Nothing!
1494 | java.lang.CharSequence kotlin.CharSequence!
1495 | java.lang.String kotlin.String!
1496 | java.lang.Number kotlin.Number!
1497 | java.lang.Throwable kotlin.Throwable!
1498 |
1499 | int[] kotlin.IntArray!
1500 | String[] kotlin.Array<(out) String>!
1501 | ```
1502 |
1503 | ------
1504 |
1505 | ## Functions
1506 |
1507 | ```kotlin
1508 | fun assert(value: Boolean, lazyMessage: () -> Any)
1509 | fun check(value: Boolean, lazyMessage: () -> Any)
1510 | fun require(value: Boolean, lazyMessage: () -> Any)
1511 | fun error(message: Any): Nothing
1512 |
1513 | fun run(block: () -> R): R
1514 | fun synchronized(lock: Any, block: () -> R): R
1515 | fun lazy(initializer: () -> T): Lazy
1516 | fun lazyOf(value: T): Lazy
1517 | fun T.let(block: (T) -> R): R
1518 | fun T.apply(block: T.() -> Unit): T
1519 | fun repeat(times: Int, action: (Int) -> Unit)
1520 | fun with(receiver: T, block: T.() -> R): R
1521 |
1522 | ```
1523 |
1524 | ------
1525 |
1526 | ## Functions
1527 |
1528 | ```kotlin
1529 | inline fun T.apply(block: T.() -> Unit)
1530 | : T { block(); return this }
1531 |
1532 | inline fun T.let(block: (T) -> R): R = block(this)
1533 |
1534 | inline fun with(receiver: T, block: T.() -> R)
1535 | : R = receiver.block()
1536 |
1537 | var u1: User? = null
1538 | val u2 = User("Alice", age = 20, desc = "Wonderful!")
1539 | u1?.apply { sayHello() }
1540 | u2.apply { eat(); sayHello() }
1541 | u1?.let {
1542 | u2.show(it)
1543 | u1.sayHello()
1544 | }
1545 | u2.let { println("user is valid!") }
1546 | with(u2) {
1547 | println("do something on user")
1548 | sayHello()
1549 | }
1550 | ```
1551 |
1552 | ### T.apply
1553 |
1554 | Calls the specified function block with this value as its receiver and returns this value.
1555 |
1556 | ### T.let
1557 |
1558 | Calls the specified function block with this value as its argument and returns its result.
1559 |
1560 | ### with
1561 |
1562 | Calls the specified function block with the given receiver as its receiver and returns its result.
1563 |
1564 | ------
1565 |
1566 | ## Arrays
1567 |
1568 | ```kotlin
1569 | class Array private constructor() {
1570 | val size: Int
1571 | fun get(index: Int): T
1572 | fun set(index: Int, value: T): Unit
1573 |
1574 | fun iterator(): Iterator
1575 | // ...
1576 | }
1577 |
1578 | val asc = Array(5, { i -> (i * i).toString() })
1579 |
1580 | val x: IntArray = arrayOf(1, 2, 3, 4, 5)
1581 | x[0] = x[1] + x[2]
1582 |
1583 | val intArray2 = intArrayOf(2, 4, 6, 8, 10)
1584 | val boolArray1 = arrayOf(true, false, true, false, true)
1585 | val boolArray2 = booleanArrayOf(true, true, false, true)
1586 | val strArray1 = arrayOf("Cat", "Dog", "Rabbit")
1587 |
1588 | // byteArrayOf(), charArrayOf(), shortArrayOf(),
1589 | // longArrayOf(), floatArrayOf()
1590 | ```
1591 |
1592 | ------
1593 |
1594 | ## Array Extensions
1595 |
1596 | ```kotlin
1597 | // create array
1598 | arrayOf()/arrayOfNulls()/emptyArray()/intArrayOf()
1599 |
1600 | // functions
1601 | - get()/set()/iterator()/indices/lastIndex
1602 |
1603 | // extension functions
1604 | - asIterable()/asList()/asSequence()/associate()
1605 | - distinct()/distinctBy()/drop()/dropLast()/binarySearch()
1606 |
1607 | - find()/findLast()
1608 | - fill()/contains()/copyOf()/count()
1609 |
1610 | - elementAt()/elementAtOrNull()/first()/last()
1611 | - all()/any()/filter()/filterNot()/filterTo()/flatten()
1612 |
1613 | - forEach()/forEachIndexed()/map()/mapIndexed()/groupBy()
1614 | - intersect()()/joinTo()/joinToString()
1615 | ```
1616 |
1617 | ------
1618 | ## Collections
1619 |
1620 | ```kotlin
1621 | val numbers: MutableList = mutableListOf(1, 2, 3)
1622 | println(numbers) // prints "[1, 2, 3]"
1623 | numbers.add(4)
1624 |
1625 | val readOnlyView: List = numbers
1626 | readOnlyView.clear() // -> does not compile
1627 |
1628 | val strings = hashSetOf("a", "b", "c", "c")
1629 |
1630 | val items = listOf(1, 2, 3, 4)
1631 | items.last == 4
1632 | items.filter { it % 2 == 0 } // Returns [2, 4]
1633 |
1634 | if (rwList.none { it > 6 }) println("No items above 6")
1635 | val item = rwList.firstOrNull()
1636 |
1637 | val readWriteMap = hashMapOf("foo" to 1, "bar" to 2)
1638 | println(map["foo"])
1639 | val snapshot: Map = HashMap(readWriteMap)
1640 | ```
1641 |
1642 | ------
1643 |
1644 | ## Ranges
1645 |
1646 | ```kotlin
1647 | if (i in 1..10) { // equivalent of 1 <= i && i <= 10
1648 | println(i)
1649 | }
1650 |
1651 | for (i in 1..4) print(i) // prints "1234"
1652 | for (i in 4..1) print(i) // prints nothing
1653 |
1654 | for (i in 4 downTo 1) print(i) // prints "4321"
1655 |
1656 | for (i in 1..4 step 2) print(i) // prints "13"
1657 |
1658 | for (i in 4 downTo 1 step 2) print(i) // prints "42"
1659 |
1660 | // progression with values [1, 3, 5, 7, 9, 11]
1661 | (1..12 step 2).last == 11
1662 |
1663 | // progression with values [1, 4, 7, 10]
1664 | (1..12 step 3).last == 10
1665 |
1666 | // progression with values [1, 5, 9]
1667 | (1..12 step 4).last == 9
1668 | ```
1669 |
1670 | ------
1671 |
1672 | ## Collection Extensions
1673 |
1674 | ```kotlin
1675 | //Iterable, Collection, List, Set, Map
1676 |
1677 | - iterator() // Iterable
1678 | - size/indices/count()/isEmpty()/contains() // Collection
1679 | - lastIndex/get()/indexOf()/listIterator()/subList() // List
1680 |
1681 | // Extensions Functions for List
1682 | - toTypedArray()/toMutableList()
1683 | - isNotEmpty()/?orEmpty()/plus()/plusElement()
1684 | - asReversed()/binarySearch()/findLast()
1685 |
1686 | - dropLast()/takeLast()/reduceRight()
1687 | - getOrNull()/elementAt()/elementAtOrNull()
1688 | - single()/slice()/first()/firstOrNull()/last()
1689 | - +/plus()
1690 |
1691 | // MutableIterable, MutableCollection, MutableList
1692 |
1693 | - add()/addAll()/remove()/removeAt()
1694 | - removeAll()/retainAll()/clear()
1695 | - reverse()/sort()/sortBy()/sortByDescending()/sortWith()
1696 | - +=/plusAssign() -=/minusAssign()
1697 |
1698 | ```
1699 |
1700 | ------
1701 |
1702 | ## Generics
1703 |
1704 | ```java
1705 | - Java’s wildcards are converted into type projections
1706 | - Foo becomes Foo!
1707 | - Foo becomes Foo!
1708 | - Java’s raw types are converted into star projections
1709 | - List becomes List<*>!, i.e. List!
1710 | ```
1711 |
1712 | ```kotlin
1713 | // Array -> Java: Array
1714 | fun copy2(from: Array, to: Array) {
1715 | // ...
1716 | }
1717 |
1718 | // Array -> Java: Array
1719 | fun fill(dest: Array, value: String) {
1720 | // ...
1721 | }
1722 |
1723 | fun T.basicToString() : String { // extension function
1724 | // ...
1725 | }
1726 | ```
1727 |
1728 | ### Kotlin的泛型
1729 |
1730 | - 与Java相似，Kotlin中的类也具有类型参数，一般而言，创建类的实例时，我们需要声明参数的类型，但当参数类型可以从构造函数参数等途径推测时，在创建的过程中可以忽略类型参数：
1731 |
1732 | ```
1733 | val box = Box(1) // 1 has type Int, so the compiler figures out that we are talking about Box
1734 | ```
1735 |
1736 | - 首先，我们考虑一下Java中的通配符（wildcards）的意义。该问题在文档 Effective Java, Item 28: Use bounded wildcards to increase API flexibility中给出了详细的解释。 首先，Java中的泛型类型是不变的，即List并不是List