Why you should totally switch to Kotlin

It’s time to start using a modern programming language

0# Java Interoperability

1# Familiar Syntax

class Foo {

val b: String = "b" // val means unmodifiable
var i: Int = 0 // var means modifiable

fun hello() {
val str = "Hello"
print("$str World")
}

fun sum(x: Int, y: Int): Int {
return x + y
}

fun maxOf(a: Float, b: Float) = if (a > b) a else b

}

2# String Interpolation

val x = 4
val y = 7
print("sum of $x and $y is ${x + y}") // sum of 4 and 7 is 11

3# Type Inference

val a = "abc"                         // type inferred to String
val b = 4 // type inferred to Int

val c: Double = 0.7 // type declared explicitly
val d: List<String> = ArrayList() // type declared explicitly

4# Smart Casts

if (obj is String) {
print(obj.toUpperCase()) // obj is now known to be a String
}

5# Intuitive Equals

val john1 = Person("John")
val john2 = Person("John")
john1 == john2 // true (structural equality)
john1 === john2 // false (referential equality)

6# Default Arguments

fun build(title: String, width: Int = 800, height: Int = 600) {
Frame(title, width, height)
}

7# Named Arguments

build("PacMan", 400, 300)                           // equivalent
build(title = "PacMan", width = 400, height = 300) // equivalent
build(width = 400, height = 300, title = "PacMan") // equivalent

8# The When Expression

when (x) {
1 -> print("x is 1")
2 -> print("x is 2")
3, 4 -> print("x is 3 or 4")
in 5..10 -> print("x is 5, 6, 7, 8, 9, or 10")
else -> print("x is out of range")
}
val res: Boolean = when {
obj == null -> false
obj is String -> true
else -> throw IllegalStateException()
}

9# Properties

class Frame {
var width: Int = 800
var height: Int = 600

val pixels: Int
get() = width * height
}

10# The Data Class

data class Person(val name: String,
var email: String,
var age: Int)

val john = Person("John", "john@gmail.com", 112)

11# Operator Overloading

data class Vec(val x: Float, val y: Float) {
operator fun plus(v: Vec) = Vec(x + v.x, y + v.y)
}

val v = Vec(2f, 3f) + Vec(4f, 1f)

12# Destructuring Declarations

for ((key, value) in map) {
print("Key: $key")
print("Value: $value")
}

13# Ranges

for (i in 1..100) { ... } 
for (i in 0 until 100) { ... }
for (i in 2..10 step 2) { ... }
for (i in 10 downTo 1) { ... }
if (x in 1..10) { ... }

14# Extension Functions

fun String.replaceSpaces(): String {
return this.replace(' ', '_')
}

val formatted = str.replaceSpaces()
str.removeSuffix(".txt")
str.capitalize()
str.substringAfterLast("/")
str.replaceAfter(":", "classified")

15# Null Safety

var a: String = "abc"
a = null // compile error

var b: String? = "xyz"
b = null // no problem
val x = b.length        // compile error: b might be null
if (b == null) return
val x = b.length // no problem
val x = b?.length       // type of x is nullable Int
val name = ship?.captain?.name ?: "unknown"
val x = b?.length ?: throw NullPointerException()  // same as below
val x = b!!.length // same as above

16# Better Lambdas

val sum = { x: Int, y: Int -> x + y }   // type: (Int, Int) -> Int
val res = sum(4,7) // res == 11
  1. Method parentheses can be moved or omitted if the lambda is the last or the only argument of a method.
  2. If we choose not to declare the argument of a single-argument-lambda it’ll be implicitly declared under the name it.
numbers.filter({ x -> x.isPrime() })
numbers.filter { x -> x.isPrime() }
numbers.filter { it.isPrime() }
persons
.filter { it.age >= 18 }
.sortedBy { it.name }
.map { it.email }
.forEach { print(it) }
verticalLayout {
padding = dip(30)
editText {
hint = “Name”
textSize = 24f
}
editText {
hint = “Password”
textSize = 24f
}
button(“Login”) {
textSize = 26f
}
}

17# IDE Support

IntelliJ will notice if you paste Java code into a Kotlin file

--

--

Software Engineer (Uber), Physics Major

Get the Medium app

A button that says 'Download on the App Store', and if clicked it will lead you to the iOS App store
A button that says 'Get it on, Google Play', and if clicked it will lead you to the Google Play store