Kotlin for Android Developers - 1

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

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

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)

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

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)

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

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

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)

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

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!

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

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

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

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

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

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

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

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

Gradle & Kotlin
Writing Gradle build scripts
and plugins in Kotlin

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

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

}
Function keyword

}
Function name

}
Argumentname

}
Argumenttype

}
Return type

}

}
Unit inferred

fun main(args: Array<String>) {
}

var name = "World"
println("Hello, $name!")
}

var name = "World"
}
Variable declaration

var name = "World“
}
String interpolation

var name = "World"
if (args.isNotEmpty()) {
name = args[0]
}
}

val name = "World"
name = args[0]
}
}

val name = "World"
name = args[0]
}
}
Constant declaration

val name = "World"
name = args[0]
}
}
Val cannot be reassigned

val name = if (args.isNotEmpty()) {
args[0]
} else {
"World"
}
}

val name = if (args.isNotEmpty()) {
args[0]
} else {
"World"
}
}
Conditional assignment block

val name = if (args.isNotEmpty()) { args[0] } else { "World" }
}

val name = if (args.isNotEmpty()) args[0] else "World"
}

class Person(var name: String)
}

}
Class keyword

}
Class name

}
Primaryconstructor

}
Non-final classmember

}

val person = Person("Michael")
}

}
Instance declaration

println("Hello, ${person.name}!")
}
> Hello, Michael!

enum class Language(val greeting: String) {
EN("Hello"), ES("Hola"), FR("Bonjour")
}
}

}
class Person(var name: String, var lang: Language)
}

}
class Person(var name: String, var lang: Language = Language.EN)
}
Defaultvalue

}
class Person(var name: String, var lang: Language = Language.EN)
}

}
class Person(var name: String, var lang: Language = Language.EN) {
fun greet() = println("${lang.greeting}, $name!")
}
}

}
}
}

}
}
person.greet()
}
> Hello, Michael!

}
}
}

}
}
val people = listOf(
Person("Michael"),
Person("Miguel", Language.SP),
Person("Michelle", Language.FR)
)
}

}
}
Person("Michael"),
)
for (person in people) {
person.greet()
}
}

}
}
Person("Michael"),
)
people.forEach { person ->
person.greet()
}
}

}
}
Person("Michael"),
)
people.forEach { it.greet() }
}

}
}
listOf(
Person("Michael"),
).forEach { it.greet() }
}
> Hello, Michael!
> Hola, Miguel!
> Bonjour, Michelle!

}
open class Person(var name: String, var lang: Language = Language.EN) {
}
listOf(
Person("Michael"),
).forEach { it.greet() }.
}
Non-final

}
}
class Hispanophone(name: String) : Person(name, Language.ES)
class Francophone(name: String) : Person(name, Language.FR)
listOf(
Person("Michael"),
}
Inheritance

}
}
class Hispanophone(name: String) : Person(name, Language.ES)
class Francophone(name: String) : Person(name, Language.FR)
listOf(
Person("Michael"),
Hispanophone("Miguel"),
Francophone("Michelle")
}

Type inference
String string = "";

Type inference
var string: String = ""

Type inference
var string = ""

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

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

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

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

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

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

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()

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

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

Null-safety
val a: String = null

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

Null-safety
val a: String? = null

Null-safety
println(a.length())

Null-safety
println(a.length())
Unsafe call

Kotlin for Android Developers - 1

Recommended

More Related Content

What's hot (20)

Similar to Kotlin for Android Developers - 1 (20)

Recently uploaded (20)

Kotlin for Android Developers - 1