Kotlin-Workshop Day #3

Android Academy TLV - Kotlin workshop day #3

Co-created with
Eden Bugdary Machluf and Hadas Peled

Transcript

1. by Hadas Peled, Gil Goldzweig Goldbaum, Eden Bugdary Machluf Shmupidoo 17/10/19 WIFI: Guest Password: BrokenWires@@2019 1
3. ▢ More classes: ❏ Inheritance ❏ Abstract ❏ Interfaces ▢ Data class ▢ Special classes ▢ Pairs ▢ Collections ▢ Constants ▢ Extensions & infix 3
4. ▢ Generics ▢ Higher - Order functions ▢ Inline functions ▢ Java interoperability ▢ Labeled breaks ▢ Reflection ▢ Tips & Tricks 4
6. class MyIntList { fun get(pos: Int): Int { //returns the item in position `pos` } fun addItem(item: Int) { //adds the new item `item` to the list } } 6
7. class MyIntList { fun get(pos: Int): Int { //returns the item in position `pos` } fun addItem(item: Int) { //adds the new item `item` to the list } } 7
8. class MyIntList { fun get(pos: Int): Int { //returns the item in position `pos` } fun addItem(item: Int) { //adds the new item `item` to the list } } 8
9. class MyIntList { fun get(pos: Int): Int { //returns the item in position `pos` } fun addItem(item: Int) { //adds the new item `item` to the list } } 9
10. class MyIntList { fun get(pos: Int): Int { //returns the item in position `pos` } fun addItem(item: Int) { //adds the new item `item` to the list } } 10
11. class MyIntList { fun get(pos: Int): Int { //returns the item in position `pos` } fun addItem(item: Int) { //adds the new item `item` to the list } } 11
12. class MyIntList { fun get(pos: Int): Int { //returns the item in position `pos` } fun addItem(item: Int) { //adds the new item `item` to the list } } 12
13. class MyIntList { fun get(pos: Int): Int { //returns the item in position `pos` } fun addItem(item: Int) { //adds the new item `item` to the list } } val intList: MyIntList 13
14. class MyIntList { fun get(pos: Int): Int { //returns the item in position `pos` } fun addItem(item: Int) { //adds the new item `item` to the list } } 14
15. class MyStringList { fun get(pos: Int): Int { //returns the item in position `pos` } fun addItem(item: Int) { //adds the new item `item` to the list } } 15
16. class MyStringList { fun get(pos: Int): String { //returns the item in position `pos` } fun addItem(item: String) { //adds the new item `item` to the list } } 16
18. class MyList<T> { fun get(pos: Int): T { //returns the item in position `pos` } fun addItem(item: T) { //adds the new item `item` to the list } } 18
19. class MyList<T> { fun get(pos: Int): T { //returns the item in position `pos` } fun addItem(item: T) { //adds the new item `item` to the list } } 19
20. class MyList<T> { fun get(pos: Int): T { //returns the item in position `pos` } fun addItem(item: T) { //adds the new item `item` to the list } } 20
21. class MyList<T> { fun get(pos: Int): T { //returns the item in position `pos` } fun addItem(item: T) { //adds the new item `item` to the list } } 21
22. class MyList<T> { fun get(pos: Int): T { //returns the item in position `pos` } fun addItem(item: T) { //adds the new item `item` to the list } } val intList: MyList<Int> 22
23. class MyList<T> { fun get(pos: Int): T { //returns the item in position `pos` } fun addItem(item: T) { //adds the new item `item` to the list } } val intList: MyList<Int> 23
24. class MyList<T> { fun get(pos: Int): T { //returns the item in position `pos` } fun addItem(item: T) { //adds the new item `item` to the list } } val intList: MyList<Int> 24
25. class MyList<T> { fun get(pos: Int): T { //returns the item in position `pos` } fun addItem(item: T) { //adds the new item `item` to the list } } val intList: MyList<Int> val stringList: MyList<String> 25
27. open class Snack(var needsContainer: Boolean) class TimTam: Snack(false) class Doritos: Snack(true) 27
28. open class Snack(var needsContainer: Boolean) class TimTam: Snack(false) class Doritos: Snack(true) 28
29. open class Snack(var needsContainer: Boolean) class TimTam: Snack(false) class Doritos: Snack(true) 29
30. open class Snack(var needsContainer: Boolean) class TimTam: Snack(false) class Doritos: Snack(true) 30
31. open class Snack(var needsContainer: Boolean) class TimTam: Snack(false) class Doritos: Snack(true) 31
32. open class Snack(var needsContainer: Boolean) class TimTam: Snack(false) class Doritos: Snack(true) 32
34. open class Snack(var needsContainer: Boolean) class TimTam: Snack(false) 34
35. open class Snack(var needsContainer: Boolean) class TimTam: Snack(false) class Refreshments<T>(val snack: T) 35
36. open class Snack(var needsContainer: Boolean) class TimTam: Snack(false) class Refreshments<T>(val snack: T) 36
37. open class Snack(var needsContainer: Boolean) class TimTam: Snack(false) class Refreshments<T>(val snack: T) var refreshments = Refreshments<TimTam>(TimTam()) 37
38. open class Snack(var needsContainer: Boolean) class TimTam: Snack(false) class Refreshments<T>(val snack: T) var refreshments = Refreshments<TimTam>(TimTam()) 38
39. open class Snack(var needsContainer: Boolean) class TimTam: Snack(false) class Refreshments<T>(val snack: T) var refreshments = Refreshments<TimTam>(TimTam()) 39
40. open class Snack(var needsContainer: Boolean) class TimTam: Snack(false) class Refreshments<T>(val snack: T) var refreshments = Refreshments(TimTam()) 40
41. open class Snack(var needsContainer: Boolean) class TimTam: Snack(false) class Refreshments<T>(val snack: T) var refreshments = Refreshments(TimTam()) var stringRefreshments = Refreshments(“String”) //why?? 41
42. open class Snack(var needsContainer: Boolean) class TimTam: Snack(false) class Refreshments<T>(val snack: T) var refreshments = Refreshments(TimTam()) var stringRefreshments = Refreshments(“String”) //why?? var nullRefreshments = Refreshments(null) //why?? 42
43. open class Snack(var needsContainer: Boolean) class TimTam: Snack(false) class Refreshments<T>(val snack: T) var refreshments = Refreshments(TimTam()) var stringRefreshments = Refreshments(“String”) //why?? var nullRefreshments = Refreshments(null) //why?? 43
44. open class Snack(var needsContainer: Boolean) class TimTam: Snack(false) class Refreshments<T: Any?>(val snack: T) var refreshments = Refreshments(TimTam()) var stringRefreshments = Refreshments(“String”) //why?? var nullRefreshments = Refreshments(null) //why?? 44
45. open class Snack(var needsContainer: Boolean) class TimTam: Snack(false) class Refreshments<T: Any>(val snack: T) var refreshments = Refreshments(TimTam()) var stringRefreshments = Refreshments(“String”) //why?? var nullRefreshments = Refreshments(null) //why?? 45
46. open class Snack(var needsContainer: Boolean) class TimTam: Snack(false) class Refreshments<T: Any>(val snack: T) var refreshments = Refreshments(TimTam()) var stringRefreshments = Refreshments(“String”) //why?? var nullRefreshments = Refreshments(null) //why?? 46
47. open class Snack(var needsContainer: Boolean) class TimTam: Snack(false) class Refreshments<T: Any>(val snack: T) var refreshments = Refreshments(TimTam()) var stringRefreshments = Refreshments(“String”) //why?? 47
48. open class Snack(var needsContainer: Boolean) class TimTam: Snack(false) class Refreshments<T: Any>(val snack: T) var refreshments = Refreshments(TimTam()) var stringRefreshments = Refreshments(“String”) //why?? 48
49. open class Snack(var needsContainer: Boolean) class TimTam: Snack(false) class Refreshments<T: Snack>(val snack: T) var refreshments = Refreshments(TimTam()) var stringRefreshments = Refreshments(“String”) //why?? 49
50. open class Snack(var needsContainer: Boolean) class TimTam: Snack(false) class Refreshments<T: Snack>(val snack: T) var refreshments = Refreshments(TimTam()) var stringRefreshments = Refreshments(“String”) //why?? 50
51. open class Snack(var needsContainer: Boolean) class TimTam: Snack(false) class Refreshments<T: Snack>(val snack: T) 51
52. open class Snack(var needsContainer: Boolean) class TimTam: Snack(false) class Refreshments<T: Snack>(val snack: T){ fun waitAtTable(){ check(!snack.needsContainer){"can't serve $snack!"} println("$snack is served") } } 52
53. open class Snack(var needsContainer: Boolean) class TimTam: Snack(false) class Refreshments<T: Snack>(val snack: T){ fun waitAtTable(){ check(!snack.needsContainer){"can't serve $snack!"} println("$snack is served") } } 53
54. open class Snack(var needsContainer: Boolean) class TimTam: Snack(false) class Refreshments<T: Snack>(val snack: T){ fun waitAtTable(){ check(!snack.needsContainer){"can't serve $snack!"} println("$snack is served") } } 54
55. open class Snack(var needsContainer: Boolean) class TimTam: Snack(false) class Refreshments<T: Snack>(val snack: T){ fun waitAtTable(){ check(!snack.needsContainer){"can't serve $snack!"} println("$snack is served") } } 55
56. open class Snack(var needsContainer: Boolean) class TimTam: Snack(false) class Refreshments<T: Snack>(val snack: T){ fun waitAtTable(){ check(!snack.needsContainer){"can't serve $snack!"} println("$snack is served") } } 56
57. open class Snack(var needsContainer: Boolean) class TimTam: Snack(false) class Refreshments<T: Snack>(val snack: T){ fun waitAtTable(){ check(!snack.needsContainer){"can't serve $snack!"} println("$snack is served") } } 57
58. class Refreshments<T: Snack>(val snack: T) { fun waitAtTable() { check(!snack.needsContainer){"can't serve $snack!"} println("$snack is served") } } 58
60. Snack 60
61. Snack 61
62. Snack 62
63. Scarry word Key word What it actually means Snack 63
64. Scarry word Key word What it actually means Snack 64
65. Scarry word Key word What it actually means Snack 65
66. Scarry word Key word What it actually means Snack 66
67. Scarry word Key word What it actually means Invariance var snackRefreshments: Refreshments<Snack> = Refreshments<TimTam>(TimTam()) //ERROR var timtamRefreshments: Refreshments<TimTam> = Refreshments<Snack>(Snack(false)) //ERROR Snack 67
68. Scarry word Key word What it actually means Invariance var snackRefreshments: Refreshments<Snack> = Refreshments<TimTam>(TimTam()) //ERROR var timtamRefreshments: Refreshments<TimTam> = Refreshments<Snack>(Snack(false)) //ERROR Snack 68
69. Scarry word Key word What it actually means Invariance var snackRefreshments: Refreshments<Snack> = Refreshments<TimTam>(TimTam()) //ERROR var timtamRefreshments: Refreshments<TimTam> = Refreshments<Snack>(Snack(false)) //ERROR Snack 69
70. Scarry word Key word What it actually means Invariance var snackRefreshments: Refreshments<Snack> = Refreshments<TimTam>(TimTam()) //ERROR var timtamRefreshments: Refreshments<TimTam> = Refreshments<Snack>(Snack(false)) //ERROR Snack 70
71. Scarry word Key word What it actually means Invariance var snackRefreshments :Refreshments<Snack> = Refreshments<TimTam>(TimTam()) //ERROR var timtamRefreshments: Refreshments<TimTam> = Refreshments<Snack>(Snack(false)) //ERROR Snack 71
72. Scarry word Key word What it actually means Invariance var snackRefreshments: Refreshments<Snack> = Refreshments<TimTam>(TimTam()) //ERROR var timtamRefreshments: Refreshments<TimTam> = Refreshments<Snack>(Snack(false)) //ERROR Snack 72
73. Scarry word Key word What it actually means Invariance var snackRefreshments: Refreshments<Snack> = Refreshments<TimTam>(TimTam()) //ERROR var timtamRefreshments: Refreshments<TimTam> = Refreshments<Snack>(Snack(false)) //ERROR Snack 73
74. class Refreshments<T: Snack>(val snack: T) { fun waitAtTable() { check(!snack.needsContainer) {"can't serve $snack!"} println("$snack is served") } } 74
75. class Refreshments<T: Snack>(val snack: T) { fun waitAtTable() { check(!snack.needsContainer) {"can't serve $snack!"} println("$snack is served") } } fun addItemTo(ref: Refreshments<Snack>) = println("item added") 75
76. class Refreshments<T: Snack>(val snack: T) { fun waitAtTable() { check(!snack.needsContainer) {"can't serve $snack!"} println("$snack is served") } } fun addItemTo(ref: Refreshments<Snack>) = println("item added") 76
77. class Refreshments<T: Snack>(val snack: T) { fun waitAtTable() { check(!snack.needsContainer) {"can't serve $snack!"} println("$snack is served") } } fun addItemTo(ref: Refreshments<Snack>) = println("item added") 77
78. class Refreshments<T: Snack>(val snack: T) { fun waitAtTable() { check(!snack.needsContainer) {"can't serve $snack!"} println("$snack is served") } } fun addItemTo(ref: Refreshments<Snack>) = println("item added") val refreshments = Refreshments(TimTam()) 78
79. class Refreshments<T: Snack>(val snack: T) { fun waitAtTable() { check(!snack.needsContainer) {"can't serve $snack!"} println("$snack is served") } } fun addItemTo(ref: Refreshments<Snack>) = println("item added") val refreshments: Refreshments<TimTam> = Refreshments(TimTam()) 79
80. class Refreshments<T: Snack>(val snack: T) { fun waitAtTable() { check(!snack.needsContainer) {"can't serve $snack!"} println("$snack is served") } } fun addItemTo(ref: Refreshments<Snack>) = println("item added") val refreshments: Refreshments<TimTam> = Refreshments(TimTam()) addItemTo(refreshments) 80
81. class Refreshments<T: Snack>(val snack: T) { fun waitAtTable() { check(!snack.needsContainer) {"can't serve $snack!"} println("$snack is served") } } fun addItemTo(ref: Refreshments<Snack>) = println("item added") val refreshments: Refreshments<TimTam> = Refreshments(TimTam()) addItemTo(refreshments) Type mismatch: inferred type is Refreshments<TimTam> but Refreshments<Snack> was expected 81
82. Scarry word Key word What it actually means Invariance var snackRefreshments: Refreshments<Snack> = Refreshments<TimTam>(TimTam()) //ERROR var timtamRefreshments: Refreshments<TimTam> = Refreshments<Snack>(Snack(false)) //ERROR Covariance out var snackRefreshments: Refreshments<Snack> = Refreshments<TimTam>(TimTam()) //WORK var timtamRefreshments: Refreshments<TimTam> = Refreshments<Snack>(Snack(false)) //ERROR Snack 82
83. Scarry word Key word What it actually means Invariance var snackRefreshments: Refreshments<Snack> = Refreshments<TimTam>(TimTam()) //ERROR var timtamRefreshments: Refreshments<TimTam> = Refreshments<Snack>(Snack(false)) //ERROR Covariance out var snackRefreshments: Refreshments<Snack> = Refreshments<TimTam>(TimTam()) //WORK var timtamRefreshments: Refreshments<TimTam> = Refreshments<Snack>(Snack(false)) //ERROR Snack 83
84. Scarry word Key word What it actually means Invariance var snackRefreshments: Refreshments<Snack> = Refreshments<TimTam>(TimTam()) //ERROR var timtamRefreshments: Refreshments<TimTam> = Refreshments<Snack>(Snack(false)) //ERROR Covariance out var snackRefreshments: Refreshments<Snack> = Refreshments<TimTam>(TimTam()) //WORK var timtamRefreshments: Refreshments<TimTam> = Refreshments<Snack>(Snack(false)) //ERROR Snack 84
85. Scarry word Key word What it actually means Invariance var snackRefreshments: Refreshments<Snack> = Refreshments<TimTam>(TimTam()) //ERROR var timtamRefreshments: Refreshments<TimTam> = Refreshments<Snack>(Snack(false)) //ERROR Covariance out var snackRefreshments: Refreshments<Snack> = Refreshments<TimTam>(TimTam()) //WORK var timtamRefreshments: Refreshments<TimTam> = Refreshments<Snack>(Snack(false)) //ERROR Snack 85
86. Scarry word Key word What it actually means Invariance var snackRefreshments: Refreshments<Snack> = Refreshments<TimTam>(TimTam()) //ERROR var timtamRefreshments: Refreshments<TimTam> = Refreshments<Snack>(Snack(false)) //ERROR Covariance out var snackRefreshments: Refreshments<Snack> = Refreshments<TimTam>(TimTam()) //WORK var timtamRefreshments: Refreshments<TimTam> = Refreshments<Snack>(Snack(false)) //ERROR Snack 86
87. Scarry word Key word What it actually means Invariance var snackRefreshments: Refreshments<Snack> = Refreshments<TimTam>(TimTam()) //ERROR var timtamRefreshments: Refreshments<TimTam> = Refreshments<Snack>(Snack(false)) //ERROR Covariance out var snackRefreshments: Refreshments<Snack> = Refreshments<TimTam>(TimTam()) //WORK var timtamRefreshments: Refreshments<TimTam> = Refreshments<Snack>(Snack(false)) //ERROR Snack 87
88. Scarry word Key word What it actually means Invariance var snackRefreshments: Refreshments<Snack> = Refreshments<TimTam>(TimTam()) //ERROR var timtamRefreshments: Refreshments<TimTam> = Refreshments<Snack>(Snack(false)) //ERROR Covariance out var snackRefreshments: Refreshments<Snack> = Refreshments<TimTam>(TimTam()) //WORK var timtamRefreshments: Refreshments<TimTam> = Refreshments<Snack>(Snack(false)) //ERROR Snack 88
89. Snack 89
90. Rules that prevent us from getting an error 90
91. Rules that prevent us from getting an error • Out type - type parameters that only ever occur in return values of functions, or on val properties. 91
92. class Refreshments<T: Snack>(val snack: T) { fun waitAtTable() { check(!snack.needsContainer) {"can't serve $snack!"} println("$snack is served") } } fun addItemTo(ref: Refreshments<Snack>) = println("item added") val refreshments = Refreshments(TimTam()) 92
93. class Refreshments<T: Snack>(val snack: T) { fun waitAtTable() { check(!snack.needsContainer) {"can't serve $snack!"} println("$snack is served") } } fun addItemTo(ref: Refreshments<Snack>) = println("item added") val refreshments = Refreshments(TimTam()) 93
94. class Refreshments<out T: Snack>(val snack: T) { fun waitAtTable() { check(!snack.needsContainer) {"can't serve $snack!"} println("$snack is served") } } fun addItemTo(ref: Refreshments<Snack>) = println("item added") val refreshments = Refreshments(TimTam()) 94
95. class Refreshments<out T: Snack>(val snack: T) { fun waitAtTable() { check(!snack.needsContainer) {"can't serve $snack!"} println("$snack is served") } } fun addItemTo(ref: Refreshments<Snack>) = println("item added") val refreshments = Refreshments(TimTam()) addItemTo(refreshments) 95
97. open class Snack(var needsContainer: Boolean) class Doritos: Snack(true) 97
98. open class Snack(var needsContainer: Boolean) class Doritos: Snack(true) 98
99. open class Snack(var needsContainer: Boolean) class Doritos: Snack(true) interface Container<T: Snack> { fun contain(snack: T) } 99
100. open class Snack(var needsContainer: Boolean) class Doritos: Snack(true) interface Container<T: Snack> { fun contain(snack: T) } 100
101. open class Snack(var needsContainer: Boolean) class Doritos: Snack(true) interface Container<T: Snack> { fun contain(snack: T) } 101
102. open class Snack(var needsContainer: Boolean) class Doritos: Snack(true) interface Container<T: Snack> { fun contain(snack: T) } 102
103. open class Snack(var needsContainer: Boolean) class Doritos: Snack(true) interface Container<T: Snack> { fun contain(snack: T) } class Bowler: Container<Doritos> { override fun contain(doritos: Doritos) { doritos.getBowl() } } 103
104. open class Snack(var needsContainer: Boolean) class Doritos: Snack(true) interface Container<T: Snack> { fun contain(snack: T) } class Bowler: Container<Doritos> { override fun contain(doritos: Doritos) { doritos.getBowl() } } 104
105. open class Snack(var needsContainer: Boolean) class Doritos: Snack(true) interface Container<T: Snack> { fun contain(snack: T) } class Bowler: Container<Doritos> { override fun contain(doritos: Doritos) { doritos.getBowl() } } 105
106. open class Snack(var needsContainer: Boolean) class Doritos: Snack(true) interface Container<T: Snack> { fun contain(snack: T) } class Bowler: Container<Doritos> { override fun contain(doritos: Doritos) { doritos.getBowl() } } 106
107. open class Snack(var needsContainer: Boolean) class Doritos: Snack(true) interface Container<T: Snack> { fun contain(snack: T) } class Bowler: Container<Doritos> { override fun contain(doritos: Doritos) { doritos.getBowl() } } 107
108. open class Snack(var needsContainer: Boolean) class Doritos: Snack(true) { fun getBowl() { needsContainer = false } } interface Container<T: Snack> { fun contain(snack: T) } class Bowler: Container<Doritos> { override fun contain(doritos: Doritos) { doritos.getBowl() } } 108
109. open class Snack(var needsContainer: Boolean) class Doritos: Snack(true) { fun getBowl() { needsContainer = false } } interface Container<T: Snack> { fun contain(snack: T) } class Bowler: Container<Doritos> { override fun contain(doritos: Doritos) { doritos.getBowl() } } 109
110. class Refreshments<out T: Snack>(val snack: T) { fun waitAtTable() { check(!snack.needsContainer) {"can't serve $snack!"} println("$snack is served") } } 110
111. class Refreshments<out T: Snack>(val snack: T) { fun waitAtTable() { check(!snack.needsContainer) {"can't serve $snack!"} println("$snack is served") } } 111
112. class Refreshments<out T: Snack>(val snack: T) { fun waitAtTable(container: Container<T>) { check(!snack.needsContainer) {"can't serve $snack!"} println("$snack is served") } } 112
113. class Refreshments<out T: Snack>(val snack: T) { fun waitAtTable(container: Container<T>) { check(!snack.needsContainer) {"can't serve $snack!"} println("$snack is served") } } Type parameter T is declared as 'out' but occurs in 'invariant' position in type Container<T> 113
114. class Refreshments<out T: Snack>(val snack: T) { fun waitAtTable(container: Container<T>) { check(!snack.needsContainer) {"can't serve $snack!"} println("$snack is served") } } interface Container<T: Snack> { fun contain(snack: T) } 114
115. class Refreshments<out T: Snack>(val snack: T) { fun waitAtTable(container: Container<T>) { check(!snack.needsContainer) {"can't serve $snack!"} println("$snack is served") } } interface Container<T: Snack> { fun contain(snack: T) } 115
116. class Refreshments<out T: Snack>(val snack: T) { fun waitAtTable(container: Container<T>) { check(!snack.needsContainer) {"can't serve $snack!"} println("$snack is served") } } interface Container<T: Snack> { fun contain(snack: T) fun spillSnack(): T } 116
117. class Refreshments<out T: Snack>(val snack: T) { fun waitAtTable(container: Container<T>) { check(!snack.needsContainer) {"can't serve $snack!"} println("$snack is served") } } interface Container<T: Snack> { fun contain(snack: T) fun spillSnack(): T } 117
118. class Refreshments<out T: Snack>(val snack: T) { fun waitAtTable(container: Container<T>) { val snackBrother: T = container.spillSnack() check(!snack.needsContainer) {"can't serve $snack!"} println("$snack is served") } } interface Container<T: Snack> { fun contain(snack: T) fun spillSnack(): T } 118
119. class Refreshments<out T: Snack>(val snack: T) { fun waitAtTable(container: Container<T>) { val snackBrother: T = container.spillSnack() check(!snack.needsContainer) {"can't serve $snack!"} println("$snack is served") } } interface Container<T: Snack> { fun contain(snack: T) fun spillSnack(): T } 119
120. class Refreshments<out T: Snack>(val snack: T) { fun waitAtTable(container: Container<T>) { val snackBrother: T = container.spillSnack() check(!snack.needsContainer) {"can't serve $snack!"} println("$snack is served") } } interface Container<T: Snack> { fun contain(snack: T) fun spillSnack(): T } Snack 120
121. class Refreshments<out T: Snack>(val snack: T) { fun waitAtTable(container: Container<T>) { val snackBrother: T = container.spillSnack() check(!snack.needsContainer) {"can't serve $snack!"} println("$snack is served") } } interface Container<T: Snack> { fun contain(snack: T) fun spillSnack(): T } 121
122. class Refreshments<out T: Snack>(val snack: T) { fun waitAtTable(container: Container<T>) { val snackBrother: T = container.spillSnack() check(!snack.needsContainer) {"can't serve $snack!"} println("$snack is served") } } interface Container<out T: Snack> { fun contain(snack: T) fun spillSnack(): T } 122
123. class Refreshments<out T: Snack>(val snack: T) { fun waitAtTable(container: Container<T>) { val snackBrother: T = container.spillSnack() check(!snack.needsContainer) {"can't serve $snack!"} println("$snack is served") } } interface Container<out T: Snack> { fun contain(snack: T) fun spillSnack(): T } Type parameter T is declared as 'out' but occurs in 'in' position in type Container<T> 123
124. Scarry word Key word What it actually means Invariance var snackRefreshments :Refreshments<Snack> = Refreshments<TimTam>(TimTam()) //ERROR var timtamRefreshments :Refreshments<TimTam> = Refreshments<Snack>(Snack(false)) //ERROR Covariance out var snackRefreshments :Refreshments<Snack> = Refreshments<TimTam>(TimTam()) //WORK var timtamRefreshments :Refreshments<TimTam> = Refreshments<Snack>(Snack(false)) //ERROR Contravariance in var snackRefreshments :Refreshments<Snack> = Refreshments<TimTam>(TimTam()) //ERROR var timtamRefreshments :Refreshments<TimTam> = Refreshments<Snack>(Snack(false)) //WORK Snack 124
125. Scarry word Key word What it actually means Invariance var snackRefreshments :Refreshments<Snack> = Refreshments<TimTam>(TimTam()) //ERROR var timtamRefreshments :Refreshments<TimTam> = Refreshments<Snack>(Snack(false)) //ERROR Covariance out var snackRefreshments :Refreshments<Snack> = Refreshments<TimTam>(TimTam()) //WORK var timtamRefreshments :Refreshments<TimTam> = Refreshments<Snack>(Snack(false)) //ERROR Contravariance in var snackRefreshments :Refreshments<Snack> = Refreshments<TimTam>(TimTam()) //ERROR var timtamRefreshments :Refreshments<TimTam> = Refreshments<Snack>(Snack(false)) //WORK Snack 125
126. Scarry word Key word What it actually means Invariance var snackRefreshments :Refreshments<Snack> = Refreshments<TimTam>(TimTam()) //ERROR var timtamRefreshments :Refreshments<TimTam> = Refreshments<Snack>(Snack(false)) //ERROR Covariance out var snackRefreshments :Refreshments<Snack> = Refreshments<TimTam>(TimTam()) //WORK var timtamRefreshments :Refreshments<TimTam> = Refreshments<Snack>(Snack(false)) //ERROR Contravariance in var snackRefreshments :Refreshments<Snack> = Refreshments<TimTam>(TimTam()) //ERROR var timtamRefreshments :Refreshments<TimTam> = Refreshments<Snack>(Snack(false)) //WORK Snack 126
127. Scarry word Key word What it actually means Invariance var snackRefreshments :Refreshments<Snack> = Refreshments<TimTam>(TimTam()) //ERROR var timtamRefreshments :Refreshments<TimTam> = Refreshments<Snack>(Snack(false)) //ERROR Covariance out var snackRefreshments :Refreshments<Snack> = Refreshments<TimTam>(TimTam()) //WORK var timtamRefreshments :Refreshments<TimTam> = Refreshments<Snack>(Snack(false)) //ERROR Contravariance in var snackRefreshments :Refreshments<Snack> = Refreshments<TimTam>(TimTam()) //ERROR var timtamRefreshments :Refreshments<TimTam> = Refreshments<Snack>(Snack(false)) //WORK Snack 127
128. Scarry word Key word What it actually means Invariance var snackRefreshments :Refreshments<Snack> = Refreshments<TimTam>(TimTam()) //ERROR var timtamRefreshments :Refreshments<TimTam> = Refreshments<Snack>(Snack(false)) //ERROR Covariance out var snackRefreshments :Refreshments<Snack> = Refreshments<TimTam>(TimTam()) //WORK var timtamRefreshments :Refreshments<TimTam> = Refreshments<Snack>(Snack(false)) //ERROR Contravariance in var snackRefreshments :Refreshments<Snack> = Refreshments<TimTam>(TimTam()) //ERROR var timtamRefreshments :Refreshments<TimTam> = Refreshments<Snack>(Snack(false)) //WORK Snack 128
129. Scarry word Key word What it actually means Invariance var snackRefreshments :Refreshments<Snack> = Refreshments<TimTam>(TimTam()) //ERROR var timtamRefreshments :Refreshments<TimTam> = Refreshments<Snack>(Snack(false)) //ERROR Covariance out var snackRefreshments :Refreshments<Snack> = Refreshments<TimTam>(TimTam()) //WORK var timtamRefreshments :Refreshments<TimTam> = Refreshments<Snack>(Snack(false)) //ERROR Contravariance in var snackRefreshments :Refreshments<Snack> = Refreshments<TimTam>(TimTam()) //ERROR var timtamRefreshments :Refreshments<TimTam> = Refreshments<Snack>(Snack(false)) //WORK Snack 129
130. Snack 130
131. Rules that prevent us from getting an error • Out type - type parameters that only ever occur in return values of functions, or on val properties. 131
132. Rules that prevent us from getting an error • Out type - type parameters that only ever occur in return values of functions, or on val properties. • In type - type parameters that only ever occur as an argument to functions. 132
133. interface Container<T: Snack> { fun contain(snack: T) } 133
134. interface Container<T: Snack> { fun contain(snack: T) } 134
135. interface Container<in T: Snack> { fun contain(snack: T) } 135
136. class Refreshments<out T: Snack>(val snack: T) { fun waitAtTable(container: Container<T>) { check(!snack.needsContainer) {"can't serve $snack!"} println("$snack is served") } } interface Container<T: Snack> { fun contain(snack: T) } 136
137. class Refreshments<out T: Snack>(val snack: T) { fun waitAtTable(container: Container<T>) { //check(!snack.needsContainer) {"can't serve $snack!"} println("$snack is served") } } interface Container<T: Snack> { fun contain(snack: T) } 137
138. class Refreshments<out T: Snack>(val snack: T) { fun waitAtTable(container: Container<T>) { //check(!snack.needsContainer) {"can't serve $snack!"} if(snack.needsContainer) { container.contain(snack) } println("$snack is served") } } interface Container<T: Snack> { fun contain(snack: T) } 138
139. class Refreshments<out T: Snack>(val snack: T) { fun waitAtTable(container: Container<T>) { //check(!snack.needsContainer) {"can't serve $snack!"} if(snack.needsContainer) { container.contain(snack) } println("$snack is served") } } interface Container<T: Snack> { fun contain(snack: T) } 139
140. class Refreshments<out T: Snack>(val snack: T) { fun waitAtTable(container: Container<T>) { //check(!snack.needsContainer) {"can't serve $snack!"} if(snack.needsContainer) { container.contain(snack) } println("$snack is served") } } interface Container<T: Snack> { fun contain(snack: T) } 140
141. class Refreshments<out T: Snack>(val snack:T) { fun waitAtTable(container: Container<T>) { //check(!snack.needsContainer) {"can't serve $snack!"} if(snack.needsContainer) { container.contain(snack) } println("$snack is served") } } interface Container<T: Snack> { fun contain(snack: T) } Refreshments(Doritos()).waitAtTable(Bowler()) 141
144. fun isContainerNeeded(refreshment: Refreshments<Snack>) { println("Is container needed? ${refreshment.snack.needsContainer}") } isContainerNeeded(refreshment) 144
145. fun isContainerNeeded(refreshment: Refreshments<Snack>) { println("Is container needed? ${refreshment.snack.needsContainer}") } isContainerNeeded(refreshment) 145
146. fun isContainerNeeded(refreshment: Refreshments<Snack>) { println("Is container needed? ${refreshment.snack.needsContainer}") } isContainerNeeded(refreshment) 146
147. fun isContainerNeeded(refreshment: Refreshments<Snack>) { println("Is container needed? ${refreshment.snack.needsContainer}") } isContainerNeeded(refreshment) 147
148. fun <T : Snack> isContainerNeeded(refreshment: Refreshments<T>) { println("Is container needed? ${refreshment.snack.needsContainer}") } isContainerNeeded(refreshment) 148
149. fun <T : Snack> isContainerNeeded(refreshment: Refreshments<T>) { println("Is container needed? ${refreshment.snack.needsContainer}") } isContainerNeeded(refreshment) 149
150. fun <T : Snack> isContainerNeeded(refreshment: Refreshments<T>) { println("Is container needed? ${refreshment.snack.needsContainer}") } isContainerNeeded(refreshment) 150
151. fun <T : Snack> isContainerNeeded(refreshment: Refreshments<T>) { println("Is container needed? ${refreshment.snack.needsContainer}") } isContainerNeeded(refreshment) 151
152. fun <T : Snack> isContainerNeeded(refreshment: Refreshments<T>) { println("Is container needed? ${refreshment.snack.needsContainer}") } isContainerNeeded(refreshment) //Is container needed? true 152
154. Function: fun makeFood(hangerLevel: Int) { if (hangerLevel > 5) { println("Give a lot of food !") } else { println("Only a refreshment") } } 154
155. Function: fun makeFood(hangerLevel: Int) { if (hangerLevel > 5) { println("Give a lot of food !") } else { println("Only a refreshment") } } 155
156. Function: fun makeFood(hangerLevel: Int) { if (hangerLevel > 5) { println("Give a lot of food !") } else { println("Only a refreshment") } } 156
157. Function: fun makeFood(hangerLevel: Int) { if (hangerLevel > 5) { println("Give a lot of food !") } else { println("Only a refreshment") } } 157
158. Method: class Refreshments(val snack: Snack) { fun waitAtTable(container: Container) { println("$snack is served") } } 158
159. Method: class Refreshments(val snack: Snack) { fun waitAtTable(container: Container) { println("$snack is served") } } 159
160. Method: class Refreshments(val snack: Snack) { fun waitAtTable(container: Container) { println("$snack is served") } } 160
161. class Refreshments<T :Snack>(val snack :T){ fun <R : Snack> hasRefreshmentOfType() = snack is R //.. } 161
162. class Refreshments<T :Snack>(val snack :T){ fun <R : Snack> hasRefreshmentOfType() = snack is R //.. } 162
163. class Refreshments<T :Snack>(val snack :T){ fun < R : Snack> hasRefreshmentOfType() = snack is R //.. } inline reified Generic types are normally only available at compile time, and get replaced with the actual types. 163
164. inline fun <reified T: Snack> Snack.isOfType() = this is T var refreshment = Refreshments(Doritos()) println(refreshment.snack.isOfType<TimTam>()) 164
165. inline fun <reified T: Snack> Snack.isOfType() = this is T var refreshment = Refreshments(Doritos()) println(refreshment.snack.isOfType<TimTam>()) 165
166. inline fun <reified T: Snack> Snack.isOfType() = this is T var refreshment = Refreshments(Doritos()) println(refreshment.snack.isOfType<TimTam>()) 166
167. inline fun <reified T: Snack> Snack.isOfType() = this is T var refreshment = Refreshments(Doritos()) println(refreshment.snack.isOfType<TimTam>()) 167
168. inline fun <reified T: Snack> Snack.isOfType() = this is T var refreshment = Refreshments(Doritos()) println(refreshment.snack.isOfType<TimTam>()) //false 168
169. Star-projections are much like raw types in the Java programming language, but safe. 169
170. inline fun <reified R : Snack> Refreshments<*>.hasRefreshmentOfType() = snack is R var refreshment = Refreshments(Doritos()) println(refreshment.hasRefreshmentOfType<Doritos>()) //true 170
171. inline fun <reified R : Snack> Refreshments<*>.hasRefreshmentOfType() = snack is R var refreshment = Refreshments(Doritos()) println(refreshment.hasRefreshmentOfType<Doritos>()) //true 171
172. inline fun <reified R : Snack> Refreshments<*>.hasRefreshmentOfType() = snack is R var refreshment = Refreshments(Doritos()) println(refreshment.hasRefreshmentOfType<Doritos>()) //true 172
173. inline fun <reified R : Snack> Refreshments<*>.hasRefreshmentOfType() = snack is R var refreshment = Refreshments(Doritos()) println(refreshment.hasRefreshmentOfType<Doritos>()) //true 173
174. inline fun <reified R : Snack> Refreshments<*>.hasRefreshmentOfType() = snack is R var refreshment = Refreshments(Doritos()) println(refreshment.hasRefreshmentOfType<Doritos>()) //true 174
175. inline fun <reified R : Snack> Refreshments<*>.hasRefreshmentOfType() = snack is R var refreshment = Refreshments(Doritos()) println(refreshment.hasRefreshmentOfType<Doritos>()) //true 175
176. inline fun <reified R : Snack> Refreshments<*>.hasRefreshmentOfType() = snack is R var refreshment = Refreshments(Doritos()) println(refreshment.hasRefreshmentOfType<Doritos>()) //true 176
177. WORKSHOP!!! 177
178. • Kotlin functions are first-class ◦ Can be stored in variables and data structures ◦ passed as arguments to and returned from other functions. 178
179. fun main(list: List<Int>) { list.forEach { } } 179
180. fun <T> List<T>.forEach(loop: (T) -> Unit) { for (element in this) { loop(element) } } 180
181. fun <T> List<T>.forEach(loop: (T) -> Unit) { for (element in this) { loop(element) } } 181
182. fun <T> List<T>.forEach(loop: (T) -> Unit) { for (element in this) { loop(element) } } 182
183. (T) -> Unit 183
184. (T) -> Unit 184
185. (T) -> Unit 185
186. (T) -> String 186
187. (T) -> Int 187
188. (T) -> Int 188
189. ((T) -> Int)?) 189
190. fun <T> List<T>.forEach(loop: (T) -> Unit) { for (element in this) { loop(element) } } 190
191. fun <T> List<T>.forEach(loop: (T) -> Unit) { for (element in this) { loop(element) } } 191
192. fun <T> List<T>.forEach(loop: (T) -> Unit) { for (element in this) { loop(element) } } 192
193. fun main(list: List<Int>) { } 193
194. fun main(list: List<Int>) { list.forEach() } 194
195. fun main(list: List<Int>) { list.forEach({ }) } 195
196. fun main(list: List<Int>) { list.forEach({ element: Int -> }) } 196
197. fun main(list: List<Int>) { list.forEach({ element: Int -> }) } 197
198. fun main(list: List<Int>) { list.forEach({ element: Int -> }) } 198
199. fun main(list: List<Int>) { list.forEach({ element: Int -> }) } 199
200. fun main(list: List<Int>) { list.forEach({ element: Int -> // Smart cast to Int }) } 200
201. fun main(list: List<Int>) { list.forEach({ element -> }) } 201
202. fun main(list: List<Int>) { list.forEach({ }) } 202
203. fun main(list: List<Int>) { list.forEach({ it // Our element will be called 'it' }) } 203
204. fun main(list: List<Int>) { list.forEach({ }) } 204
205. fun main(list: List<Int>) { list.forEach({ }) } 205
206. fun main(list: List<Int>) { list.forEach { } } 206
207. fun main(list: List<Int>) { list.forEach { } } 207
208. fun main(list: List<Int>) { list.forEach { } } 208
209. fun main(list: List<List<Int>>) { list.forEach { } } 209
210. fun main(list: List<List<Int>>) { list.forEach { it } } 210
211. fun main(list: List<List<Int>>) { list.forEach { it.forEach { } } } 211
212. fun main(list: List<List<Int>>) { list.forEach { it.forEach { it } } } 212
213. fun main(list: List<List<Int>>) { list.forEach { it.forEach { it } } } 213
214. fun main(list: List<List<Int>>) { list.forEach { it.forEach { it } } } 214
215. fun main(list: List<List<Int>>) { list.forEach { it.forEach { it } } } 215
216. fun main(list: List<List<Int>>) { list.forEach { numbersList -> numbersList.forEach { number -> number } } } 216
217. fun main(list: List<Int>) { list.forEach { } } 217
218. fun print(data: Int) { println(data) } 218
219. fun main(list: List<Int>) { list.forEach { } } 219
220. fun main(list: List<Int>) { list.forEach(print) } 220
221. fun main(list: List<Int>) { list.forEach(::print) } 221
222. fun main(list: List<Int>) { list.forEach { } } 222
224. fun <T> List<T>.forEach(loop: (T) -> Unit) { for (element in this) { loop(element) } } 224
225. public static void forEach(List $receiver, Function1 loop) { Intrinsics.checkParameterIsNotNull($receiver, "$receiver"); Intrinsics.checkParameterIsNotNull(loop, "loop"); Iterator var3 = $receiver.iterator(); while(var3.hasNext()) { Object element = var3.next(); loop.invoke(element); } } 225
226. public static void forEach(List $receiver, Function1 loop) { Intrinsics.checkParameterIsNotNull($receiver, "$receiver"); Intrinsics.checkParameterIsNotNull(loop, "loop"); Iterator var3 = $receiver.iterator(); while(var3.hasNext()) { Object element = var3.next(); loop.invoke(element); } } 226
227. public static void forEach(List $receiver, Function1 loop) { Intrinsics.checkParameterIsNotNull($receiver, "$receiver"); Intrinsics.checkParameterIsNotNull(loop, "loop"); Iterator var3 = $receiver.iterator(); while(var3.hasNext()) { Object element = var3.next(); loop.invoke(element); } } 227
228. public static void forEach(List $receiver, Function1 loop) { Intrinsics.checkParameterIsNotNull($receiver, "$receiver"); Intrinsics.checkParameterIsNotNull(loop, "loop"); Iterator var3 = $receiver.iterator(); while(var3.hasNext()) { Object element = var3.next(); loop.invoke(element); } } 228
229. public static void forEach(List $receiver, Function1 loop) { Intrinsics.checkParameterIsNotNull($receiver, "$receiver"); Intrinsics.checkParameterIsNotNull(loop, "loop"); Iterator var3 = $receiver.iterator(); while(var3.hasNext()) { Object element = var3.next(); loop.invoke(element); } } 229
230. public static void forEach(List $receiver, Function1 loop) { Intrinsics.checkParameterIsNotNull($receiver, "$receiver"); Intrinsics.checkParameterIsNotNull(loop, "loop"); Iterator var3 = $receiver.iterator(); while(var3.hasNext()) { Object element = var3.next(); loop.invoke(element); } } 230
231. fun <T> List<T>.forEach(loop: (T) -> Unit) { for (element in this) { loop(element) } } fun notInlined(elements: List<Int>) { elements.forEach { println("NoInlined: $it") } } 231
232. public static void notInlined(List elements) { Intrinsics.checkParameterIsNotNull(elements, "elements"); forEach(elements, new Function1<Int>() { @Override public void invoke(element: Int) { System.out.println("NoInlined: " + element); } }); ); } 232
233. public static void notInlined(List elements) { Intrinsics.checkParameterIsNotNull(elements, "elements"); forEach(elements, new Function1<Int>() { @Override public void invoke(element: Int) { System.out.println("NoInlined: " + element); } }); ); } 233
234. public static void notInlined(List elements) { Intrinsics.checkParameterIsNotNull(elements, "elements"); forEach(elements, new Function1<Int>() { @Override public void invoke(element: Int) { System.out.println("NoInlined: " + element); } }); ); } 234
235. public static void notInlined(List elements) { Intrinsics.checkParameterIsNotNull(elements, "elements"); forEach(elements, new Function1<Int>() { @Override public void invoke(element: Int) { System.out.println("NoInlined: " + element); } }); ); } 235
236. public static void notInlined(List elements) { Intrinsics.checkParameterIsNotNull(elements, "elements"); forEach(elements, new Function1<Int>() { @Override public void invoke(element: Int) { System.out.println("NoInlined: " + element); } }); ); } 236
237. public static void notInlined(List elements) { Intrinsics.checkParameterIsNotNull(elements, "elements"); forEach(elements, new Function1<Int>() { @Override public void invoke(element: Int) { System.out.println("NoInlined: " + element); } }); ); } 237
238. public static void notInlined(List elements) { Intrinsics.checkParameterIsNotNull(elements, "elements"); forEach(elements, new Function1<Int>() { @Override public void invoke(element: Int) { System.out.println("NoInlined: " + element); } }); ); } 238
239. public static void notInlined(List elements) { Intrinsics.checkParameterIsNotNull(elements, "elements"); forEach(elements, new Function1<Int>() { @Override public void invoke(element: Int) { System.out.println("NoInlined: " + element); } }); ); } 239
240. fun <T> List<T>.forEach(loop: (T) -> Unit) { for (element in this) { loop(element) } } fun notInlined(elements: List<Int>) { elements.forEach { println("NotInlined: $it") } } 240
241. inline fun <T> List<T>.forEach(loop: (T) -> Unit) { for (element in this) { loop(element) } } fun notInlined(elements: List<Int>) { elements.forEach { println("NotInlined: $it") } } 241
242. inline fun <T> List<T>.forEach(loop: (T) -> Unit) { for (element in this) { loop(element) } } fun notInlined(elements: List<Int>) { elements.forEach { println("NotInlined: $it") } } 242
243. inline fun <T> List<T>.forEach(loop: (T) -> Unit) { for (element in this) { loop(element) } } fun inlined(elements: List<Int>) { elements.forEach { println("Inlined: $it") } } 243
244. inline fun <T> List<T>.forEach(loop: (T) -> Unit) { for (element in this) { loop(element) } } fun inlined(elements: List<Int>) { elements.forEach { println("Inlined: $it") } } 244
245. public static void forEach(List $receiver, Function1 loop) { Intrinsics.checkParameterIsNotNull($receiver, "$receiver"); Intrinsics.checkParameterIsNotNull(loop, "loop"); Iterator var3 = $receiver.iterator(); while(var3.hasNext()) { Object element = var3.next(); loop.invoke(element); } } 245
246. inline fun <T> List<T>.forEach(loop: (T) -> Unit) { for (element in this) { loop(element) } } fun inlined(elements: List<Int>) { elements.forEach { println("Inlined: $it") } } 246
247. public static void inlined(List elements) { Iterable iterable = (Iterable)elements; Iterator var3 = iterable.iterator(); while(var3.hasNext()) { Object element = var3.next(); int it = ((Number)element).intValue(); String var7 = "Inlined: " + it; System.out.println(var7); } } 247
248. public static void inlined(List elements) { Iterable iterable = (Iterable)elements; Iterator var3 = iterable.iterator(); while(var3.hasNext()) { Object element = var3.next(); int it = ((Number)element).intValue(); String var7 = "Inlined: " + it; System.out.println(var7); } } 248
249. public static void inlined(List elements) { Iterable iterable = (Iterable)elements; Iterator var3 = iterable.iterator(); while(var3.hasNext()) { Object element = var3.next(); int it = ((Number)element).intValue(); String var7 = "Inlined: " + it; System.out.println(var7); } } 249
250. public static void inlined(List elements) { Iterable iterable = (Iterable)elements; Iterator var3 = iterable.iterator(); while(var3.hasNext()) { Object element = var3.next(); int it = ((Number)element).intValue(); String var7 = "Inlined: " + it; System.out.println(var7); } } 250
251. public static void inlined(List elements) { Iterable iterable = (Iterable)elements; Iterator var3 = iterable.iterator(); while(var3.hasNext()) { Object element = var3.next(); int it = ((Number)element).intValue(); String var7 = "Inlined: " + it; System.out.println(var7); } } 251
253. inline fun <T> List<T>.a(lambda: (T) -> Unit) { inlineForEach(lambda) inlineForEach(lambda) inlineForEach(lambda) InlineForEach(lambda) } 253
254. Iterable iterable = (Iterable)elements; Iterator var3 = iterable.iterator(); while(var3.hasNext()) { Object element = var3.next(); int it = ((Number)element).intValue(); String var7 = "Inlined: " + it; System.out.println(var7); } 254
255. Iterable iterable = (Iterable)elements; Iterator var3 = iterable.iterator(); while(var3.hasNext()) { Object element = var3.next(); int it = ((Number)element).intValue(); String var7 = "Inlined: " + it; System.out.println(var7); } Iterable iterable = (Iterable)elements; Iterator var3 = iterable.iterator(); while(var3.hasNext()) { Object element = var3.next(); int it = ((Number)element).intValue(); String var7 = "Inlined: " + it; System.out.println(var7); } Iterable iterable = (Iterable)elements; Iterator var3 = iterable.iterator(); while(var3.hasNext()) { Object element = var3.next(); int it = ((Number)element).intValue(); String var7 = "Inlined: " + it; System.out.println(var7); } Iterable iterable = (Iterable)elements; Iterator var3 = iterable.iterator(); while(var3.hasNext()) { Object element = var3.next(); int it = ((Number)element).intValue(); String var7 = "Inlined: " + it; System.out.println(var7); } 255
256. inline fun foo( lambda: () -> Unit, noinline notInlined: () -> Unit ) { ... } 256
258. • let • apply • with 258
260. fun main(nullableString: String?) { val builder = StringBuilder() builder.append("a") builder.append("b") builder.append("c") } 260
261. fun main(nullableString: String?) { val builder = StringBuilder() builder.append("a") builder.append("b") builder.append("c") builder.append(nullableString) } 261
262. fun main(nullableString: String?) { val builder = StringBuilder() builder.append("a") builder.append("b") builder.append("c") nullableString?.let { builder.append(it) } } 262
263. fun main(nullableString: String?) { val builder = StringBuilder() builder.append("a") builder.append("b") builder.append("c") nullableString?.let { builder.append(it) } } 263
264. fun main(nullableString: String?) { val builder = StringBuilder() builder.append("a") builder.append("b") builder.append("c") nullableString?.let { builder.append(it) } } 264
265. fun main(nullableString: String?) { val builder = StringBuilder() builder.append("a") builder.append("b") builder.append("c") nullableString?.let { builder.append(it) } } 265
266. fun main(nullableString: String?) { val builder = StringBuilder() builder.append("a") builder.append("b") builder.append("c") nullableString?.let(builder::append) } 266
268. fun main() { val builder = StringBuilder() builder.append("a") builder.append("b") builder.append("c") } 268
269. fun main() { val builder = StringBuilder() with(builder) { append("a") append("b") append("c") } } 269
270. fun main() { val builder = StringBuilder() with(builder) { append("a") append("b") append("c") // StringBuilder } // returns last value provided// StringBuilder } 270
271. fun main() { val builder = StringBuilder() builder.apply { append("a") append("b") append("c") } } 271
272. fun main() { val builder = StringBuilder() builder.apply { append("a") append("b") append("c") } } 272
273. fun main() { val builder = StringBuilder() builder.apply { append("a") append("b") append("c") "c" // last provided value is String } // returns receiver // StringBuilder } 273
276. class BankAccount { var accountNumber: Long var owner: String var balance: Double } 276
277. class BankAccount { var accountNumber: Long var owner: String var balance: Double } val bankAccount = BankAccount() bankAccount.accountNumber = 123L bankAccount.owner = "Bart" bankAccount.balance = 100.00 277
278. class BankAccount { var accountNumber: Long var owner: String var balance: Double var branch: String var interestRate: Double } val bankAccount = BankAccount() bankAccount.accountNumber = 123L bankAccount.owner = "Bart" 278
279. public static class Builder { private long accountNumber; //This is important, so we'll pass it to the constructor. private String owner; private String branch; private double balance; private double interestRate; public Builder(long accountNumber) { this.accountNumber = accountNumber; } public Builder withOwner(String owner){ this.owner = owner; return this; //By returning the builder each time, we can create a fluent interface. } public Builder atBranch(String branch){ this.branch = branch; return this; } public Builder openingBalance(double balance){ this.balance = balance; return this; } public Builder atRate(double interestRate){ this.interestRate = interestRate; return this; } public BankAccount build(){ //Here we create the actual bank account object, which is always in a fully initialised state when it's returned. BankAccount account = new BankAccount(); //Since the builder is in the BankAccount class, we can invoke its private constructor. account.accountNumber = this.accountNumber; 279
280. BankAccount account = new BankAccount.Builder(1234L) .withOwner("Marge") .atBranch("Springfield") .openingBalance(100) .atRate(2.5) .build() 280
281. Higher-order functions + Extensions functions 281
282. (T) -> Unit 282
283. (T) -> Unit 283
284. BankAccount.(T) -> Unit 284
285. class BankAccount( ... ) 285
286. class BankAccount( ... ) fun bankAccount() 286
287. class BankAccount( ... ) fun bankAccount(initialize: BankAccount.() -> Unit) 287
288. class BankAccount( ... ) fun bankAccount(initialize: BankAccount.() -> Unit) 288
289. class BankAccount( ... ) fun bankAccount(initialize: BankAccount.() -> Unit) 289
290. class BankAccount( ... ) fun bankAccount(initialize: BankAccount.() -> Unit) Higher-order extension function 290
291. class BankAccount( ... ) fun bankAccount(initialize: BankAccount.() -> Unit): BankAccount { } 291
292. fun bankAccount(initialize: BankAccount.() -> Unit): BankAccount { } 292
293. fun bankAccount(initialize: BankAccount.() -> Unit): BankAccount { return BankAccount() } 293
294. fun bankAccount(initialize: BankAccount.() -> Unit): BankAccount { return BankAccount() } 294
295. fun bankAccount(initialize: BankAccount.() -> Unit): BankAccount { return BankAccount().apply() } 295
296. fun bankAccount(initialize: BankAccount.() -> Unit): BankAccount { return BankAccount().apply(::initialize) } 296
297. bankAccount 297
298. bankAccount { } 298
299. bankAccount { accountNumber = 123L owner = "Bart" balance = 100.00 branch = "Tel-Aviv" interestRate = 2.5 } 299
300. bankAccount { accountNumber = 123L owner = "Bart" balance = 100.00 branch = "Tel-Aviv" interestRate = 2.5 } 300
301. bankAccount { accountNumber = 123L owner = "Bart" balance = 100.00 branch = "Tel-Aviv" interestRate = 2.5 } 301
302. bankAccount { accountNumber = 123L owner = "Bart" balance = 100.00 branch = Branch() interestRate = 2.5 } 302
303. fun BankAccount.branch(initialize: Branch.() -> Unit) { } 303
304. fun BankAccount.branch(initialize: Branch.() -> Unit) { branch = Branch() } 304
305. fun BankAccount.branch(initialize: Branch.() -> Unit) { branch = Branch().apply(::initialize) } 305
306. bankAccount { accountNumber = 123L owner = "Bart" balance = 100.00 branch = Branch() interestRate = 2.5 } 306
307. bankAccount { accountNumber = 123L owner = "Bart" balance = 100.00 branch { } interestRate = 2.5 } 307
308. bankAccount { accountNumber = 123L owner = "Bart" balance = 100.00 branch { city = "Tel Aviv" administrator = "Hadas Peled" services = listOf("deposits") } interestRate = 2.5 } 308
310. WORKSHOP!!! 310
315. • Interface with one abstract method 315
316. • Interface with one abstract method interface Runnable { fun run() } 316
317. • Interface with one abstract method interface Runnable { fun run() } 317
318. • Interface with one abstract method public interface Runnable { //JAVA public abstract void run(); //JAVA } //JAVA 318
319. • Interface with one abstract method public interface Runnable { //JAVA public abstract void run(); //JAVA } //JAVA fun runNow(runnable: Runnable) { runnable.run() } 319
320. • Interface with one abstract method public interface Runnable { //JAVA public abstract void run(); //JAVA } //JAVA fun runNow(runnable: Runnable) { runnable.run() } 320
321. • Interface with one abstract method public interface Runnable { //JAVA public abstract void run(); //JAVA } //JAVA fun runNow(runnable: Runnable) { runnable.run() } 321
322. • Interface with one abstract method public interface Runnable { //JAVA public abstract void run(); //JAVA } //JAVA fun runNow(runnable: Runnable) { runnable.run() } val runnable = object: Runnable { override fun run() { println("I am runnable") } } 322
323. • Interface with one abstract method public interface Runnable { //JAVA public abstract void run(); //JAVA } //JAVA fun runNow(runnable: Runnable) { runnable.run() } val runnable = object: Runnable { override fun run() { println("I am runnable") } } 323
324. • Interface with one abstract method public interface Runnable { //JAVA public abstract void run(); //JAVA } //JAVA fun runNow(runnable: Runnable) { runnable.run() } val runnable = object: Runnable { override fun run() { println("I am runnable") } } 324
325. • Interface with one abstract method public interface Runnable { //JAVA public abstract void run(); //JAVA } //JAVA fun runNow(runnable: Runnable) { runnable.run() } val runnable = object: Runnable { override fun run() { println("I am runnable") } } 325
326. • Interface with one abstract method public interface Runnable { //JAVA public abstract void run(); //JAVA } //JAVA fun runNow(runnable: Runnable) { runnable.run() } val runnable = object: Runnable { override fun run() { println("I am runnable") } } runNow(runnable) 326
327. • Interface with one abstract method public interface Runnable { //JAVA public abstract void run(); //JAVA } //JAVA fun runNow(runnable: Runnable) { runnable.run() } val runnable = object: Runnable { override fun run() { println("I am runnable") } } runNow(runnable) 327
328. • Interface with one abstract method public interface Runnable { //JAVA public abstract void run(); //JAVA } //JAVA fun runNow(runnable: Runnable) { runnable.run() } 328
329. • Interface with one abstract method public interface Runnable { //JAVA public abstract void run(); //JAVA } //JAVA fun runNow(runnable: Runnable) { runnable.run() } runNow(Runnable{println("I am runnable")}) 329
330. • Interface with one abstract method public interface Runnable { //JAVA public abstract void run(); //JAVA } //JAVA fun runNow(runnable: Runnable) { runnable.run() } runNow(Runnable{println("I am runnable")}) 330
331. • Interface with one abstract method public interface Runnable { //JAVA public abstract void run(); //JAVA } //JAVA fun runNow(runnable: Runnable) { runnable.run() } runNow(Runnable{println("I am runnable")}) 331
334. // Kotlin class MyClass { var text = "Hello world" } 334
335. // Kotlin class MyClass { var text = "Hello world" } 335
336. // Kotlin class MyClass{ var text = "Hello world" } Kotlin Decompiler - 336
337. // Kotlin class MyClass{ var text = "Hello world" } Kotlin Decompiler - Android studio 1. Menu > Tools > Kotlin > Show Kotlin Bytecode 2. Click on the Decompile button 3. Copy the java code 337
338. // Kotlin class MyClass{ var text = "Hello world" } // Java - Decompiler public final class MyClass { @NotNull private String text = "Hello world"; @NotNull public final String getText() { return this.text; } public final void setText(@NotNull String var1) { Intrinsics.checkParameterIsNotNull(var1, "<set-?>"); this.text = var1; } } 338
339. // Kotlin class MyClass{ var text = "Hello world" } // Java - Decompiler public final class MyClass { @NotNull private String text = "Hello world"; @NotNull public final String getText() { return this.text; } public final void setText(@NotNull String var1) { Intrinsics.checkParameterIsNotNull(var1, "<set-?>"); this.text = var1; } } 339
340. // Kotlin class MyClass{ var text = "Hello world" } // Java - Decompiler public final class MyClass { @NotNull private String text = "Hello world"; @NotNull public final String getText() { return this.text; } public final void setText(@NotNull String var1) { Intrinsics.checkParameterIsNotNull(var1, "<set-?>"); this.text = var1; } } 340
341. // Kotlin class MyClass{ var text = "Hello world" } // Java - Decompiler public final class MyClass { @NotNull private String text = "Hello world"; @NotNull public final String getText() { return this.text; } public final void setText(@NotNull String var1) { Intrinsics.checkParameterIsNotNull(var1, "<set-?>"); this.text = var1; } } 341
342. // Kotlin class MyClass{ var text = "Hello world" } // Java - Decompiler public final class MyClass { @NotNull private String text = "Hello world"; @NotNull public final String getText() { return this.text; } public final void setText(@NotNull String var1) { Intrinsics.checkParameterIsNotNull(var1, "<set-?>"); this.text = var1; } } 342
343. // Kotlin class MyClass{ var text = "Hello world" } // Java - Decompiler public final class MyClass { @NotNull private String text = "Hello world"; @NotNull public final String getText() { return this.text; } public final void setText(@NotNull String var1) { Intrinsics.checkParameterIsNotNull(var1, "<set-?>"); this.text = var1; } } 343
344. // Kotlin class MyClass{ val text = "Hello world" } // Java - Decompiler public final class MyClass { @NotNull private final String text = "Hello world"; @NotNull public final String getText() { return this.text; } public final void setText(@NotNull String var1) { Intrinsics.checkParameterIsNotNull(var1, "<set-?>"); this.text = var1; } } 344
345. // Kotlin class MyClass{ var text = "Hello world" } // Java - Decompiler public final class MyClass { @NotNull private String text = "Hello world"; @NotNull public final String getText() { return this.text; } public final void setText(@NotNull String var1) { Intrinsics.checkParameterIsNotNull(var1, "<set-?>"); this.text = var1; } } 345
346. // Kotlin class MyClass{ var text = "Hello world" } // Java - Decompiler public final class MyClass { @NotNull private String text = "Hello world"; @NotNull public final String getText() { return this.text; } public final void setText(@NotNull String var1) { Intrinsics.checkParameterIsNotNull(var1, "<set-?>"); this.text = var1; } } 346
347. // Kotlin class MyClass{ var text = "Hello world" } // Java - Decompiler public final class MyClass { @NotNull private String text = "Hello world"; @NotNull public final String getText() { return this.text; } public final void setText(@NotNull String var1) { Intrinsics.checkParameterIsNotNull(var1, "<set-?>"); this.text = var1; } } 347
348. // Kotlin class MyClass{ var text = "Hello world" } // Java - Decompiler public final class MyClass { @NotNull private String text = "Hello world"; @NotNull public final String getText() { return this.text; } public final void setText(@NotNull String var1) { Intrinsics.checkParameterIsNotNull(var1, "<set-?>"); this.text = var1; } } 348
349. // Kotlin class MyClass{ var text = "Hello world" } // Java - Decompiler public final class MyClass { @NotNull private String text = "Hello world"; @NotNull public final String getText() { return this.text; } public final void setText(@NotNull String var1) { Intrinsics.checkParameterIsNotNull(var1, "<set-?>"); this.text = var1; } } 349
350. // Kotlin class MyClass{ var text = "Hello world" } // Java - Decompiler public final class MyClass { @NotNull private String text = "Hello world"; @NotNull public final String getText() { return this.text; } public final void setText(@NotNull String var1) { Intrinsics.checkParameterIsNotNull(var1, "<set-?>"); this.text = var1; } } 350
351. // Kotlin class MyClass{ var text = "Hello world" } // Java - Decompiler public final class MyClass { @NotNull private String text = "Hello world"; @NotNull public final String getText() { return this.text; } public final void setText(@NotNull String var1) { Intrinsics.checkParameterIsNotNull(var1, "<set-?>"); this.text = var1; } } 351
352. // Kotlin class MyClass{ var text = "Hello world" } // Java - Decompiler public final class MyClass { @NotNull private String text = "Hello world"; @NotNull public final String getText() { return this.text; } public final void setText(@NotNull String var1) { Intrinsics.checkParameterIsNotNull(var1, "<set-?>"); this.text = var1; } } 352
353. // Kotlin class MyClass{ var text = "Hello world" } // Java - Decompiler public final class MyClass { @NotNull private String text = "Hello world"; @NotNull public final String getText() { return this.text; } public final void setText(@NotNull String var1) { Intrinsics.checkParameterIsNotNull(var1, "<set-?>"); this.text = var1; } } 353
354. // Kotlin class MyClass{ var text = "Hello world" } // Java - Decompiler public final class MyClass { @NotNull private String text = "Hello world"; @NotNull public final String getText() { return this.text; } public final void setText(@NotNull String var1) { Intrinsics.checkParameterIsNotNull(var1, "<set-?>"); this.text = var1; } } 354
355. // Kotlin class MyClass{ var text = "Hello world" } // Java - Decompiler public final class MyClass { @NotNull private String text = "Hello world"; @NotNull public final String getText() { return this.text; } public final void setText(@NotNull String var1) { Intrinsics.checkParameterIsNotNull(var1, "<set-?>"); this.text = var1; } } 355
357. // Kotlin file - app.kt package org.example class Util fun getTime() { /*...*/ } 357
358. // Kotlin file - app.kt package org.example class Util fun getTime() { /*...*/ } 358
359. // Kotlin file - app.kt package org.example class Util fun getTime() { /*...*/ } 359
360. // Kotlin file - app.kt package org.example class Util fun getTime() { /*...*/ } 360
361. // Kotlin file - app.kt package org.example class Util fun getTime() { /*...*/ } // Java - Decompiler public final class AppKt { public static final void getTime() { } } public final class Util { } 361
362. // Kotlin file - app.kt package org.example class Util fun getTime() { /*...*/ } // Java - Decompiler public final class AppKt { public static final void getTime() { } } public final class Util { } 362
363. // Kotlin file - app.kt package org.example class Util fun getTime() { /*...*/ } // Java - Decompiler public final class AppKt { public static final void getTime() { } } public final class Util { } 363
364. // Kotlin file - app.kt package org.example class Util fun getTime() { /*...*/ } // Java - Decompiler public final class AppKt { public static final void getTime() { } } public final class Util { } 364
365. // Kotlin file - app.kt package org.example class Util fun getTime() { /*...*/ } // Java - Decompiler public final class AppKt { public static final void getTime() { } } public final class Util { } 365
366. // Kotlin file - app.kt package org.example class Util fun getTime() { /*...*/ } // Java - Decompiler public final class AppKt { public static final void getTime() { } } public final class Util { } 366
367. // Kotlin file - app.kt package org.example class Util fun getTime() { /*...*/ } // Java - Decompiler public final class AppKt { public static final void getTime() { } } public final class Util { } 367
368. // Kotlin file - app.kt package org.example class Util fun getTime() { /*...*/ } // Java - Decompiler public final class AppKt { public static final void getTime() { } } public final class Util { } 368
369. // Kotlin file - app.kt package org.example class Util fun getTime() { /*...*/ } // Java - My file 369
370. // Kotlin file - app.kt package org.example class Util fun getTime() { /*...*/ } // Java - My file 370
371. // Kotlin file - app.kt package org.example class Util fun getTime() { /*...*/ } // Java - My file new org.example.Util(); 371
372. // Kotlin file - app.kt package org.example class Util fun getTime() { /*...*/ } // Java - My file new org.example.Util(); 372
373. // Kotlin file - app.kt package org.example class Util fun getTime() { /*...*/ } // Java - My file new org.example.Util(); org.example.AppKt.getTime(); 373
374. // Kotlin file - app.kt package org.example class Util fun getTime() { /*...*/ } // Java - My file new org.example.Util(); org.example.AppKt.getTime(); 374
375. // Kotlin file - app.kt @file:JvmName("Utils") package org.example class Util fun getTime() { /*...*/ } // Java - My file new org.example.Util(); org.example.AppKt.getTime(); 375
376. // Kotlin file - app.kt @file:JvmName("Utils") package org.example class Util fun getTime() { /*...*/ } // Java - My file new org.example.Util(); org.example.AppKt.getTime(); 376
377. // Kotlin file - app.kt @file:JvmName("Utils") package org.example class Util fun getTime() { /*...*/ } // Java - My file new org.example.Util(); org.example.AppKt.getTime(); 377
378. // Kotlin file - app.kt @file:JvmName("Utils") package org.example class Util fun getTime() { /*...*/ } // Java - My file new org.example.Util(); org.example.Utils.getTime(); 378
379. // Kotlin file - app.kt @file:JvmName("Utils") package org.example class Util fun getTime() { /*...*/ } // Java - My file new org.example.Util(); org.example.Utils.getTime(); 379
380. // Kotlin file - app.kt @file:JvmName("Utils") package org.example class Util fun getTime() { /*...*/ } // Java - My file new org.example.Util(); org.example.Utils.getTime(); // Kotlin file - apps.kt package org.example fun getDate() { /*...*/ } 380
381. // Kotlin file - app.kt @file:JvmName("Utils") package org.example class Util fun getTime() { /*...*/ } // Java - My file new org.example.Util(); org.example.Utils.getTime(); // Kotlin file - apps.kt package org.example fun getDate() { /*...*/ } 381
382. // Kotlin file - app.kt @file:JvmName("Utils") package org.example class Util fun getTime() { /*...*/ } // Java - My file new org.example.Util(); org.example.Utils.getTime(); // Kotlin file - apps.kt package org.example fun getDate() { /*...*/ } 382
383. // Kotlin file - app.kt @file:JvmName("Utils") package org.example class Util fun getTime() { /*...*/ } // Java - My file new org.example.Util(); org.example.Utils.getTime(); // Kotlin file - apps.kt @file:JvmName("Utils") package org.example fun getDate() { /*...*/ } 383
384. // Kotlin file - app.kt @file:JvmName("Utils") @file:JvmMultifileClass package org.example class Util fun getTime() { /*...*/ } // Java - My file new org.example.Util(); org.example.Utils.getTime(); // Kotlin file - apps.kt @file:JvmName("Utils") @file:JvmMultifileClass package org.example fun getDate() { /*...*/ } 384
385. // Kotlin file - app.kt @file:JvmName("Utils") @file:JvmMultifileClass package org.example class Util fun getTime() { /*...*/ } // Java - My file new org.example.Util(); org.example.Utils.getTime(); org.example.Utils.getDate(); // Kotlin file - apps.kt @file:JvmName("Utils") @file:JvmMultifileClass package org.example fun getDate() { /*...*/ } 385
387. // Kotlin val flavor = "Vanilla" 387
388. // Kotlin val flavor = "Vanilla" fun getFlavor(): String = "I taste like $flavor" 388
389. // Kotlin val flavor = "Vanilla" fun getFlavor(): String = "I taste like $flavor" // Platform declaration clash: // The following declarations have the same JVM signature. 389
390. // Kotlin val flavor = "Vanilla" @JvmName("getFlavorFormat") fun getFlavor(): String = "I taste like $flavor" 390
391. // Kotlin val flavor = "Vanilla" @JvmName("getFlavorFormat") fun getFlavor(): String = "I taste like $flavor" var isVanilla: Boolean get() = this.flavor == "Vanilla" set(value) { if(value) flavor = "Vanilla" } 391
392. // Kotlin val flavor = "Vanilla" @JvmName("getFlavorFormat") fun getFlavor(): String = "I taste like $flavor" var isVanilla: Boolean get() = this.flavor == "Vanilla" set(value) { if(value) flavor = "Vanilla" } 392
393. // Kotlin val flavor = "Vanilla" @JvmName("getFlavorFormat") fun getFlavor(): String = "I taste like $flavor" var isVanilla: Boolean get() = this.flavor == "Vanilla" set(value) { if(value) flavor = "Vanilla" } 393
394. // Kotlin val flavor = "Vanilla" @JvmName("getFlavorFormat") fun getFlavor(): String = "I taste like $flavor" var isVanilla: Boolean get() = this.flavor == "Vanilla" set(value) { if(value) flavor = "Vanilla" } 394
395. // Kotlin val flavor = "Vanilla" @JvmName("getFlavorFormat") fun getFlavor(): String = "I taste like $flavor" var isVanilla: Boolean get() = this.flavor == "Vanilla" set(value) { if(value) flavor = "Vanilla" } 395
396. // Kotlin val flavor = "Vanilla" @JvmName("getFlavorFormat") fun getFlavor(): String = "I taste like $flavor" var isVanilla: Boolean @JvmName("getIsVanilla") get() = this.flavor == "Vanilla" @JvmName("setIsVanilla") set(value) { if(value) flavor = "Vanilla" } 396
397. // Kotlin val flavor = "Vanilla" @JvmName("getFlavorFormat") fun getFlavor() : String = "I taste like $flavor" var isVanilla: Boolean @JvmName("getIsVanilla") get() = this.flavor == "Vanilla" @JvmName("setIsVanilla") set(value) { if(value) flavor = "Vanilla" } 397
398. // Kotlin val flavor = "Vanilla" @JvmName("getFlavorFormat") fun getFlavor() : String = "I taste like $flavor" var isVanilla: Boolean @JvmName("getIsVanilla") get() = this.flavor == "Vanilla" @JvmName("setIsVanilla") set(value) { if(value) flavor = "Vanilla" } 398
399. // Kotlin var flavor = "Vanilla" @JvmName("getFlavorFormat") fun getFlavor() : String = "I taste like $flavor" var isVanilla: Boolean @JvmName("getIsVanilla") get() = this.flavor == "Vanilla" @JvmName("setIsVanilla") set(value) { if(value) flavor = "Vanilla" } 399
400. // Kotlin @get:JvmName("flavor") @set:JvmName("changeFlavor") var flavor = "Vanilla" @JvmName("getFlavorFormat") fun getFlavor() : String = "I taste like $flavor" var isVanilla: Boolean @JvmName("getIsVanilla") get() = this.flavor == "Vanilla" @JvmName("setIsVanilla") set(value) { if(value) flavor = "Vanilla" } 400
401. // Kotlin @get:JvmName("flavor") @set:JvmName("changeFlavor") var flavor = "Vanilla" @JvmName("getFlavorFormat") fun getFlavor() : String = "I taste like $flavor" var isVanilla: Boolean @JvmName("getIsVanilla") get() = this.flavor == "Vanilla" @JvmName("setIsVanilla") set(value) { if(value) flavor = "Vanilla" } 401
402. // Kotlin @get:JvmName("flavor") @set:JvmName("changeFlavor") var flavor = "Vanilla" @JvmName("getFlavorFormat") fun getFlavor() : String = "I taste like $flavor" var isVanilla: Boolean @JvmName("getIsVanilla") get() = this.flavor == "Vanilla" @JvmName("setIsVanilla") set(value) { if(value) flavor = "Vanilla" } 402
403. // Kotlin @get:JvmName("flavor") @set:JvmName("changeFlavor") var flavor = "Vanilla" @JvmName("getFlavorFormat") fun getFlavor() : String = "I taste like $flavor" var isVanilla: Boolean get() = this.flavor == "Vanilla" set(value) { if(value) flavor = "Vanilla" } 403
404. // Kotlin @get:JvmName("flavor") @set:JvmName("changeFlavor") var flavor = "Vanilla" @JvmName("getFlavorFormat") fun getFlavor() : String = "I taste like $flavor" @get:JvmName("getIsVanilla") @set:JvmName("setIsVanilla") var isVanilla: Boolean get() = this.flavor == "Vanilla" set(value) { if(value) flavor = "Vanilla" } 404
406. // Kotlin object Flavors { const val VANILLA: String = "Vanilla" } class IceCream(val flavor: String = DEFAULT_FLAVOR, val cone: Boolean = true) { companion object { const val DEFAULT_FLAVOR: String = Flavors.VANILLA } } 406
407. // Kotlin object Flavors { const val VANILLA: String = "Vanilla" } class IceCream(val flavor: String = DEFAULT_FLAVOR, val cone: Boolean = true) { companion object { const val DEFAULT_FLAVOR: String = Flavors.VANILLA } } 407
408. // Kotlin object Flavors { const val VANILLA: String = "Vanilla" } class IceCream(val flavor: String = DEFAULT_FLAVOR, val cone: Boolean = true) { companion object { const val DEFAULT_FLAVOR: String = Flavors.VANILLA } } 408
409. // Kotlin object Flavors { const val VANILLA: String = "Vanilla" } class IceCream(val flavor: String = DEFAULT_FLAVOR, val cone: Boolean = true) { companion object { const val DEFAULT_FLAVOR: String = Flavors.VANILLA } } 409
410. // Kotlin object Flavors { const val VANILLA: String = "Vanilla" } class IceCream(val flavor: String = DEFAULT_FLAVOR, val cone: Boolean = true) { companion object { const val DEFAULT_FLAVOR: String = Flavors.VANILLA } } 410
411. // Kotlin object Flavors { const val VANILLA: String = "Vanilla" } class IceCream(val flavor: String = DEFAULT_FLAVOR, val cone: Boolean = true) { companion object { const val DEFAULT_FLAVOR: String = Flavors.VANILLA } } 411
412. // Kotlin object Flavors { } class IceCream(val flavor: String = DEFAULT_FLAVOR, val cone: Boolean = true) { companion object { } } 412
413. // Kotlin object Flavors { fun getVanillaFlavor() = "Vanilla" } class IceCream(val flavor: String = getDefaultFlavor(), val cone: Boolean = true) { companion object { fun getDefaultFlavor() = Flavors.getVanillaFlavor() } } 413
414. // Kotlin object Flavors { fun getVanillaFlavor() = "Vanilla" } class IceCream(val flavor: String = getDefaultFlavor(), val cone: Boolean = true) { companion object { fun getDefaultFlavor() = Flavors.getVanillaFlavor() } } 414
415. // Kotlin object Flavors { fun getVanillaFlavor() = "Vanilla" } class IceCream(val flavor: String = getDefaultFlavor(), val cone: Boolean = true) { companion object { fun getDefaultFlavor() = Flavors.getVanillaFlavor() } } 415
416. // Kotlin object Flavors { fun getVanillaFlavor() = "Vanilla" } class IceCream(val flavor: String = getDefaultFlavor(), val cone: Boolean = true) { companion object { fun getDefaultFlavor() = Flavors.getVanillaFlavor() } } // Java - My file 416
417. // Kotlin object Flavors { fun getVanillaFlavor() = "Vanilla" } class IceCream(val flavor: String = getDefaultFlavor(), val cone: Boolean = true) { companion object { fun getDefaultFlavor() = Flavors.getVanillaFlavor() } } // Java - My file Flavors.getVanillaFlavor(); // ??? 417
418. // Kotlin object Flavors { fun getVanillaFlavor() = "Vanilla" } class IceCream(val flavor: String = getDefaultFlavor(), val cone: Boolean = true) { companion object { fun getDefaultFlavor() = Flavors.getVanillaFlavor() } } // Java - My file Flavors.getVanillaFlavor(); // Cannot resolve method 418
419. // Kotlin object Flavors { fun getVanillaFlavor() = "Vanilla" } class IceCream(val flavor: String = getDefaultFlavor(), val cone: Boolean = true) { companion object { fun getDefaultFlavor() = Flavors.getVanillaFlavor() } } // Java - My file IceCream.getDefaultFlavor(); // Cannot resolve method 419
420. // Kotlin object Flavors { fun getVanillaFlavor() = "Vanilla" } class IceCream(val flavor: String = getDefaultFlavor(), val cone: Boolean = true) { companion object { fun getDefaultFlavor() = Flavors.getVanillaFlavor() } } // Java - My file Flavors.INSTANCE.getVanillaFlavor(); 420
421. // Kotlin object Flavors { fun getVanillaFlavor() = "Vanilla" } class IceCream(val flavor: String = getDefaultFlavor(), val cone: Boolean = true) { companion object { fun getDefaultFlavor() = Flavors.getVanillaFlavor() } } // Java - My file Flavors.INSTANCE.getVanillaFlavor(); // WORKS 421
422. // Kotlin object Flavors { fun getVanillaFlavor() = "Vanilla" } class IceCream(val flavor: String = getDefaultFlavor(), val cone: Boolean = true) { companion object { fun getDefaultFlavor() = Flavors.getVanillaFlavor() } } // Java - My file IceCream.Companion.getDefaultFlavor(); 422
423. // Kotlin object Flavors { fun getVanillaFlavor() = "Vanilla" } class IceCream(val flavor: String = getDefaultFlavor(), val cone: Boolean = true) { companion object { fun getDefaultFlavor() = Flavors.getVanillaFlavor() } } // Java - My file IceCream.Companion.getDefaultFlavor(); // WORKS 423
424. @JvmStatic 424
425. // Kotlin object Flavors { @JvmStatic fun getVanillaFlavor() = "Vanilla" } class IceCream(val flavor: String = getDefaultFlavor(), val cone: Boolean = true) { companion object { fun getDefaultFlavor() = Flavors.getVanillaFlavor() } } 425
426. // Kotlin object Flavors { @JvmStatic fun getVanillaFlavor() = "Vanilla" } class IceCream(val flavor: String = getDefaultFlavor(), val cone: Boolean = true) { companion object { @JvmStatic fun getDefaultFlavor() = Flavors.getVanillaFlavor() } } 426
427. // Kotlin object Flavors { @JvmStatic fun getVanillaFlavor() = "Vanilla" } class IceCream(val flavor: String = getDefaultFlavor(), val cone: Boolean = true) { companion object { @JvmStatic fun getDefaultFlavor() = Flavors.getVanillaFlavor() } } // Java - My file 427
428. // Kotlin object Flavors { @JvmStatic fun getVanillaFlavor() = "Vanilla" } class IceCream(val flavor: String = getDefaultFlavor(), val cone: Boolean = true) { companion object { fun getDefaultFlavor() = Flavors.getVanillaFlavor() } } // Java - My file Flavors.getVanillaFlavor(); // WORKS 428
429. // Kotlin object Flavors { @JvmStatic fun getVanillaFlavor() = "Vanilla" } class IceCream(val flavor: String = getDefaultFlavor(), val cone: Boolean = true) { companion object { @JvmStatic fun getDefaultFlavor() = Flavors.getVanillaFlavor() } } // Java - My file IceCream.getDefaultFlavor(); // WORKS 429
430. // Kotlin class IceCream(var flavor: String = "Vanilla", var cone: Boolean = true) { constructor(topping: String): this() { cone = false } } 430
431. // Kotlin class IceCream(var flavor: String = "Vanilla", var cone: Boolean = true) { constructor(topping: String): this() { cone = false } } 431
432. // Kotlin class IceCream(var flavor: String = "Vanilla", var cone: Boolean = true) { constructor(topping: String): this() { cone = false } } 432
433. // Kotlin class IceCream(var flavor: String = "Vanilla", var cone: Boolean = true) { constructor(topping: String): this() { cone = false } } val vanillaCone = IceCream() val choclateCone = IceCream("Chocolate") val choclateCup = IceCream("Chocolate", false) val vanillaCup = IceCream(cone = false) val vanillaCupSprinkles = IceCream(topping = "Sprinkles") 433
435. @JvmOverloads 435
436. // Kotlin class IceCream @JvmOverloads constructor (var flavor: String = "Vanilla",var cone: Boolean = true) { constructor(topping: String): this() { cone = false } } 436
437. // Kotlin class IceCream @JvmOverloads constructor (var flavor: String = "Vanilla", var cone: Boolean = true) { constructor(topping: String): this() { cone = false } } // Java IceCream(String flavor, boolean cone) IceCream() 437
438. // Kotlin class IceCream @JvmOverloads constructor (var flavor: String = "Vanilla", var cone: Boolean = true) { constructor(topping: String): this() { cone = false } } // Java IceCream(String flavor, boolean cone) IceCream() IceCream(String flavor) // thanks JvmOverloads 438
439. // Kotlin class IceCream @JvmOverloads constructor (var flavor: String = "Vanilla", var cone: Boolean = true) { constructor(topping: String): this() { cone = false } } // Java IceCream(String flavor, boolean cone) IceCream() IceCream(String flavor) 439
440. // Kotlin class IceCream @JvmOverloads constructor (var flavor: String = "Vanilla", var cone: Boolean = true) { constructor(topping: String): this() { cone = false } } // Java IceCream(String flavor, boolean cone) IceCream() IceCream(String flavor) // thanks JvmOverloads IceCream(String topping) // secondary constructor 440
441. // Kotlin class IceCream @JvmOverloads constructor (var flavor: String = "Vanilla", var cone: Boolean = true) { constructor(balls: Int): this() { cone = false } } // Java IceCream(String flavor, boolean cone) IceCream() IceCream(String flavor) 441
442. // Kotlin class IceCream @JvmOverloads constructor (var flavor: String = "Vanilla", var cone: Boolean = true) { constructor(balls: Int): this() { cone = false } } // Java IceCream(String flavor, boolean cone) IceCream() IceCream(String flavor) IceCream(int balls) 442
443. // Kotlin class IceCream @JvmOverloads constructor (var flavor: String = "Vanilla", var cone: Boolean = true) { constructor(balls: Int = 1): this() { cone = false } } // Java IceCream(String flavor, boolean cone) IceCream() IceCream(String flavor) IceCream(int balls) 443
444. // Kotlin class IceCream @JvmOverloads constructor (var flavor: String = "Vanilla", var cone: Boolean = true) { constructor(balls: Int = 1): this() { cone = false } } // Java IceCream(String flavor, boolean cone) IceCream() IceCream(String flavor) IceCream(int balls) 444
445. // Kotlin class IceCream @JvmOverloads constructor (var flavor: String = "Vanilla", var cone: Boolean = true) { constructor(balls: Int = 1): this("Vanilla", true) { cone = false } } // Java IceCream(String flavor, boolean cone) IceCream() IceCream(String flavor) IceCream(int balls) 445
446. // Kotlin class IceCream @JvmOverloads constructor (var flavor: String = "Vanilla", var cone: Boolean = true) { constructor(balls: Int = 1): this("Vanilla", true) { cone = false } } // Java IceCream(String flavor, boolean cone) IceCream() IceCream(String flavor) IceCream(int balls) 446
447. // Kotlin class IceCream @JvmOverloads constructor (var flavor: String = "Vanilla", var cone: Boolean = true) { constructor(balls: Int = 1): this("Vanilla", true) { cone = false } } // Java IceCream(String flavor, boolean cone) IceCream() IceCream(String flavor) IceCream(int balls) IceCream() 447
448. // Kotlin class IceCream @JvmOverloads constructor (var flavor: String = "Vanilla", var cone: Boolean = true) { constructor(balls: Int = 1): this("Vanilla", true) { cone = false } } // Java IceCream(String flavor, boolean cone) IceCream() IceCream(String flavor) IceCream(int balls) IceCream() 448
450. // Kotlin class IceCream @JvmOverloads constructor (var flavor: String = "Vanilla", var cone: Boolean = true) { constructor(balls: Int = 1): this("Vanilla", true) { cone = false } } // Java IceCream(String flavor, boolean cone) IceCream() IceCream(String flavor) IceCream(int balls) IceCream() 450
451. // Kotlin class IceCream @JvmOverloads constructor (var flavor: String = "Vanilla", var cone: Boolean = true) { @JvmOverloads constructor(balls: Int = 1): this("Vanilla",true) { cone = false } } // Java IceCream(String flavor, boolean cone) IceCream() IceCream(String flavor) IceCream(int balls) IceCream() 451
452. // Kotlin class IceCream @JvmOverloads constructor (var flavor: String = "Vanilla", var cone: Boolean = true) { @JvmOverloads constructor(balls: Int = 1): this("Vanilla",true) { cone = false } } // Java IceCream(String flavor, boolean cone) IceCream() IceCream(String flavor) IceCream(int balls) IceCream() 452
453. // Kotlin class IceCream @JvmOverloads constructor (var flavor: String = "Vanilla", var cone: Boolean = true) { @JvmOverloads constructor(balls: Int = 1): this("Vanilla",true) { cone = false } } // Java IceCream(String flavor, boolean cone) IceCream() IceCream(String flavor) IceCream(int balls) IceCream() 453
455. Kotlin has three structural jump expressions: 455
456. Kotlin has three structural jump expressions: • return - By default returns from the nearest enclosing function or anonymous function. 456
457. Kotlin has three structural jump expressions: • return - By default returns from the nearest enclosing function or anonymous function. • break - Terminates the nearest enclosing loop. 457
458. Kotlin has three structural jump expressions: • return - By default returns from the nearest enclosing function or anonymous function. • break - Terminates the nearest enclosing loop. • continue - Proceeds to the next step of the nearest enclosing loop. 458
460. for (i in 1..100) { // ... } 460
461. loop@ for (i in 1..100) { // ... } 461
462. loop@ for (i in 1..100) { innerLoop@ for (j in 1..100) { if (...) break } } 462
463. loop@ for (i in 1..100) { innerLoop@ for (j in 1..100) { if (...) break } } 463
464. loop@ for (i in 1..100) { innerLoop@ for (j in 1..100) { if (...) break } } 464
465. loop@ for (i in 1..100) { innerLoop@ for (j in 1..100) { if (...) break@loop } } 465
467. fun foo() { listOf(1, 2, 3, 4, 5).forEach { if (it == 3) return print(it) } print("this point is unreachable") } 467
468. fun foo() { listOf(1, 2, 3, 4, 5).forEach { if (it == 3) return print(it) } print("this point is unreachable") } 468
469. fun foo() { listOf(1, 2, 3, 4, 5).forEach { if (it == 3) return print(it) } print("this point is unreachable") } 469
470. fun foo() { listOf(1, 2, 3, 4, 5).forEach { if (it == 3) return print(it) } print("this point is unreachable") } 470
471. fun foo() { listOf(1, 2, 3, 4, 5).forEach { if (it == 3) return // return to the caller of foo() print(it) } print("this point is unreachable") } 471
472. fun foo() { listOf(1, 2, 3, 4, 5).forEach { if (it == 3) return // return to the caller of foo() print(it) } print("this point is unreachable") } 472
473. fun foo() { listOf(1, 2, 3, 4, 5).forEach { if (it == 3) return // return to the caller of foo() print(it) } print("this point is unreachable") } 473
474. fun foo() { listOf(1, 2, 3, 4, 5).forEach { if (it == 3) return // return to the caller of foo() print(it) } print("this point is unreachable") } 12 474
475. fun foo() { listOf(1, 2, 3, 4, 5).forEach gil@{ if (it == 3) return@gil print(it) } print(" done with explicit label") } 475
476. fun foo() { listOf(1, 2, 3, 4, 5).forEach gil@{ if (it == 3) return@gil //return to the caller of lambda print(it) } print(" done with explicit label") } 476
477. fun foo() { listOf(1, 2, 3, 4, 5).forEach gil@{ if (it == 3) return@gil //return to the caller of lambda print(it) } print(" done with explicit label") } 1245 done with explicit label 477
478. fun foo() { listOf(1, 2, 3, 4, 5).forEach { if (it == 3) return@forEach//return to caller of lambda print(it) } print(" done with implicit label") } 1245 done with explicit label 478
479. fun foo() { listOf(1, 2, 3, 4, 5).forEach(fun(value: Int) { if (value == 3) return print(value) }) print(" done with anonymous function") } 479
480. fun foo() { listOf(1, 2, 3, 4, 5).forEach(fun(value: Int) { if (value == 3) return//return to caller of a.f print(value) }) print(" done with anonymous function") } 1245 done with explicit label 480
481. return@a 1 481
482. return@a 1 482
483. return@a 1 483
486. val iceCream = IceCream::class 486
487. KClass 487
488. val javaReference = IceCream::class.java 488
490. val iceCream = IceCream() println("This is a bounded class reference ${iceCream::class}") 490
491. val iceCream = IceCream() println("This is a bounded class reference ${iceCream::class}") 491
492. val iceCream = IceCream() println("This is a bounded class reference ${iceCream::class}") 492
494. fun isOdd(x: Int) = x % 2 != 0 494
495. fun isOdd(x: Int) = x % 2 != 0 isOdd(5) 495
496. fun isOdd(x: Int) = x % 2 != 0 val numbers = listOf(1, 2, 3) 496
497. fun isOdd(x: Int) = x % 2 != 0 val numbers = listOf(1, 2, 3) println(numbers.filter(::isOdd)) 497
498. fun isOdd(x: Int) = x % 2 != 0 val numbers = listOf(1, 2, 3) println(numbers.filter(::isOdd)) 498
499. fun isOdd(x: Int) = x % 2 != 0 val numbers = listOf(1, 2, 3) println(numbers.filter(::isOdd)) Here ::isOdd is a value of function type (Int) -> Boolean 499
500. WORKSHOP!!! 500
503. //Operations val sum: (Int, Int) -> Int = { x, y -> x + y } val sub: (Int, Int) -> Int = { x, y -> x - y } val multiply: (Int, Int) -> Int = { x, y -> x * y } Val diff: (Int, Int) -> Int = { x, y -> x / y } 503
504. //Operations val sum: (Int, Int) -> Int = { x, y -> x + y } val sub: (Int, Int) -> Int = { x, y -> x - y } val multiply: (Int, Int) -> Int = { x, y -> x * y } Val diff: (Int, Int) -> Int = { x, y -> x / y } 504
505. //Operations val sum: (Int, Int) -> Int = { x, y -> x + y } val sub: (Int, Int) -> Int = { x, y -> x - y } val multiply: (Int, Int) -> Int = { x, y -> x * y } Val diff: (Int, Int) -> Int = { x, y -> x / y } 505
506. //Operations val sum: (Int, Int) -> Int = { x, y -> x + y } val sub: (Int, Int) -> Int = { x, y -> x - y } val multiply: (Int, Int) -> Int = { x, y -> x * y } Val diff: (Int, Int) -> Int = { x, y -> x / y } 506
507. typealias IntOperation = (Int, Int) -> Int //Operations val sum: (Int, Int) -> Int = { x, y -> x + y } val sub: (Int, Int) -> Int = { x, y -> x - y } val multiply: (Int, Int) -> Int = { x, y -> x * y } Val diff: (Int, Int) -> Int = { x, y -> x / y } 507
508. typealias IntOperation = (Int, Int) -> Int //Operations val sum: (Int, Int) -> Int = { x, y -> x + y } val sub: (Int, Int) -> Int = { x, y -> x - y } val multiply: (Int, Int) -> Int = { x, y -> x * y } Val diff: (Int, Int) -> Int = { x, y -> x / y } 508
509. typealias IntOperation = (Int, Int) -> Int //Operations val sum: (Int, Int) -> Int = { x, y -> x + y } val sub: (Int, Int) -> Int = { x, y -> x - y } val multiply: (Int, Int) -> Int = { x, y -> x * y } Val diff: (Int, Int) -> Int = { x, y -> x / y } 509
510. typealias IntOperation = (Int, Int) -> Int //Operations val sum: IntOperation = { x, y -> x + y } val sub: (Int, Int) -> Int = { x, y -> x - y } val multiply: (Int, Int) -> Int = { x, y -> x * y } Val diff: (Int, Int) -> Int = { x, y -> x / y } 510
511. typealias IntOperation = (Int, Int) -> Int //Operations val sum: IntOperation = { x, y -> x + y } val sub: IntOperation = { x, y -> x - y } val multiply: IntOperation = { x, y -> x * y } Val diff: IntOperation = { x, y -> x / y } 511
512. Collections val regularMap = mapOf<String, String>() val ArtyomMap = mapOf<String, String>() 512
513. Collections typealias CoolKey = String typealias CoolValue = String val regularMap = mapOf<String, String>() val muchMoreReadableMap = mapOf<CoolKey, CoolValue>() 513
514. Collections typealias CoolKey = String typealias CoolValue = String val regularMap = mapOf<String, String>() val muchMoreReadableMap = mapOf<CoolKey, CoolValue>() 514
515. Collections typealias CoolKey = String typealias CoolValue = String val regularMap = mapOf<String, String>() val muchMoreReadableMap = mapOf<CoolKey, CoolValue>() 515
516. Collections typealias CoolKey = String typealias CoolValue = String val regularMap = mapOf<String, String>() val muchMoreReadableMap = mapOf<CoolKey, CoolValue>() 516
517. Classes class A { inner class Inner } class B { inner class Inner } typealias AInner = A.Inner typealias BInner = B.Inner 517
518. Classes class A { inner class Inner } class B { inner class Inner } typealias AInner = A.Inner typealias BInner = B.Inner 518
519. Classes class A { inner class Inner } class B { inner class Inner } typealias AInner = A.Inner typealias BInner = B.Inner 519
520. Type aliases do not create new types. They simply give another name to an existing type. 520
521. import org.edensMessage.Message import org.gilsSpecialClass.Message fun main(){ val myMessage: Message } 521
522. import org.edensMessage.Message import org.gilsSpecialClass.Message fun main(){ val myMessage: Message } 522
523. import org.edensMessage.Message import org.gilsSpecialClass.Message as gilsMessage 523
524. import org.edensMessage.Message import org.gilsSpecialClass.Message as gilsMessage 524
525. import org.edensMessage.Message import org.gilsSpecialClass.Message as gilsMessage fun main(){ val myMessage: Message val gilMessage: gilMessage } edensMessage 525
526. import org.edensMessage.Message import org.gilsSpecialClass.Message as gilsMessage fun main(){ val myMessage: Message val gilMessage: gilMessage } gilsSpecialClass 526
527. delay(9000000) 527
528. delay(9_000_000) 528
529. • Kotlin is a cool new language. • We have learn many things, how to make the code more readable, efficient and cleaner. • Keep learning Kotlin its only the tip of the iceberg… 529
531. 531 Feedback form
533. Thank you 533