Kotlin - Language Fundamentals & Syntax

Basic Syntax Rules

Case Sensitivity

Kotlin is case-sensitive, meaning main, Main, and MAIN are different:

fun main() { }     // ✅ Correct entry point
fun Main() { }     // ❌ Different function
fun MAIN() { }     // ❌ Different function

Semicolons are Optional

Unlike Java, semicolons are optional in Kotlin:

fun main() {
    println("Hello")
    val x = 5
    println(x)
}

fun main() {
    println("Hello");
    val x = 5;
    println(x);
}

Whitespace and Indentation

Kotlin ignores extra whitespace, but consistent indentation improves readability:

fun main() {
    val name = "Kotlin"    // 4 spaces indentation (recommended)
    if (name.isNotEmpty()) {
        println(name)      // 8 spaces for nested blocks
    }
}

Identifiers

Naming Rules

Identifiers are names for variables, functions, classes, etc. They must:

• Start with a letter (a-z, A-Z) or underscore (_)
• Contain only letters, digits (0-9), and underscores
• Not be a Kotlin keyword
• Be case-sensitive

name
firstName
age2
_count
userName
MAX_SIZE
isValid
calculate_tax

2name        // starts with digit
first-name   // contains hyphen
class        // keyword
my name      // contains space
@username    // contains @

Naming Conventions

Keywords

Keywords are reserved words that have special meaning in Kotlin:

Comments

Comments explain code and are ignored by the compiler:

Single-Line Comments

fun main() {
    // This is a single-line comment
    println("Hello") // Comment at end of line
}

Multi-Line Comments

/*
 * This is a multi-line comment
 * It can span multiple lines
 * Useful for longer explanations
 */
fun main() {
    /* Short multi-line comment */
    println("Hello")
}

Documentation Comments (KDoc)

/**
 * Calculates the area of a rectangle
 * @param width the width of the rectangle
 * @param height the height of the rectangle
 * @return the area as a Double
 */
fun calculateArea(width: Double, height: Double): Double {
    return width * height
}

Expressions vs Statements

Expressions

Expressions produce a value and can be used wherever a value is expected:

fun main() {
    val a = 5 + 3           // 5 + 3 is an expression
    val b = if (a > 5) 10 else 0  // if is an expression in Kotlin
    val c = when (a) {      // when is also an expression
        8 -> "eight"
        else -> "other"
    }
}

Statements

Statements perform an action but don't return a value:

fun main() {
    println("Hello")        // Statement: performs action
    val x = 5              // Statement: declares variable
}

Code Blocks

Code blocks are groups of statements enclosed in curly braces:

fun main() {                    // Function block
    val name = "Kotlin"
    
    if (name.isNotEmpty()) {    // If block
        println("Name: $name")
        println("Length: ${name.length}")
    }
    
    run {                       // Anonymous block
        val temp = "temporary"
        println(temp)
    }
    // temp is not accessible here
}

String Literals

Regular Strings

val greeting = "Hello, World!"
val name = "Kotlin"
val empty = ""

String Templates

val name = "Alice"
val age = 30
val message = "Hello, $name! You are $age years old."
val calculation = "5 + 3 = ${5 + 3}"

Raw Strings

val multiLine = """
    Line 1
    Line 2
    Line 3
    """.trimIndent()

val path = """C:\Users\name\Documents"""  // No need to escape backslashes

Basic Operators

Arithmetic Operators

val a = 10
val b = 3

println(a + b)  // Addition: 13
println(a - b)  // Subtraction: 7
println(a * b)  // Multiplication: 30
println(a / b)  // Division: 3
println(a % b)  // Modulus: 1

Assignment Operators

var x = 10
x += 5    // x = x + 5, result: 15
x -= 3    // x = x - 3, result: 12  
x *= 2    // x = x * 2, result: 24
x /= 4    // x = x / 4, result: 6

Comparison Operators

val a = 10
val b = 5

println(a > b)   // Greater than: true
println(a < b)   // Less than: false
println(a >= b)  // Greater than or equal: true
println(a <= b)  // Less than or equal: false
println(a == b)  // Equal: false
println(a != b)  // Not equal: true

Program Structure

Basic Structure

// Optional package declaration
package com.example.myapp

// Import statements
import kotlin.math.*

// Top-level declarations
val CONSTANT = "Global constant"

// Main function (entry point)
fun main() {
    println("Program starts here")
}

// Other functions
fun helper() {
    println("Helper function")
}

File Organization

• One file can contain multiple classes and functions
• File name doesn't need to match class name (unlike Java)
• Top-level functions are allowed
• Package structure should match directory structure

Common Syntax Patterns

Variable Declaration Pattern

val readOnly = "immutable"      // Type inferred
var mutable: String = "can change"  // Explicit type
lateinit var delayed: String    // Late initialization

Function Declaration Pattern

fun functionName(param1: Type, param2: Type): ReturnType {
    // function body
    return result
}

// Single expression function
fun add(a: Int, b: Int): Int = a + b

// No return type needed for Unit
fun printHello() {
    println("Hello")
}

Error Prevention Tips