3. Kotlin Syntax and Basics

Kotlin is a modern, statically typed programming language that is gaining popularity for Android app development. Its concise syntax and powerful features make it an excellent choice for developers looking to build robust applications efficiently. In this section, we will delve into the syntax and basics of Kotlin, providing a solid foundation for your journey into Android app development.

Variables and Data Types

In Kotlin, variables can be declared using either val or var. The val keyword is used for read-only variables, which means once they are assigned a value, it cannot be changed. On the other hand, var is used for mutable variables that can be reassigned.

val immutableVariable: Int = 10
var mutableVariable: Int = 20
mutableVariable = 30 // This is allowed
// immutableVariable = 15 // This will cause a compile error

Kotlin supports a variety of data types, including:

• Numbers: Int, Long, Short, Byte, Double, Float
• Characters: Char
• Booleans: Boolean
• Strings: String

Kotlin's type inference allows you to omit the explicit type declaration if the type can be inferred from the context:

val inferredInt = 42 // Type Int is inferred
val inferredString = "Hello, Kotlin" // Type String is inferred

Functions

Functions in Kotlin are declared using the fun keyword. A function can have parameters and a return type. If no return type is specified, the function returns Unit, which is equivalent to void in Java.

fun add(a: Int, b: Int): Int {
    return a + b
}

fun printMessage(message: String) {
    println(message)
}

Kotlin supports single-expression functions, which allow you to write functions in a more concise way:

fun subtract(a: Int, b: Int): Int = a - b

Control Flow

Kotlin provides several control flow constructs, including if, when, for, and while loops.

The if expression in Kotlin is similar to Java but can also be used as an expression to return a value:

val max = if (a > b) a else b

The when expression is a powerful alternative to the switch statement in Java:

val result = when (x) {
    1 -> "One"
    2 -> "Two"
    else -> "Unknown"
}

Kotlin's for loop is used to iterate over ranges, arrays, or collections:

for (i in 1..5) {
    println(i)
}

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

The while and do-while loops function similarly to their Java counterparts:

var x = 5
while (x > 0) {
    println(x)
    x--
}

do {
    println("This will be printed at least once")
} while (false)

Null Safety

One of Kotlin's standout features is its built-in null safety, which helps prevent null pointer exceptions. In Kotlin, by default, variables cannot hold a null value. If you want to allow a variable to hold null, you need to declare it as a nullable type using the question mark (?) symbol:

var nullableString: String? = null

To access a nullable variable safely, Kotlin provides several options:

• Safe Call Operator (?.): Returns null if the variable is null, otherwise calls the method.
• Elvis Operator (?:): Provides a default value if the variable is null.
• Non-Null Assertion Operator (!!): Throws a NullPointerException if the variable is null.

val length = nullableString?.length
val lengthWithDefault = nullableString?.length ?: 0
val forcedLength = nullableString!!.length // Use with caution

Collections

Kotlin provides a rich set of collection types, such as lists, sets, and maps. These collections are available in two variants: read-only and mutable. Read-only collections are declared using the listOf, setOf, and mapOf functions, while mutable collections use mutableListOf, mutableSetOf, and mutableMapOf.

val readOnlyList = listOf(1, 2, 3)
val mutableList = mutableListOf(1, 2, 3)
mutableList.add(4)

val readOnlyMap = mapOf("key1" to "value1", "key2" to "value2")
val mutableMap = mutableMapOf("key1" to "value1")
mutableMap["key2"] = "value2"

Collections in Kotlin come with a variety of useful functions for filtering, mapping, and reducing data, making them highly versatile for data manipulation.

Classes and Objects

Kotlin's approach to object-oriented programming is both simple and powerful. Classes are declared using the class keyword. By default, classes in Kotlin are final, meaning they cannot be subclassed unless explicitly marked with the open keyword.

open class Animal(val name: String) {
    fun sound() {
        println("$name makes a sound")
    }
}

class Dog(name: String) : Animal(name) {
    fun bark() {
        println("$name barks")
    }
}

Kotlin supports primary constructors, which are concise and can initialize properties directly:

class Person(val firstName: String, val lastName: String)

For more complex initialization, you can use an init block:

class Car(val make: String, val model: String) {
    init {
        println("Car created: $make $model")
    }
}

Data Classes

Data classes in Kotlin are a special kind of class that are intended to hold data. They automatically generate several useful methods, such as equals(), hashCode(), toString(), and copy():

data class User(val name: String, val age: Int)

val user1 = User("Alice", 30)
val user2 = user1.copy(name = "Bob")

Conclusion

Understanding the syntax and basics of Kotlin is crucial for any developer aiming to build Android applications. Kotlin's concise syntax, null safety, and powerful features like data classes and collection functions make it an ideal language for modern app development. As you continue to explore Kotlin, you'll discover even more capabilities that will enhance your coding efficiency and effectiveness.

Next page of the Free Ebook:

4Variables and Data Types in Kotlin

7 minutes