1. //這是單行注釋 // 
2. /* 
3. 這是多行注釋 
4. */ 
5. // 這和Java的 "package" 差不多. 
6. package com.learnxinyminutes.kotlin 
7.  
8. /* 
9. Kotlin程序入口函數是名為"main". 
10. 這個函數的入參是包含命令行參數的數組 
11. */ 
12. fun main(args: Array<String>) { 
13.     /* 
14.     聲明值是使用"var" 或 "val". 
15.     "val"是一旦分配值后就不能變，不變量，相反"vars" 是聲明變量 
16.     */ 
17.     val fooVal = 10 // 之后就不能再給fooVal分配其他值了 
18.     var fooVar = 10 
19.     fooVar = 20 // fooVar是變量，能夠再次分配值 
20.  
21.     /* 
22.     大多數情況, Kotlin能夠決定一個變量的類型是什么。 
23.     這樣我們不必顯式明確每次去指定變量類型了。 
24.     我們可以通過如下方式明確定義變量類型: 
25.     */ 
26.     val foo : Int = 7 
27.  
28.     /* 
29.     Kotlin包含兩種類型的字符串：與Java字符串相同的escaped strings和新的raw strings, 
30.     escaped strings中的換行符是/n字符串和Java中一樣定義， 
31.     反斜杠是換行符 
32.     */ 
33.     val fooString = "My String Is Here!" 
34.     val barString = "Printing on a new line?/nNo Problem!" 
35.     val bazString = "Do you want to add a tab?/tNo Problem!" 
36.     println(fooString) 
37.     println(barString) 
38.     println(bazString) 
39.  
40.     /* 
41.     行字符串(raw strings)由三個引號分隔 ("""). 
42.     顧名思義能包含新的一行和其他任何字符。 
43.    下面是給fooRawString賦值的是一個函數helloWorld，直至第四行的三個引號才表示賦值結束 
44.     */ 
45.     val fooRawString = """ 
46. fun helloWorld(val name : String) { 
47.    println("Hello, world!") 
48. } 
49. """ 
50.     println(fooRawString) 
51.  
52.     /* 
53.     字符串能保護模板表達式 
54.     模板表達式是以美元符號開始($). 
55.     */ 
56.     val fooTemplateString = "$fooString has ${fooString.length} characters" 
57.     println(fooTemplateString) 
58.  
59.     /* 
60.     對于一個變量是空必須明確指定其是nullable. 
61.     變量可以在其類型后面追加問號?指定其是nullable， 
62.     然后使用?.操作符訪問這個nullable的變量 
63.     也可以使用?: 操作符在其為null時為其分配一種值。 
64.     */ 
65.     var fooNullable: String? = "abc" 
66.     println(fooNullable?.length) // => 3 
67.     println(fooNullable?.length ?: -1) // => 3 
68.     fooNullable = null 
69.     println(fooNullable?.length) // => null 
70.     println(fooNullable?.length ?: -1) // => -1 
71.  
72.     /* 
73.     函數是使用"fun" 定義 
74.     函數參數在函數名后面的括號中指定。函數參數可以有默認值。如果需要，函數返回類型在參數之后指定。 
75.     */ 
76.     fun hello(name: String = "world"): String { 
77.         return "Hello, $name!" 
78.     } 
79.     println(hello("foo")) // => Hello, foo! 
80.     println(hello(name = "bar")) // => Hello, bar! 
81.     println(hello()) // => Hello, world! 
82.  
83.     /* 
84.     一個函數參數可以使用"vararg" 標注， 
85.     能夠讓許多參數傳遞進入函數。 
86.     */ 
87.     fun varargExample(vararg names: Int) { 
88.         println("Argument has ${names.size} elements") 
89.     } 
90.     varargExample() // => Argument has 0 elements 
91.     varargExample(1) // => Argument has 1 elements 
92.     varargExample(1, 2, 3) // => Argument has 3 elements 
93.  
94.     /* 
95.     當一個函數由單個表達式組成時，那么這個卷括號可以被省略。函數內容體是在等于號=之后指定。 
96.     */ 
97.     fun odd(x: Int): Boolean = x % 2 == 1 
98.     println(odd(6)) // => false 
99.     println(odd(7)) // => true 
100.  
101.     // 如果返回類型能被推斷，我們就不必指定了。 
102.     fun even(x: Int) = x % 2 == 0 
103.     println(even(6)) // => true 
104.     println(even(7)) // => false 
105.  
106.     // 函數能用函數作為參數，返回頁首函數。 
107.     fun not(f: (Int) -> Boolean): (Int) -> Boolean { 
108.         return {n -> !f.invoke(n)} 
109.     } 
110.     // Named函數能使用 :: 作為參數指定. 
111.     val notOdd = not(::odd) 
112.     val notEven = not(::even) 
113.     // Lambda 表達式能指定為參數 
114.     val notZero = not {n -> n == 0} 
115.     /* 
116.     如果一個lambda僅有一個參數，它的聲明可以被忽視(隨著 ->一起). 
117.     單個參數名將是"it". 
118.     */ 
119.     val notPositive = not {it > 0} 
120.     for (i in 0..4) { 
121.         println("${notOdd(i)} ${notEven(i)} ${notZero(i)} ${notPositive(i)}") 
122.     } 
123.  
124.     //  "class" 是用來聲明類 
125.     class ExampleClass(val x: Int) { 
126.         fun memberFunction(y: Int): Int { 
127.             return x + y 
128.         } 
129.  
130.         infix fun infixMemberFunction(y: Int): Int { 
131.             return x * y 
132.         } 
133.     } 
134.     /* 
135.     創建新的實例使用構造器 
136.     Kotlin沒有 "new"  
137.     */ 
138.     val fooExampleClass = ExampleClass(7) 
139.     // 成員函數能使用點符號調用 
140.     println(fooExampleClass.memberFunction(4)) // => 11 
141.  
142.     /* 
143.     如果一個函數被"infix"標注，能使用infix notation調用 
144.     下面fooExampleClass infixMemberFunction 4等同于 
145. fooExampleClass.memberFunction(4) 
146.     */ 
147.     println(fooExampleClass infixMemberFunction 4) // => 28 
148.  
149.     /* 
150.    數據類是創建只包含數據的精確方式. 
151.      "hashCode"/"equals" 和 "toString" 等方法會自動產生。 
152.     */ 
153.     data class DataClassExample (val x: Int, val y: Int, val z: Int) 
154.     val fooData = DataClassExample(1, 2, 4) 
155.     println(fooData) // => DataClassExample(x=1, y=2, z=4) 
156.  
157.     // 數據類沒有 "copy" 函數 
158.     val fooCopy = fooData.copy(y = 100) 
159.     println(fooCopy) // => DataClassExample(x=1, y=100, z=4) 
160.  
161.     // 對象能被解構入多個變量。 
162.     val (a, b, c) = fooCopy 
163.     println("$a $b $c") // => 1 100 4 
164.  
165.     // 解構 "for" 循環 
166.     for ((a, b, c) in listOf(fooData)) { 
167.         println("$a $b $c") // => 1 100 4 
168.     } 
169.  
170.     val mapData = mapOf("a" to 1, "b" to 2) 
171.     // Map.Entry 也能解構 
172.     for ((key, value) in mapData) { 
173.         println("$key -> $value") 
174.     } 
175.  
176.     //  "with" 函數類似JavaScript "with" 語句. 
177.     data class MutableDataClassExample (var x: Int, var y: Int, var z: Int) 
178.     val fooMutableData = MutableDataClassExample(7, 4, 9) 
179.     with (fooMutableData) { 
180.         x -= 2 
181.         y += 2 
182.         z-- 
183.     } 
184.     println(fooMutableData) // => MutableDataClassExample(x=5, y=6, z=8) 
185.  
186.     /* 
187.     使用 "listOf" 函數創建集合 
188.     集合是不可變的，元素不能增加和移走 
189.     */ 
190.     val fooList = listOf("a", "b", "c") 
191.     println(fooList.size) // => 3 
192.     println(fooList.first()) // => a 
193.     println(fooList.last()) // => c 
194.     // list元素可通過索引訪問。 
195.     println(fooList[1]) // => b 
196.  
197.     // 一個可變的 list能使用 "mutableListOf" 函數創建 
198.     val fooMutableList = mutableListOf("a", "b", "c") 
199.     fooMutableList.add("d") 
200.     println(fooMutableList.last()) // => d 
201.     println(fooMutableList.size) // => 4 
202.  
203.     // 使用 "setOf"  創建set 
204.     val fooSet = setOf("a", "b", "c") 
205.     println(fooSet.contains("a")) // => true 
206.     println(fooSet.contains("z")) // => false 
207.  
208.     // 使用 "mapOf" f創建map 
209.     val fooMap = mapOf("a" to 8, "b" to 7, "c" to 9) 
210.     // Map values can be accessed by their key. 
211.     println(fooMap["a"]) // => 8 
212.  
213.      //待續 
214. /* 
215.     使用 "generateSequence" f函數創建序列號，它是懶賦值的集合，只有使用時才真正賦值。 
216.     */ 
217.     val fooSequence = generateSequence(1, { it + 1 }) 
218.     val x = fooSequence.take(10).toList() 
219.     println(x) // => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] 
220.  
221.     // 產生 斐波納契案例 
222.     fun fibonacciSequence(): Sequence<Long> { 
223.         var a = 0L 
224.         var b = 1L 
225.  
226.         fun next(): Long { 
227.             val result = a + b 
228.             a = b 
229.             b = result 
230.             return a 
231.         } 
232.  
233.         return generateSequence(::next) 
234.     } 
235.     val y = fibonacciSequence().take(10).toList() 
236.     println(y) // => [1, 1, 2, 3, 5, 8, 13, 21, 34, 55] 
237.  
238.     // Kotlin提供colletion的高階函數。 
239.     val z = (1..9).map {it * 3} 
240.                   .filter {it < 20} 
241.                   .groupBy {it % 2 == 0} 
242.                   .mapKeys {if (it.key) "even" else "odd"} 
243.     println(z) // => {odd=[3, 9, 15], even=[6, 12, 18]} 
244.  
245.     // "for" 循環 
246.     for (c in "hello") { 
247.         println(c) 
248.     } 
249.  
250.     // "while" 循環是和其他語言一樣 
251.     var ctr = 0 
252.     while (ctr < 5) { 
253.         println(ctr) 
254.         ctr++ 
255.     } 
256.     do { 
257.         println(ctr) 
258.         ctr++ 
259.     } while (ctr < 10) 
260.  
261.     /* 
262.     "if" 能表達返回一個值的表達式 
263.     */ 
264.     val num = 5 
265.     val message = if (num % 2 == 0) "even" else "odd" 
266.     println("$num is $message") // => 5 is odd 
267.  
268.     // "when" 能作為"if-else if" 替換 
269.     val i = 10 
270.     when { 
271.         i < 7 -> println("first block") 
272.         fooString.startsWith("hello") -> println("second block") 
273.         else -> println("else block") 
274.     } 
275.  
276.     // "when" 能帶一個參數 
277.     when (i) { 
278.         0, 21 -> println("0 or 21") 
279.         in 1..20 -> println("in the range 1 to 20") 
280.         else -> println("none of the above") 
281.     } 
282.  
283.     // "when" 能用在返回一個值的函數can be used as a function that returns a value. 
284.     var result = when (i) { 
285.         0, 21 -> "0 or 21" 
286.         in 1..20 -> "in the range 1 to 20" 
287.         else -> "none of the above" 
288.     } 
289.     println(result) 
290.  
291.     /* 
292.     使用"is" 操作符檢查類型，如果一個對象傳入類型檢查，就無需再次明確casting 它了 
293.     */ 
294.     fun smartCastExample(x: Any) : Boolean { 
295.         if (x is Boolean) { 
296.             // x is automatically cast to Boolean 
297.             return x 
298.         } else if (x is Int) { 
299.             // x is automatically cast to Int 
300.             return x > 0 
301.         } else if (x is String) { 
302.             // x is automatically cast to String 
303.             return x.isNotEmpty() 
304.         } else { 
305.             return false 
306.         } 
307.     } 
308.     println(smartCastExample("Hello, world!")) // => true 
309.     println(smartCastExample("")) // => false 
310.     println(smartCastExample(5)) // => true 
311.     println(smartCastExample(0)) // => false 
312.     println(smartCastExample(true)) // => true 
313.  
314.     // Smartcast also works with when block 
315.     fun smartCastWhenExample(x: Any) = when (x) { 
316.         is Boolean -> x 
317.         is Int -> x > 0 
318.         is String -> x.isNotEmpty() 
319.         else -> false 
320.     } 
321.  
322.     /* 
323.     Extensions是一個增加新函數到類的方式，類似 C# extension 方法 
324.     */ 
325.     fun String.remove(c: Char): String { 
326.         return this.filter {it != c} 
327.     } 
328.     println("Hello, world!".remove('l')) // => Heo, word! 
329.  
330.     println(EnumExample.A) // => A 
331.     println(ObjectExample.hello()) // => hello 
332. } 
333.  
334. // Enum類似Java enum類型 
335. enum class EnumExample { 
336.     A, B, C 
337. } 
338.  
339. /* 
340. "object"能被用于創建單例對象，不能初始化它，但是能使用名稱引向它。類似 Scala singleton objects. 
341. */ 
342. object ObjectExample { 
343.     fun hello(): String { 
344.         return "hello" 
345.     } 
346. } 
347.  
348. fun useObject() { 
349.     ObjectExample.hello() 
350.     val someRef: Any = ObjectExample // we use objects name just as is 
351. }