Basic syntax in Kotlin

Package definition and imports

Package specification should be at the top of the source file.

package my.demo

import kotlin.text.*

// ...

It is not required to match directories and packages: source files can be placed arbitrarily in the file system.

See Packages.

Program entry point

An entry point of a Kotlin application is the main function.

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

Another form of main accepts a variable number of String arguments.

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

Print to the standard output

print prints its argument to the standard output.

fun main() {
    print("Hello ")
    print("world!")
}

println prints its arguments and adds a line break, so that the next thing you print appears on the next line.

println("Hello world!")println(42)

Functions

A function with two Int parameters and Int return type.

fun sum(a: Int, b: Int): Int {
    return a + b
}
​
fun main() {
    print("sum of 3 and 5 is ")
    println(sum(3, 5))
}

A function body can be an expression. Its return type is inferred.

fun sum(a: Int, b: Int) = a + b
​
fun main() {
    println("sum of 19 and 23 is ${sum(19, 23)}")
}

A function that returns no meaningful value.

fun printSum(a: Int, b: Int): Unit {
    println("sum of $a and $b is ${a + b}")
}
​
fun main() {
    printSum(-1, 8)
}

Unit return type can be omitted.

fun printSum(a: Int, b: Int) {
    println("sum of $a and $b is ${a + b}")
}
​
fun main() {
    printSum(-1, 8)
}

See Functions.

Variables

Read-only local variables are defined using the keyword val. They can be assigned a value only once.

fun main() {
    val a: Int = 1  // immediate assignment
    val b = 2   // `Int` type is inferred
    val c: Int  // Type required when no initializer is provided
    c = 3       // deferred assignment
    println("a = $a, b = $b, c = $c")
}

Variables that can be reassigned use the var keyword.

fun main() {
    var x = 5 // `Int` type is inferred
    x += 1
    println("x = $x")
}

You can declare variables at the top level.

val PI = 3.14
var x = 0
​
fun incrementX() { 
    x += 1 
}
​
fun main() {
    println("x = $x; PI = $PI")
    incrementX()
    println("incrementX()")
    println("x = $x; PI = $PI")
}

Creating classes and instances

To define a class, use the class keyword.

class Shape

Properties of a class can be listed in its declaration or body.

class Rectangle(var height: Double, var length: Double) {
    var perimeter = (height + length) * 2
}

The default constructor with parameters listed in the class declaration is available automatically.

class Rectangle(var height: Double, var length: Double) {
    var perimeter = (height + length) * 2 
}
fun main() {
    val rectangle = Rectangle(5.0, 2.0)
    println("The perimeter is ${rectangle.perimeter}")
}

Inheritance between classes is declared by a colon (: ). Classes are final by default; to make a class inheritable, mark it as open.

open class Shape

class Rectangle(var height: Double, var length: Double): Shape {
    var perimeter = (height + length) * 2
}

See classes and objects and instances.

Comments

Just like most modern languages, Kotlin supports single-line (or end-of-line) and multi-line (block) comments.

// This is an end-of-line comment

/* This is a block comment
   on multiple lines. */

Block comments in Kotlin can be nested.

/* The comment starts here
/* contains a nested comment */
and ends here. */

See Documenting Kotlin Code for information on the documentation comment syntax.

String templates

fun main() {
    var a = 1
    // simple name in template:
    val s1 = "a is $a" 
​
    a = 2
    // arbitrary expression in template:
    val s2 = "${s1.replace("is", "was")}, but now is $a"
    println(s2)
}

See String templates for details.

Conditional expressions

fun maxOf(a: Int, b: Int): Int {
    if (a > b) {
        return a
    } else {
        return b
    }
}
​
fun main() {
    println("max of 0 and 42 is ${maxOf(0, 42)}")
}

In Kotlin, if can also be used as an expression.

fun maxOf(a: Int, b: Int) = if (a > b) a else b
​
fun main() {
    println("max of 0 and 42 is ${maxOf(0, 42)}")
}

See if -expressions.

for loop

fun main() {
    val items = listOf("apple", "banana", "kiwifruit")
    for (item in items) {
        println(item)
    }
}
Target platform: JVMRunning on kotlin v.1.4.30

fun main() {
    val items = listOf("apple", "banana", "kiwifruit")
    for (index in items.indices) {
        println("item at $index is ${items[index]}")
    }
}
Target platform: JVMRunning on kotlin v.1.4.30

See for loop.

while loop

fun main() {
    val items = listOf("apple", "banana", "kiwifruit")
    var index = 0
    while (index < items.size) {
        println("item at $index is ${items[index]}")
        index++
    }
}
Target platform: JVMRunning on kotlin v.1.4.30

See while loop.

when expression

fun describe(obj: Any): String =
    when (obj) {
        1          -> "One"
        "Hello"    -> "Greeting"
        is Long    -> "Long"
        !is String -> "Not a string"
        else       -> "Unknown"
    }
​
fun main() {
    println(describe(1))
    println(describe("Hello"))
    println(describe(1000L))
    println(describe(2))
    println(describe("other"))
}
Target platform: JVMRunning on kotlin v.1.4.30

See when expression.

Ranges

Check if a number is within a range using in operator.

fun main() {
    val x = 10
    val y = 9
    if (x in 1..y+1) {
        println("fits in range")
    }
}

Check if a number is out of range.

fun main() {
    val list = listOf("a", "b", "c")
​
    if (-1 !in 0..list.lastIndex) {
        println("-1 is out of range")
    }
    if (list.size !in list.indices) {
        println("list size is out of valid list indices range, too")
    }
}

Iterate over a range.

fun main() {
    for (x in 1..5) {
        print(x)
    }
}

Or over a progression.

fun main() {
    for (x in 1..10 step 2) {
        print(x)
    }
    println()
    for (x in 9 downTo 0 step 3) {
        print(x)
    }
}

See Ranges and progressions.

Collections

Iterate over a collection.

fun main() {
    val items = listOf("apple", "banana", "kiwifruit")
    for (item in items) {
        println(item)
    }
}

Check if a collection contains an object using in operator.

fun main() {
    val items = setOf("apple", "banana", "kiwifruit")
    when {
        "orange" in items -> println("juicy")
        "apple" in items -> println("apple is fine too")
    }
}

Using lambda expressions to filter and map collections:

fun main() {
    val fruits = listOf("banana", "avocado", "apple", "kiwifruit")
    fruits
        .filter { it.startsWith("a") }
        .sortedBy { it }
        .map { it.toUpperCase() }
        .forEach { println(it) }
}

See Collections overview.

Nullable values and null checks

A reference must be explicitly marked as nullable when null value is possible. Nullable type names have ? at the end.

Return null if str does not hold an integer:

fun parseInt(str: String): Int? {
    // ...
}

Use a function returning nullable value:

fun parseInt(str: String): Int? {
    return str.toIntOrNull()
}
​
fun printProduct(arg1: String, arg2: String) {
    val x = parseInt(arg1)
    val y = parseInt(arg2)
​
    // Using `x * y` yields error because they may hold nulls.
    if (x != null && y != null) {
        // x and y are automatically cast to non-nullable after null check
        println(x * y)
    }
    else {
        println("'$arg1' or '$arg2' is not a number")
    }    
}
​
fun main() {
    printProduct("6", "7")
    printProduct("a", "7")
    printProduct("a", "b")
}

fun parseInt(str: String): Int? {
    return str.toIntOrNull()
}
​
fun printProduct(arg1: String, arg2: String) {
    val x = parseInt(arg1)
    val y = parseInt(arg2)
    
    // ...
    if (x == null) {
        println("Wrong number format in arg1: '$arg1'")
        return
    }
    if (y == null) {
        println("Wrong number format in arg2: '$arg2'")
        return
    }
​
    // x and y are automatically cast to non-nullable after null check
    println(x * y)
}
​
fun main() {
    printProduct("6", "7")
    printProduct("a", "7")
    printProduct("99", "b")
}
Target platform: JVMRunning on kotlin v.1.4.30

See Null-safety.

Type checks and automatic casts

The is operator checks if an expression is an instance of a type. If an immutable local variable or property is checked for a specific type, there's no need to cast it explicitly:

fun getStringLength(obj: Any): Int? {
    if (obj is String) {
        // `obj` is automatically cast to `String` in this branch
        return obj.length
    }
​
    // `obj` is still of type `Any` outside of the type-checked branch
    return null
}
​
fun main() {
    fun printLength(obj: Any) {
        println("Getting the length of '$obj'. Result: ${getStringLength(obj) ?: "Error: The object is not a string"} ")
    }
    printLength("Incomprehensibilities")
    printLength(1000)
    printLength(listOf(Any()))
}

fun getStringLength(obj: Any): Int? {
    if (obj !is String) return null
​
    // `obj` is automatically cast to `String` in this branch
    return obj.length
}
​
fun main() {
    fun printLength(obj: Any) {
        println("Getting the length of '$obj'. Result: ${getStringLength(obj) ?: "Error: The object is not a string"} ")
    }
    printLength("Incomprehensibilities")
    printLength(1000)
    printLength(listOf(Any()))
}

or even

fun getStringLength(obj: Any): Int? {
    // `obj` is automatically cast to `String` on the right-hand side of `&&`
    if (obj is String && obj.length > 0) {
        return obj.length
    }
​
    return null
}
​
fun main() {
    fun printLength(obj: Any) {
        println("Getting the length of '$obj'. Result: ${getStringLength(obj) ?: "Error: The object is not a string"} ")
    }
    printLength("Incomprehensibilities")
    printLength("")
    printLength(1000)
}

See Classes and Type casts.

Menu

Basic syntax in Kotlin

Package definition and imports

Program entry point

Print to the standard output

Functions

Variables

Creating classes and instances

Comments

String templates

Conditional expressions

for loop

while loop

when expression

Ranges

Collections

Nullable values and null checks

Type checks and automatic casts

0 Comments

Popular Posts

SQL

Programming Problem

Subscribe Us

Categories

Tags

Brand creation, trend analysis & style consulting

Contact form

Menu

Basic syntax in Kotlin

Package definition and imports﻿

Program entry point

Print to the standard output﻿

Functions﻿

Variables

Creating classes and instances

Comments

String templates

Conditional expressions﻿

for loop

while loop

when expression

Ranges

Collections

Nullable values and null checks

Type checks and automatic casts

You may like these posts

0 Comments

Popular Posts

SQL

Programming Problem

Subscribe Us

Categories

Tags

Brand creation, trend analysis & style consulting

Contact form

Package definition and imports

Print to the standard output

Functions

Conditional expressions