Kotlin Basics – A Beginner’s Guide

Kotlin is a modern, concise, and powerful programming language designed to be fully interoperable with Java. It is widely used in Android development, backend applications, and multiplatform development. This tutorial will guide you through the fundamentals of Kotlin, covering key concepts with detailed explanations and examples.

1. Introduction to Kotlin

Kotlin was developed by JetBrains and officially announced as a first-class language for Android development by Google in 2017. It is designed to improve code readability, reduce boilerplate, and enhance developer productivity.

Why Learn Kotlin?

• Concise: Reduces boilerplate code compared to Java.
• Safe: Eliminates null pointer exceptions with null safety features.
• Interoperable: Works seamlessly with Java and existing Java libraries.
• Modern: Includes functional programming features and extension functions.
• Popular: Used by major companies like Google, Pinterest, Netflix, and Uber.

Setting Up Kotlin

To start coding in Kotlin, you can use:

• JetBrains IntelliJ IDEA (Recommended)
• Android Studio (For Android development)
• Online Kotlin Playground (For quick testing)

Installing Kotlin in IntelliJ IDEA

1. Download and install IntelliJ IDEA.
2. Create a new Kotlin project:
   • Select File > New > Project.
   • Choose Kotlin and select the project type (JVM, JS, or Native).
3. Add the Kotlin plugin (if not pre-installed).

---

2. Writing Your First Kotlin Program

Let’s write a simple “Hello, World!” program in Kotlin.

fun main() {
    println("Hello, World!")
}

Explanation:

• fun main() {} → Defines the main function, the entry point of a Kotlin program.
• println("Hello, World!") → Prints text to the console.

Run the program, and you will see:

Hello, World!

---

3. Variables and Data Types

Kotlin has two main types of variables:

1. Immutable (val) – Read-only, cannot be changed after assignment.
2. Mutable (var) – Can be modified later.

Example: Declaring Variables

val name = "Alice"  // Immutable
var age = 25        // Mutable
age = 26            // Allowed

Data Types in Kotlin

Kotlin has various data types:

• Integer types: Byte, Short, Int, Long
• Floating-point types: Float, Double
• Boolean: true or false
• Characters and Strings: Char, String

Example: Different Data Types

val number: Int = 10
val pi: Double = 3.14
val isKotlinFun: Boolean = true
val letter: Char = 'K'
val message: String = "Hello, Kotlin!"

---

4. Operators in Kotlin

Operators are used to perform operations on variables and values.

Arithmetic Operators:

val sum = 10 + 5        // Addition
val difference = 10 - 5 // Subtraction
val product = 10 * 5    // Multiplication
val quotient = 10 / 5   // Division
val remainder = 10 % 3  // Modulus

Comparison Operators:

val a = 10
val b = 5

println(a > b)  // true
println(a < b)  // false
println(a == b) // false
println(a != b) // true

Logical Operators:

val x = true
val y = false

println(x && y)  // false (AND)
println(x || y)  // true (OR)
println(!x)      // false (NOT)

---

5. Control Flow (if, when, loops)

If-Else Statement

val number = 10

if (number > 0) {
    println("Positive number")
} else if (number < 0) {
    println("Negative number")
} else {
    println("Zero")
}

When Expression (Like Switch in Java)

val day = 3

val dayName = when (day) {
    1 -> "Monday"
    2 -> "Tuesday"
    3 -> "Wednesday"
    4 -> "Thursday"
    5 -> "Friday"
    6, 7 -> "Weekend"
    else -> "Invalid day"
}

println(dayName)

For Loop

for (i in 1..5) {
    println("Count: $i")
}

While Loop

var count = 5
while (count > 0) {
    println("Countdown: $count")
    count--
}

---

6. Functions in Kotlin

Functions help organize code into reusable blocks.

Defining a Function

fun greet(name: String): String {
    return "Hello, $name!"
}

println(greet("Alice"))

Function with Default Parameters

fun greetUser(name: String = "Guest") {
    println("Hello, $name!")
}

greetUser()      // Output: Hello, Guest!
greetUser("Sam") // Output: Hello, Sam!

Lambda Expressions

kotlinCopyEditval add = { a: Int, b: Int -> a + b }
println(add(5, 10)) // Output: 15

---

7. Null Safety in Kotlin

Kotlin prevents NullPointerException by enforcing null safety.

Nullable vs Non-Nullable Variables

var nonNullString: String = "Hello" // Cannot be null
// nonNullString = null  // Error!

var nullableString: String? = "Hello"
nullableString = null // Allowed

Safe Call Operator (?.)

kotlinCopyEditval length = nullableString?.length // Returns length if not null, otherwise null

Elvis Operator (?:)

val message: String? = null
val text = message ?: "Default Message"
println(text) // Output: Default Message

---

Conclusion

In this post, we covered Kotlin basics, including variables, data types, operators, control flow, functions, and null safety. These fundamentals will help you write clean and efficient Kotlin code.

Next Steps:

In the next tutorial, we will dive deeper into Object-Oriented Programming (OOP) in Kotlin, covering classes, objects, inheritance, and more. Stay tuned,