Kotlin Syntax Basics: Understanding Variables, Functions, and Control Structures

In the previous article, we introduced Kotlin and explored the key differences between Kotlin and Java. Now, it's time to dive deeper into Kotlin syntax basics. In this article, we'll cover variables, functions, and control structures to help you get started with writing clean and concise Kotlin code. Let's begin!

1. Variables

Kotlin has two types of variables: val (immutable) and var (mutable).

// Immutable variable (read-only)
val name: String = "John Doe"

// Mutable variable (can be changed)
var age: Int = 30

In Kotlin, you can also use type inference to automatically determine the variable type, which makes the code more concise:

// Type inference
val name = "John Doe"
var age = 30

2. Functions

Kotlin functions are defined using the 'fun' keyword. Here's an example of a simple function that adds two numbers:

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

// Usage
val result = add(5, 3)

You can also use single-expression functions for more concise code:

fun add(a: Int, b: Int) = a + b

// Usage
val result = add(5, 3)

3. Control Structures

3.1 If-Else Expression

In Kotlin, the if-else control structure can also be used as an expression, returning a value based on a condition:

val age = 18
val status = if (age >= 18) "adult" else "minor"

println(status) // Output: adult

3.2 When Expression

The 'when' expression in Kotlin is a more powerful and concise alternative to Java's switch statement:

val number = 5
val result = when (number) {
    1 -> "one"
    2 -> "two"
    3 -> "three"
    4 -> "four"
    5 -> "five"
    else -> "unknown"
}

println(result) // Output: five

3.3 For Loop

Kotlin's for loop can be used with ranges and collections:

// Using a range
for (i in 1..5) {
    println(i)
}

// Using a collection
val names = listOf("Alice", "Bob", "Charlie")
for (name in names) {
    println(name)
}

3.4 While and Do-While Loops

Kotlin supports both while and do-while loops, similar to Java:

// While loop
var counter = 5
while (counter > 0) {
    println(counter)
    counter--
}

// Do-while loop
counter = 5
do {
    println(counter)
    counter--
} while (counter > 0)

Conclusion

In this article, we have explored the basics of Kotlin syntax, including variables, functions, and control structures. By understanding these fundamentals, you can start writing clean and concise Kotlin code. As you continue to learn Kotlin, you'll discover more advanced features that can help you write even more efficient and expressive code.

In the next article of this series, we'll dive into Kotlin's object-oriented programming features, such as classes, inheritance, and interfaces. Stay tuned!

Programming 101