Kotlin Basics

Hello World

fun main() {
    println("Hello world")
}kotlin

Define/Declare Keyword

• val: define a variable that cannot be modified
• var: define a variable that can be modified

Basic Data Type

Numbers

Integer types

• Byte: 8 bits
• Short: 16 bits
• Int: 32 bits
• Long: 64 bits

fun main() {
    var a: Byte = 8
    var b: Short = 16
    var c = 32
    var d: Long = 64
    println(a::class.simpleName) // Byte
    println(b::class.java.typeName) // short
    println(c::class.simpleName) // Int
    println(d::class.java.typeName) // long
}kotlin

Floating-point types

• Float: 32 bits
• Double: 64 bits

fun main() {
    var a = 32f
    var b = 64.0
    println(a::class.simpleName) // Float
    println(b::class.simpleName) // Double
}kotlin

Literal constants

fun main() {
    var a = 0xff // hexadecimal == 255
    var b = 0b11 // binary == 3
    var c = 1e9 // 1 * 10 ^ 9 ==> 1000000000
    var d = 1_000_000_000 // 1000000000
    // Octal literals are not supported in Kotlin.
}kotlin

Unsigned Types

• UByte
• UShort
• UInt
• ULong
• ...

Array

Null Safety

? nullable types

fun main() {
    var a: Int = 1 // cannot be null
    var b: Int? = null // can be null
}kotlin

Safe Calls

val a = "Kotlin"
val b: String? = null
println(b?.length)
println(a?.length) // Unnecessary safe call

// check null
val a: String? = null
println(if (a?.length == null) "a is null" else "a not null")
println(a?.length == null)
a?.length?.dec()?.inc() // call in chain, return null instead of throw NPE

// let: pass null in safe call
val listWithNulls: List<String?> = listOf("Kotlin", null)
for (item in listWithNulls) {
    item?.let { println(it) } // prints Kotlin and ignores null
}

// safe call on left side of assignment
// If either `person` or `person.department` is null, the function is not called:
// person?.department?.head = managersPool.getManager()kotlin

Elvis Operator

• ${nullable variable} ?: ${otherwise value}:

fun foo(node: Node): String? {
    val parent = node.getParent() ?: return null
    val name = node.getName() ?: throw IllegalArgumentException("name expected")
    // ...
}kotlin

Not Null Assertion Operator !!

• !!: Convert any value to non-null type, and will throw NPE if the reference is null.

Safe Cast

Collections of a nullable type

val nullableList: List<Int?> = listOf(1, 2, null, 4)
val intList: List<Int> = nullableList.filterNotNull()kotlin

Collections