Kotlin is a statically typed programming language that runs on the Java Virtual Machine (JVM) and is fully interoperable with Java. Some key features of Kotlin include being less verbose than Java, property-based accessors, lambdas and type inference, which allow code to be more concise and readable. Kotlin aims to be practical for building large applications and introduces modern language features while also having a smooth learning curve for Java developers.

1. for Android Developers

2. Contents
• Intro
• Hello, Kotlin!
• What Kotlin Adds to Java
• Kotlin Android Extensions
• Android Kotlin extensions “KTX”

3. Background
• Apple got a nice(r) new language
• Android stuck with Java
• Not fair!

4. Java is not just about Java
"Most people talk about Java the language, and this
may sound odd `coming from me, but I could hardly
care less. At the core of the Java ecosystem is the JVM."
James Gosling, Creator of the Java Programming Language(2011,
TheServerSide.com)

5. What's Right with Java?
• The JVM runs on virtually every platform - from your
credit card to the largest mainframe
• Cross platform compatibility has been a hallmark of Java
from the very beginning
• Huge investment in a highly stable and performant
runtime
• Many important and large systems are written in Java
• The open source movement flourished with Java
• Many important architectural concepts in use today
have come from the Java/Open Source space

6. What's Wrong with Java?
• Many Java code bases are unmitigated disasters
• Many Java developers are undisciplined hacks
• Enterprise systems - EJBs, WebSphere, etc.
• The Java language suffered from years of inattention
• Java 8 is great, but very late and many clients have not upgraded
• Missing modern features
Lambdas, properties, higher-order functions
• Null safety
NullPointerException
Java is a good language...there are some issues...you can make things as God awful
as you want... it does allow people to create incredible messes (Gosling)

7. Java on Android - the bad parts
• Java 7 was out 2011. - partial support 2013.
• Java 8 was out 2014. - support will announced in the
near future
• Null references
• Covariant arrays
• Raw types
• No Lambda expressions
• Checked exceptions

8. Other JVM Languages
• Groovy (Dynamic) - Pivotal donated to Apache
where projects go to die
• Clojure (Lisp on JVM)
• Scala (static types, functional, ML on the JVM)
• Kotlin
• Dozens more

9. Kotlin Milestones
• Project Kotlin unveiled in July 2011
• Kotlin 1.0 released in February 2016
• “Language of the Month” - Dr. Dobb’s Journal (01/2012)

10. Motivation
• Huge Java codebase (>50k classes, 10 years old)
• Building tools for many nice languages
• Want a modern, expressive language …that’s
easy to introduce in the existing environment
• Need efficient tooling
• None of the existing languages was a good fit

11. Why Kotlin?
• Kotlin is not an academic language - it is practical
• Kotlin does not make you change the way you think
(unlike Scala and Clojure)
• Seamless Java interop (the killer feature)
• Makes Android development less painful (Android is
the killer app for Kotlin)
• JDK 6!

12. Building Kotlin
• Same structure as Java - packages, classes, etc.
• Builds with Maven/Gradle/Ant
• Java and Kotlin can live side by side in the same
project

13. Kotlin Language Features
• Semicolons are optional and discouraged
• Multiple classes in files
• Very relaxed about classes, file names, etc.
• Codifies many conventions leading to more concise code
• Type inference
• Lambdas before Java 8
• Null Safety
• Domain-Specific Languages “DSL” Construction

14. Advantages of Kotlin
• Modern statically typed, object oriented language that
borrows manyideas from functional languages
• Fast learning curve - inspired by Scala and C#
• Meant to be used for building large software systems
• Engineered to be highly interoperable with Java - you
can use existing code base w/o (many) problems

15. Advantages of Kotlin cont.
• The team behind it is JetBrains, creators of IntelliJ which is Android Studio
based on. Also has some contributions from James Strachan - creator of
Groovy
• Significantly more concise and readable than Java, which means it’s
easier to maintain
• Lightweight - Kotlin stdlib has 8k methods
• If it means something to someone - it also compiles to Javascript

16. Dalvik ART
Android
Java source
javac
Kotlin source
kotlinc
bytecode
JVM
Backend
JVM
Desktop

17. You Can Have Java & Kotlin Code In One
Project
Kotlin code
Java code

18. Just another library for your app
rxjava-2.1.2
kotlin-stdlib-1.1.4 6315
10212

19. No Kotlin SDK
…just JDK + extensions
small runtime jar easy Java interop

20. Gradle & Kotlin
Writing Gradle build scripts
and plugins in Kotlin

21. try.kotlinlang.org

22. Java Kotlin
public class PersonInJava {
private int id;
private String name;
public PersonInJava(int id, String name) {
this.id = id;
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
PersonInJava that = (PersonInJava) o;
if (id != that.id) return false;
return name.equals(that.name);
}
@Override
public int hashCode() {
int result = id;
result = 31 * result + name.hashCode();
return result;
}
}
data class PersonInKotlin (var id: Int, var name:String)
Less code means less Bugs

23. Hello, Kotlin!

24. fun main(args: Array<String>): Unit {
println("Hello, World!")
}
> Hello, World!

25. fun main(args: Array<String>): Unit {
println("Hello, World!")
}
Function keyword

26. fun main(args: Array<String>): Unit {
println("Hello, World!")
}
Function name

27. fun main(args: Array<String>): Unit {
println("Hello, World!")
}
Argumentname

28. fun main(args: Array<String>): Unit {
println("Hello, World!")
}
Argumenttype

29. fun main(args: Array<String>): Unit {
println("Hello, World!")
}
Return type

30. fun main(args: Array<String>): Unit {
println("Hello, World!")
}

31. fun main(args: Array<String>): Unit {
println("Hello, World!")
}
Unit inferred

32. fun main(args: Array<String>) {
println("Hello, World!")
}

33. fun main(args: Array<String>) {
println("Hello, World!")
}

34. fun main(args: Array<String>) {
var name = "World"
println("Hello, $name!")
}

35. fun main(args: Array<String>) {
var name = "World"
println("Hello, $name!")
}
Variable declaration

36. fun main(args: Array<String>) {
var name = "World“
println("Hello, $name!")
}
String interpolation

37. fun main(args: Array<String>) {
var name = "World"
if (args.isNotEmpty()) {
name = args[0]
}
println("Hello, $name!")
}

38. fun main(args: Array<String>) {
var name = "World"
if (args.isNotEmpty()) {
name = args[0]
}
println("Hello, $name!")
}

39. fun main(args: Array<String>) {
val name = "World"
if (args.isNotEmpty()) {
name = args[0]
}
println("Hello, $name!")
}

40. fun main(args: Array<String>) {
val name = "World"
if (args.isNotEmpty()) {
name = args[0]
}
println("Hello, $name!")
}
Constant declaration

41. fun main(args: Array<String>) {
val name = "World"
if (args.isNotEmpty()) {
name = args[0]
}
println("Hello, $name!")
}
Val cannot be reassigned

42. fun main(args: Array<String>) {
val name = "World"
if (args.isNotEmpty()) {
name = args[0]
}
println("Hello, $name!")
}

43. fun main(args: Array<String>) {
val name = if (args.isNotEmpty()) {
args[0]
} else {
"World"
}
println("Hello, $name!")
}

44. fun main(args: Array<String>) {
val name = if (args.isNotEmpty()) {
args[0]
} else {
"World"
}
println("Hello, $name!")
}

45. fun main(args: Array<String>) {
val name = if (args.isNotEmpty()) {
args[0]
} else {
"World"
}
println("Hello, $name!")
}
Conditional assignment block

46. fun main(args: Array<String>) {
val name = if (args.isNotEmpty()) { args[0] } else { "World" }
println("Hello, $name!")
}

47. fun main(args: Array<String>) {
val name = if (args.isNotEmpty()) args[0] else "World"
println("Hello, $name!")
}

48. class Person(var name: String)
fun main(args: Array<String>) {
val name = if (args.isNotEmpty()) args[0] else "World"
println("Hello, $name!")
}

49. class Person(var name: String)
fun main(args: Array<String>) {
val name = if (args.isNotEmpty()) args[0] else "World"
println("Hello, $name!")
}
Class keyword

50. class Person(var name: String)
fun main(args: Array<String>) {
val name = if (args.isNotEmpty()) args[0] else "World"
println("Hello, $name!")
}
Class name

51. class Person(var name: String)
fun main(args: Array<String>) {
val name = if (args.isNotEmpty()) args[0] else "World"
println("Hello, $name!")
}
Primaryconstructor

52. class Person(var name: String)
fun main(args: Array<String>) {
val name = if (args.isNotEmpty()) args[0] else "World"
println("Hello, $name!")
}
Non-final classmember

53. class Person(var name: String)
fun main(args: Array<String>) {
val name = if (args.isNotEmpty()) args[0] else "World"
println("Hello, $name!")
}

54. class Person(var name: String)
fun main(args: Array<String>) {
println("Hello, $name!")
}

55. class Person(var name: String)
fun main(args: Array<String>) {
val person = Person("Michael")
println("Hello, $name!")
}

56. class Person(var name: String)
fun main(args: Array<String>) {
val person = Person("Michael")
println("Hello, $name!")
}
Instance declaration

57. class Person(var name: String)
fun main(args: Array<String>) {
val person = Person("Michael")
println("Hello, $name!")
}

58. class Person(var name: String)
fun main(args: Array<String>) {
val person = Person("Michael")
println("Hello, ${person.name}!")
}
> Hello, Michael!

59. enum class Language(val greeting: String) {
EN("Hello"), ES("Hola"), FR("Bonjour")
}
class Person(var name: String)
fun main(args: Array<String>) {
val person = Person("Michael")
println("Hello, ${person.name}!")
}

60. enum class Language(val greeting: String) {
EN("Hello"), ES("Hola"), FR("Bonjour")
}
class Person(var name: String)
fun main(args: Array<String>) {
val person = Person("Michael")
println("Hello, ${person.name}!")
}

61. enum class Language(val greeting: String) {
EN("Hello"), ES("Hola"), FR("Bonjour")
}
class Person(var name: String, var lang: Language)
fun main(args: Array<String>) {
val person = Person("Michael")
println("Hello, ${person.name}!")
}

62. enum class Language(val greeting: String) {
EN("Hello"), ES("Hola"), FR("Bonjour")
}
class Person(var name: String, var lang: Language = Language.EN)
fun main(args: Array<String>) {
val person = Person("Michael")
println("Hello, ${person.name}!")
}
Defaultvalue

63. enum class Language(val greeting: String) {
EN("Hello"), ES("Hola"), FR("Bonjour")
}
class Person(var name: String, var lang: Language = Language.EN)
fun main(args: Array<String>) {
val person = Person("Michael")
println("Hello, ${person.name}!")
}

64. enum class Language(val greeting: String) {
EN("Hello"), ES("Hola"), FR("Bonjour")
}
class Person(var name: String, var lang: Language = Language.EN) {
fun greet() = println("${lang.greeting}, $name!")
}
fun main(args: Array<String>) {
val person = Person("Michael")
println("Hello, ${person.name}!")
}

65. enum class Language(val greeting: String) {
EN("Hello"), ES("Hola"), FR("Bonjour")
}
class Person(var name: String, var lang: Language = Language.EN) {
fun greet() = println("${lang.greeting}, $name!")
}
fun main(args: Array<String>) {
val person = Person("Michael")
println("Hello, ${person.name}!")
}

66. enum class Language(val greeting: String) {
EN("Hello"), ES("Hola"), FR("Bonjour")
}
class Person(var name: String, var lang: Language = Language.EN) {
fun greet() = println("${lang.greeting}, $name!")
}
fun main(args: Array<String>) {
val person = Person("Michael")
}

67. enum class Language(val greeting: String) {
EN("Hello"), ES("Hola"), FR("Bonjour")
}
class Person(var name: String, var lang: Language = Language.EN) {
fun greet() = println("${lang.greeting}, $name!")
}
fun main(args: Array<String>) {
val person = Person("Michael")
person.greet()
}
> Hello, Michael!

68. enum class Language(val greeting: String) {
EN("Hello"), ES("Hola"), FR("Bonjour")
}
class Person(var name: String, var lang: Language = Language.EN) {
fun greet() = println("${lang.greeting}, $name!")
}
fun main(args: Array<String>) {
}

69. enum class Language(val greeting: String) {
EN("Hello"), ES("Hola"), FR("Bonjour")
}
class Person(var name: String, var lang: Language = Language.EN) {
fun greet() = println("${lang.greeting}, $name!")
}
fun main(args: Array<String>) {
val people = listOf(
Person("Michael"),
Person("Miguel", Language.SP),
Person("Michelle", Language.FR)
)
}

70. enum class Language(val greeting: String) {
EN("Hello"), ES("Hola"), FR("Bonjour")
}
class Person(var name: String, var lang: Language = Language.EN) {
fun greet() = println("${lang.greeting}, $name!")
}
fun main(args: Array<String>) {
val people = listOf(
Person("Michael"),
Person("Miguel", Language.SP),
Person("Michelle", Language.FR)
)
for (person in people) {
person.greet()
}
}

71. enum class Language(val greeting: String) {
EN("Hello"), ES("Hola"), FR("Bonjour")
}
class Person(var name: String, var lang: Language = Language.EN) {
fun greet() = println("${lang.greeting}, $name!")
}
fun main(args: Array<String>) {
val people = listOf(
Person("Michael"),
Person("Miguel", Language.SP),
Person("Michelle", Language.FR)
)
people.forEach { person ->
person.greet()
}
}

72. enum class Language(val greeting: String) {
EN("Hello"), ES("Hola"), FR("Bonjour")
}
class Person(var name: String, var lang: Language = Language.EN) {
fun greet() = println("${lang.greeting}, $name!")
}
fun main(args: Array<String>) {
val people = listOf(
Person("Michael"),
Person("Miguel", Language.SP),
Person("Michelle", Language.FR)
)
people.forEach { it.greet() }
}

73. enum class Language(val greeting: String) {
EN("Hello"), ES("Hola"), FR("Bonjour")
}
class Person(var name: String, var lang: Language = Language.EN) {
fun greet() = println("${lang.greeting}, $name!")
}
fun main(args: Array<String>) {
listOf(
Person("Michael"),
Person("Miguel", Language.SP),
Person("Michelle", Language.FR)
).forEach { it.greet() }
}
> Hello, Michael!
> Hola, Miguel!
> Bonjour, Michelle!

74. enum class Language(val greeting: String) {
EN("Hello"), ES("Hola"), FR("Bonjour")
}
open class Person(var name: String, var lang: Language = Language.EN) {
fun greet() = println("${lang.greeting}, $name!")
}
fun main(args: Array<String>) {
listOf(
Person("Michael"),
Person("Miguel", Language.SP),
Person("Michelle", Language.FR)
).forEach { it.greet() }.
}
Non-final

75. enum class Language(val greeting: String) {
EN("Hello"), ES("Hola"), FR("Bonjour")
}
open class Person(var name: String, var lang: Language = Language.EN) {
fun greet() = println("${lang.greeting}, $name!")
}
class Hispanophone(name: String) : Person(name, Language.ES)
class Francophone(name: String) : Person(name, Language.FR)
fun main(args: Array<String>) {
listOf(
Person("Michael"),
Person("Miguel", Language.SP),
Person("Michelle", Language.FR)
).forEach { it.greet() }
}
Inheritance

76. enum class Language(val greeting: String) {
EN("Hello"), ES("Hola"), FR("Bonjour")
}
open class Person(var name: String, var lang: Language = Language.EN) {
fun greet() = println("${lang.greeting}, $name!")
}
class Hispanophone(name: String) : Person(name, Language.ES)
class Francophone(name: String) : Person(name, Language.FR)
fun main(args: Array<String>) {
listOf(
Person("Michael"),
Hispanophone("Miguel"),
Francophone("Michelle")
).forEach { it.greet() }
}

77. enum class Language(val greeting: String) {
EN("Hello"), ES("Hola"), FR("Bonjour")
}
open class Person(var name: String, var lang: Language = Language.EN) {
fun greet() = println("${lang.greeting}, $name!")
}
class Hispanophone(name: String) : Person(name, Language.ES)
class Francophone(name: String) : Person(name, Language.FR)
fun main(args: Array<String>) {
listOf(
Person("Michael"),
Hispanophone("Miguel"),
Francophone("Michelle")
).forEach { it.greet() }
}

78. What Kotlin Adds to Java

79. Type inference

80. Type inference
String string = "";

81. Type inference
var string: String = ""

82. Type inference
var string = ""

83. Type inference
var string = ""
Var char = ' '

84. Type inference
var string = ""
var char = ' '
var int = 0

85. Type inference
var string = ""
var char = ' '
var int = 0
var long = 0L

86. Type inference
var string = ""
var char = ' '
var int = 0
var long = 0L
var float = 0F

87. Type inference
var int = 0
var long = 0L
var float = 0F
var double = 0.0
var string = ""
var char = ' '

88. Type inference
var string = ""
var char = ' '
var int = 0
var long = 0L
var float = 0F
var double = 0.0
var boolean = true

89. Type inference
var string = ""
var char = ' '
var int = 0
var long = 0L
var float = 0F
var double = 0.0
var boolean = true
var foo = MyFooType()

90. Null-safety

91. Null-safety
String a = null;

92. Null-safety
String a = null;
System.out.println(a.length());

93. Null-safety
String a = null;
System.out.println(a.length());
NullPointerException

94. Null-safety
val a: String = null

95. Null-safety
val a: String = null
Non-null type

96. Null-safety
val a: String? = null

97. Null-safety
val a: String? = null

98. Null-safety
val a: String? = null
println(a.length())

99. Null-safety
val a: String? = null
println(a.length())
Unsafe call