The Android Software Stack

Android is like a well-organized toolbox, with each layer having a specific job. Let's look at how these layers work together:

The Linux Kernel: The Foundation

What It Does

• Manages memory and system resources
• Handles multiple tasks running at the same time
• Controls hardware like the screen, camera, and speakers
• Manages power to keep your battery lasting longer

The Linux Kernel is like the foundation of a house - it's what everything else is built on. It handles the basic stuff that makes your phone work:

• Managing memory (like keeping track of what apps are using)
• Handling multiple tasks (like running your music app while checking email)
• Controlling hardware (like the screen, camera, and speakers)
• Managing power (like putting your phone to sleep when you're not using it)

Hardware Abstraction Layer: The Translator

What It Does

• Translates between your app and the phone's hardware
• Makes sure apps work on different types of phones
• Handles communication with sensors and cameras
• Ensures consistent behavior across devices

The Hardware Abstraction Layer (HAL) is like a translator between your app and the phone's hardware. It helps your app talk to things like:

• The camera
• The microphone
• The accelerometer (for detecting movement)
• Other sensors and hardware features

Android Runtime: The App Runner

What It Does

• Runs your Android apps efficiently
• Converts app code into a format your phone can understand
• Optimizes app performance and battery usage
• Manages app resources and memory

The Android Runtime (ART) is like a personal trainer for your apps - it helps them run faster and use less battery. Here's how it works:

• When you build your app, it's compiled into a special format called DEX
• When you install the app, ART converts it into a format your phone can understand
• This makes your apps run faster and use less battery

Android Libraries: The Toolbox

What It Does

• Provides ready-to-use code for common tasks
• Handles graphics, animations, and user interface
• Manages user input and touch events
• Connects to system services and features

Android Libraries are like a toolbox full of ready-to-use tools. Here are some of the most useful ones:

• android.app - The basic building blocks for your apps
• android.content - Helps apps share data with each other
• android.graphics - Tools for drawing and animations
• android.view - Building blocks for your app's interface
• android.widget - Ready-made buttons, text fields, and other UI elements

Application Framework: The Rule Book

What It Does

• Manages how apps start, run, and stop
• Handles notifications and alerts
• Manages app resources and settings
• Helps apps work together and share data

The Application Framework is like a rule book that helps apps work together. It includes:

• Activity Manager - Controls how apps start, stop, and switch between each other
• Content Providers - Lets apps share data (like contacts or photos)
• Resource Manager - Manages things like text, colors, and layouts
• Notifications Manager - Handles alerts and notifications

Applications: The User Interface

What It Does

• Provides the interface you see and use
• Handles user interactions and input
• Delivers specific features and functionality
• Creates the user experience

Applications are what you see and use every day - they're the top layer of the Android cake. This includes:

• Built-in apps (like Phone, Messages, and Camera)
• Apps you install from the Play Store
• Apps you create yourself

What is Gradle?

What It Does

• Builds your app automatically
• Manages project configuration
• Handles dependencies
• Creates different versions of your app

When you create a new Android Studio project, it starts with about 80 files. When you click the Run button, Gradle:

• Generates additional files
• Compiles your code
• Downloads needed libraries
• Creates the final app package
• Ends up with about 700 files in your project

Project vs App: Understanding the Structure

Key Gradle Features

Sensible Defaults: The Smart Assistant

Gradle comes with smart default settings, so you don't have to configure everything yourself. It's like having a chef who knows the basic recipe - you only need to tell them if you want something different.

Dependencies: The Shopping List

Dependencies are like ingredients your app needs to work. For example, if your app needs to show a map, it needs the Google Maps library. Gradle can:

• Find libraries your app needs
• Download them automatically
• Make sure they work together

Build Variants: Different Versions

Build variants let you create different versions of your app. For example:

• A free version and a paid version
• A phone version and a tablet version
• A test version and a release version

Understanding Gradle Files

Settings File

The settings.gradle.kts file is like the project's address book - it tells Gradle where to find libraries and what to call your project:

pluginManagement {
    repositories {
        google()
        mavenCentral()
        gradlePluginPortal()
    }
}
dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        google()
        mavenCentral()
    }
}
rootProject.name = "ThemeDemo"
include(":app")

Project Build File

This is like the master recipe for your entire project. It's usually simple:

plugins {
    alias(libs.plugins.androidApplication) apply false
    alias(libs.plugins.jetbrainsKotlinAndroid) apply false
    alias(libs.plugins.kotlin.compose) apply false
}

Module Build File

This is like the specific recipe for your app. It tells Gradle:

• What tools to use (plugins)
• What your app is called (namespace)
• What Android versions it works with (SDK versions)
• What libraries it needs (dependencies)

Here's a breakdown of the important parts:

plugins {
    alias(libs.plugins.android.application)  // For building Android apps
    alias(libs.plugins.kotlin.android)       // For using Kotlin
    alias(libs.plugins.kotlin.compose)       // For using Jetpack Compose
}

android {
    namespace = "com.example.conversion"     // Your app's unique name
    compileSdk = 35                         // Android version to build with
    
    defaultConfig {
        applicationId = "com.example.conversion"  // Your app's ID
        minSdk = 28                            // Minimum Android version
        targetSdk = 35                         // Target Android version
        versionCode = 1                        // Version number
        versionName = "1.0"                    // Version name
    }
}

dependencies {
    // Core Android libraries
    implementation(libs.androidx.core.ktx)
    implementation(libs.androidx.lifecycle.runtime.ktx)
    
    // Compose libraries
    implementation(libs.androidx.activity.compose)
    implementation(platform(libs.androidx.compose.bom))
    implementation(libs.androidx.ui)
    implementation(libs.androidx.material3)
    
    // Testing libraries
    testImplementation(libs.junit)
    androidTestImplementation(libs.androidx.junit)
}

Version Catalog

The version catalog is like a master ingredient list that keeps track of all the versions. You can find it at Gradle Scripts → libs.versions.toml:

[versions]
agp = "8.3.0"
kotlin = "1.9.0"
coreKtx = "1.12.0"
junit = "4.13.2"
espressoCore = "3.5.1"
appcompat = "1.6.1"
material = "1.11.0"
activity = "1.8.0"
constraintlayout = "2.1.4"

[libraries]
androidx-core-ktx = { group = "androidx.core", name = "core-ktx", version.ref = "coreKtx" }
material = { group = "com.google.android.material", name = "material", version.ref = "material" }
activity = { group = "androidx.activity", name = "activity", version.ref = "activity" }

[plugins]
androidApplication = { id = "com.android.application", version.ref = "agp" }

The Emergence of Kotlin

Kotlin was introduced in 2011 by JetBrains, the company known for creating IntelliJ IDEA, a popular IDE for Java development. The language was designed to be fully interoperable with Java while addressing some of the common pain points of Java, such as verbosity, null safety issues, and boilerplate code.

Kotlin's Adoption for Android Development

Kotlin's significance in the Android development landscape was solidified in 2017 when Google announced official support for Kotlin on Android during their annual developer conference, Google I/O. This endorsement was a response to the growing popularity of Kotlin among Android developers who appreciated its concise syntax and robust features, which streamlined common programming tasks and reduced the likelihood of bugs.

When to Use Kotlin

• When starting a new Android project (Google's preferred language)
• When maintaining large codebases where code clarity is crucial
• When working with teams familiar with modern programming paradigms
• When you want to reduce potential runtime errors through better type safety

Key Advantages of Kotlin

Kotlin Playground

There is a Kotlin Playground where you can write small kotlin scripts to practice and experiment with the language. This is great for learning, but be aware that it's not suited for Android Studio development.

To use the examples from this chapter in the Kotlin Playground you need to write the code examples inside the function main(). You can then click the run button in the upper right corner to see the output. You can also edit the code and run it again to see the changes.

fun main() {
        // Put the code exxamples here
    }
    

Practical Examples

// ===========================================
// KOTLIN VS JAVA COMPARISON EXAMPLES
// ===========================================

// Example 1: Data Classes - The Power of Conciseness
// This demonstrates how Kotlin reduces boilerplate code dramatically

// Java equivalent would require:
// - Private fields
// - Constructor
// - Getters and setters
// - equals() and hashCode()
// - toString()
// - copy() method
// - Approximately 50+ lines of code!

// Kotlin data class - just 1 line!
data class Person(val name: String, val age: Int)

// Using the data class
val person1 = Person("Alice", 25)
val person2 = Person("Bob", 30)
val person3 = Person("Alice", 25)

println("=== DATA CLASS EXAMPLE ===")
println("Person 1: $person1")
println("Person 2: $person2")
println("Person 3: $person3")

// Automatic equals and hashCode
println("Person 1 equals Person 3: ${person1 == person3}")  // true
println("Person 1 equals Person 2: ${person1 == person2}")  // false

// Automatic copy method
val person4 = person1.copy(age = 26)
println("Person 4 (copy with age change): $person4")

// Automatic component functions for destructuring
val (name, age) = person1
println("Destructured: name=$name, age=$age")

// Example 2: Null Safety - Preventing Runtime Crashes
// This shows how Kotlin prevents null pointer exceptions at compile time
println("\n=== NULL SAFETY EXAMPLE ===")

// In Java, this would compile but crash at runtime:
// String name = null;
// int length = name.length(); // NullPointerException!

// In Kotlin, this won't even compile:
// val name: String = null  // Compile error!

// Safe nullable types
val nullableName: String? = null
val safeName: String = "John"

// Safe calls - won't crash
val length1 = nullableName?.length
val length2 = safeName.length

println("Nullable name length: $length1")  // null
println("Safe name length: $length2")      // 4

// Elvis operator for default values
val displayName = nullableName ?: "Unknown"
println("Display name: $displayName")      // "Unknown"

// Safe calls with chaining
val email: String? = "user@example.com"
val domain = email?.substringAfter('@')?.substringBefore('.')
println("Email domain: $domain")           // "user"

// Example 3: Extension Functions - Adding Methods to Existing Classes
// This demonstrates how Kotlin can extend classes you don't own
println("\n=== EXTENSION FUNCTIONS EXAMPLE ===")

// Add a new method to String class
fun String.addExclamation(): String {
    return "$this!"
}

// Add a method to check if string is palindrome
fun String.isPalindrome(): Boolean {
    val cleaned = this.lowercase().filter { it.isLetterOrDigit() }
    return cleaned == cleaned.reversed()
}

// Add a method to format phone numbers
fun String.formatPhoneNumber(): String {
    val digits = this.filter { it.isDigit() }
    return when {
        digits.length == 10 -> "(${digits.substring(0, 3)}) ${digits.substring(3, 6)}-${digits.substring(6)}"
        digits.length == 11 && digits.startsWith("1") -> "1 (${digits.substring(1, 4)}) ${digits.substring(4, 7)}-${digits.substring(7)}"
        else -> this
    }
}

// Use the extension functions
val greeting = "Hello"
val palindrome = "A man a plan a canal Panama"
val phoneNumber = "5551234567"

println("Greeting with exclamation: ${greeting.addExclamation()}")
println("Is '$palindrome' a palindrome? ${palindrome.isPalindrome()}")
println("Formatted phone: ${phoneNumber.formatPhoneNumber()}")

// Example 4: Smart Casts - Automatic Type Casting
// This shows how Kotlin eliminates the need for explicit casting
println("\n=== SMART CASTS EXAMPLE ===")

// Function that works with different types
fun processValue(value: Any): String {
    return when (value) {
        is String -> {
            // Kotlin automatically knows 'value' is String here
            "String: '${value.uppercase()}' (length: ${value.length})"
        }
        is Int -> {
            // Kotlin automatically knows 'value' is Int here
            "Integer: $value (doubled: ${value * 2})"
        }
        is List<*> -> {
            // Kotlin automatically knows 'value' is List here
            "List with ${value.size} items: $value"
        }
        is Boolean -> {
            // Kotlin automatically knows 'value' is Boolean here
            "Boolean: $value (opposite: ${!value})"
        }
        else -> "Unknown type: ${value::class.simpleName}"
    }
}

// Test smart casts with different types
val testValues = listOf("Hello", 42, listOf(1, 2, 3), true, 3.14)

for (value in testValues) {
    println("Processing: ${processValue(value)}")
}

// Example 5: Lambda Expressions and Higher-Order Functions
// This demonstrates Kotlin's functional programming capabilities
println("\n=== LAMBDA EXPRESSIONS EXAMPLE ===")

// Lambda expressions
val add = { x: Int, y: Int -> x + y }
val multiply = { x: Int, y: Int -> x * y }
val isEven = { x: Int -> x % 2 == 0 }

// Higher-order function that takes a function as parameter
fun performOperation(x: Int, y: Int, operation: (Int, Int) -> Int): Int {
    return operation(x, y)
}

// Use the higher-order function with different operations
val sum = performOperation(10, 5, add)
val product = performOperation(10, 5, multiply)

println("10 + 5 = $sum")
println("10 * 5 = $product")

// Lambda with collections
val numbers = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
val evenNumbers = numbers.filter(isEven)
val doubledNumbers = numbers.map { it * 2 }
val sumOfEvens = evenNumbers.sum()

println("Original numbers: $numbers")
println("Even numbers: $evenNumbers")
println("Doubled numbers: $doubledNumbers")
println("Sum of evens: $sumOfEvens")

// Example 6: String Templates and Interpolation
// This shows Kotlin's powerful string handling
println("\n=== STRING TEMPLATES EXAMPLE ===")

val userName = "Alice"
val userAge = 25
val userScore = 95.5

// Simple string interpolation
val simpleMessage = "Hello, $userName! You are $userAge years old."
println(simpleMessage)

// Complex expressions in strings
val detailedMessage = """
User Profile:
  Name: ${userName.uppercase()}
  Age: $userAge
  Score: ${String.format("%.1f", userScore)}%
  Status: ${if (userScore >= 90) "Excellent" else "Good"}
  Next birthday: ${userAge + 1}
""".trimIndent()

println(detailedMessage)

// Example 7: When Expression - Powerful Switch Statement
// This demonstrates Kotlin's enhanced switch-like functionality
println("\n=== WHEN EXPRESSION EXAMPLE ===")

fun getDayDescription(day: String): String {
    return when (day.lowercase()) {
        "monday" -> "Start of the work week"
        "tuesday" -> "Second day of the work week"
        "wednesday" -> "Hump day - middle of the week"
        "thursday" -> "Almost Friday"
        "friday" -> "TGIF - Thank Goodness It's Friday!"
        "saturday", "sunday" -> "Weekend - time to relax!"
        else -> "Unknown day"
    }
}

fun getGradeDescription(score: Int): String {
    return when {
        score >= 90 -> "A - Excellent"
        score >= 80 -> "B - Good"
        score >= 70 -> "C - Satisfactory"
        score >= 60 -> "D - Needs Improvement"
        else -> "F - Failed"
    }
}

// Test the when expressions
val testDays = listOf("Monday", "Wednesday", "Saturday", "Invalid")
val testScores = listOf(95, 87, 72, 55, 100)

println("Day Descriptions:")
for (day in testDays) {
    println("  $day: ${getDayDescription(day)}")
}

println("\nGrade Descriptions:")
for (score in testScores) {
    println("  Score $score: ${getGradeDescription(score)}")
}

// Example 8: Real-World Kotlin Usage Scenarios
println("\n=== REAL-WORLD KOTLIN SCENARIOS ===")

// Scenario 1: User Management System
data class User(
    val id: String,
    val name: String,
    val email: String,
    val isActive: Boolean = true,
    val createdAt: String = "2024-01-01"
)

// Extension function for user validation
fun User.isValidEmail(): Boolean {
    return email.contains("@") && email.contains(".") && email.indexOf("@") < email.lastIndexOf(".")
}

// Extension function for user display
fun User.getDisplayInfo(): String {
    return """
    User ID: $id
    Name: $name
    Email: $email
    Status: ${if (isActive) "Active" else "Inactive"}
    Created: $createdAt
    """.trimIndent()
}

// Create and use users
val users = listOf(
    User("user1", "Alice Johnson", "alice@example.com"),
    User("user2", "Bob Smith", "bob@example.com", isActive = false),
    User("user3", "Charlie Brown", "invalid-email")
)

println("User Management System:")
for (user in users) {
    println("\n${user.getDisplayInfo()}")
    println("Valid email: ${user.isValidEmail()}")
}

// Scenario 2: Product Catalog with Smart Features
data class Product(
    val id: String,
    val name: String,
    val price: Double,
    val category: String,
    val inStock: Boolean = true
)

// Extension function for product formatting
fun Product.getFormattedPrice(): String {
    return "$${String.format("%.2f", price)}"
}

// Extension function for stock status
fun Product.getStockStatus(): String {
    return if (inStock) "In Stock" else "Out of Stock"
}

// Extension function for discount calculation
fun Product.calculateDiscountedPrice(discountPercent: Double): Double {
    return price * (1 - discountPercent / 100)
}

val products = listOf(
    Product("prod1", "Laptop", 999.99, "Electronics"),
    Product("prod2", "Book", 29.99, "Books"),
    Product("prod3", "Phone", 699.99, "Electronics", inStock = false)
)

println("\nProduct Catalog:")
for (product in products) {
    val discountedPrice = product.calculateDiscountedPrice(10.0)
    println("""
    ${product.name}
      Price: ${product.getFormattedPrice()}
      Category: ${product.category}
      Stock: ${product.getStockStatus()}
      With 10% discount: $${String.format("%.2f", discountedPrice)}
    """.trimIndent())
}

Compilation to Bytecode

Both Kotlin and Java are statically typed languages that compile to the same bytecode format, which runs on the Java Virtual Machine (JVM). This means that when you write Android applications in Kotlin or Java, the source code is compiled into JVM bytecode, which is then executed by the Android Runtime (ART) on Android devices.

The ability to compile to the same bytecode allows Kotlin and Java to be used interchangeably or together within the same project. Android developers can gradually migrate Java codebases to Kotlin, integrating Kotlin files into existing Java applications without needing to rewrite the entire application. This seamless integration is facilitated by the Kotlin plugin for Android Studio, which includes tools for converting Java code to Kotlin automatically.

Primitive Data Types:

NOTE: Kotlin doesn't have primitive types in the same way as Java does. However, it provides a set of classes that represent primitive data types under the hood. These classes are optimized for performance and behave like primitives, but they are still objects.

When to Use

• Use Int, Long for whole numbers depending on size needed
• Use Double for decimal numbers (Float for memory-constrained cases)
• Use Boolean for true/false conditions
• Use Char for single characters

Object Data Types:

When to Use

• Use String for text of any length
• Use Array for fixed-size collections
• Use List, Set, Map for flexible collections

Variables: Immutable and Mutable

When to Use

• Use val by default (prefer immutability)
• Use var only when a value needs to change

Practical Examples

// ===========================================
// VARIABLE DECLARATION EXAMPLES
// ===========================================

// Example 1: Immutable variables (val)
// These variables cannot be changed after they're created
val immutableVal = "I cannot be changed"  // Immutable
val pi = 3.14159                          // Mathematical constant
val maxRetries = 3                         // Configuration value
val companyName = "TechCorp"               // Company name

println("Immutable variable: $immutableVal")
println("Pi: $pi")
println("Max retries: $maxRetries")
println("Company name: $companyName")

// Example 2: Mutable variables (var)
// These variables can be updated as needed
var mutableVar = "I can be changed"       // Mutable
var currentScore = 0                       // Game score that changes
var temperature = 72.5                     // Temperature that fluctuates
var isLoggedIn = false                     // Login status that changes

println("Mutable variable: $mutableVar")
println("Current score: $currentScore")
println("Temperature: $temperature")
println("Is logged in: $isLoggedIn")

// Example 3: Changing mutable variables
println("=== MUTABLE VARIABLE CHANGES ===")
println("Initial value: $mutableVar")
mutableVar = "See, I changed!"            // This works - updating the value
println("After change: $mutableVar")

currentScore = 100                         // Update score
println("Score updated to: $currentScore")

temperature = 85.2                         // Update temperature
println("Temperature changed to: $temperature")

isLoggedIn = true                          // Update login status
println("Login status: $isLoggedIn")

// Example 4: Attempting to change immutable variables (will cause errors)
// The following lines would cause compile errors:
// immutableVal = "Trying to change"      // Error: Val cannot be reassigned
// pi = 3.14                              // Error: Val cannot be reassigned
// maxRetries = 5                          // Error: Val cannot be reassigned

// Example 5: Type annotation examples
// You can explicitly specify the type, or let Kotlin infer it
val explicitInt: Int = 123              // Type annotation
val inferredInt = 123                   // Type inference (Kotlin knows it's Int)
val explicitString: String = "Hello"    // Type annotation
val inferredString = "World"            // Type inference (Kotlin knows it's String)

// Example 6: Real-world variable usage
println("\n=== REAL-WORLD VARIABLE USAGE ===")

// User profile information (immutable - shouldn't change)
val userId = "user_12345"
val dateOfBirth = "1990-05-15"
val email = "user@example.com"

// User session information (mutable - changes during use)
var loginAttempts = 0
var lastLoginTime = "2024-01-01 00:00:00"
var isOnline = false

// Game state variables (mutable - change during gameplay)
var playerHealth = 100
var playerLevel = 1
var experiencePoints = 0
var goldCoins = 50

println("User ID: $userId")
println("Login attempts: $loginAttempts")
println("Player health: $playerHealth")

// Update game state
playerHealth -= 20                       // Player took damage
experiencePoints += 150                  // Player gained experience
goldCoins += 25                         // Player found treasure

println("After updates:")
println("Player health: $playerHealth")
println("Experience points: $experiencePoints")
println("Gold coins: $goldCoins")

Nullability

When to Use

• Use non-nullable types by default
• Use nullable types only when a value might legitimately be absent
• Use safe call operator when working with nullable values

Kotlin's type system helps prevent null pointer exceptions by making "nullability" explicit in the type system. By default, regular types cannot hold null:

Practical Examples

// ===========================================
// NULLABILITY EXAMPLES
// ===========================================

// Example 1: Non-nullable vs nullable types
println("=== NULLABILITY COMPARISON ===")

// Non-nullable String - cannot be null
val nonNullableName: String = "John"
// val nonNullableName2: String = null  // This would cause a compile error!

// Nullable String - can be null
val nullableName: String? = null
val nullableName2: String? = "Jane"
val nullableName3: String? = "Bob"

println("Non-nullable name: $nonNullableName")
println("Nullable names: $nullableName, $nullableName2, $nullableName3")

// Example 2: Safe call operator (?.)
// This safely accesses properties without causing crashes
println("\n=== SAFE CALL OPERATOR ===")

val names = listOf(nullableName, nullableName2, nullableName3, "Alice")

for (name in names) {
    // Safe call - won't crash if name is null
    val length = name?.length
    println("Name: '$name', Length: $length")
    
    // You can also chain safe calls
    val uppercase = name?.uppercase()
    println("  Uppercase: $uppercase")
}

// Example 3: Elvis operator (?:)
// This provides default values when dealing with null
println("\n=== ELVIS OPERATOR ===")

val userInput1: String? = null
val userInput2: String? = "Hello World"
val userInput3: String? = ""

// Provide default values for null cases
val displayName1 = userInput1 ?: "Guest"
val displayName2 = userInput2 ?: "Guest"
val displayName3 = userInput3 ?: "Guest"  // Empty string is not null, so no default

println("User 1: '$userInput1' -> Display: '$displayName1'")
println("User 2: '$userInput2' -> Display: '$displayName2'")
println("User 3: '$userInput3' -> Display: '$displayName3'")

// Example 4: Safe conditional with if check
// This is a way to handle null values safely
println("\n=== SAFE CONDITIONAL CHECKS ===")

val potentialName: String? = "Alice"

if (potentialName != null) {
    // Within this block, Kotlin knows potentialName is not null
    val nameLength = potentialName.length  // Smart cast - no need for safe call
    val uppercaseName = potentialName.uppercase()
    println("Name: $potentialName, Length: $nameLength, Uppercase: $uppercaseName")
} else {
    println("No name provided")
}


// Example 5: Not-null assertion (!!) - Use with caution!
// This forces Kotlin to treat a nullable value as non-null
println("\n=== NOT-NULL ASSERTION (DANGEROUS) ===")

val definitelyNotNull: String? = "Safe to use"
val mightBeNull: String? = null

try {
    // This is safe because we know the value is not null
    val length1 = definitelyNotNull!!.length
    println("Safe assertion: $length1")
    
    // This will crash with NullPointerException!
    val length2 = mightBeNull!!.length
    println("This will never print: $length2")
} catch (e: NullPointerException) {
    println("Caught NullPointerException: ${e.message}")
}

// Example 6: Real-world nullability scenarios
println("\n=== REAL-WORLD NULLABILITY SCENARIOS ===")

// Simulate user input that might be missing
val userAge: String? = "25"
val userPhone: String? = null
val userAddress: String? = ""

// Process user information safely
val age = userAge?.toIntOrNull() ?: 0
val phone = userPhone ?: "No phone provided"
val address = if (userAddress.isNullOrEmpty()) "No address provided" else userAddress

println("User Profile:")
println("  Age: $age")
println("  Phone: $phone")
println("  Address: $address")

// Example 7: Working with collections that might contain null
println("\n=== NULLABLE COLLECTIONS ===")

val mixedList: List = listOf("Alice", null, "Bob", null, "Charlie")

// Filter out null values
val nonNullNames = mixedList.filterNotNull()
println("All names (including nulls): $mixedList")
println("Non-null names only: $nonNullNames")

// Count null vs non-null values
val nullCount = mixedList.count { it == null }
val nonNullCount = mixedList.count { it != null }
println("Null values: $nullCount, Non-null values: $nonNullCount")

Let Function

When to Use

• When you want to perform operations only if a value is not null
• To avoid repeating a variable name multiple times
• To limit the scope of variables

Practical Examples

// ===========================================
// LET FUNCTION EXAMPLES
// ===========================================

// Example 1: Basic usage with non-null value
// The let function executes the block and returns the result
println("=== BASIC LET USAGE ===")
val name = "Alice"
val result = name.let {
    println("Processing name: $it")
    it.length  // Returns the length of 'name'
}
println("Result: $result")

// Example 2: Null-safe usage with let
// This is the most common use case for let
println("\n=== NULL-SAFE LET USAGE ===")
val nullableName: String? = "Bob"
val nameLength = nullableName?.let {
    println("Name is: $it")
    it.length  // This block only executes if nullableName is not null
} ?: 0
println("Name length: $nameLength")

// Example 3: Let with null value
// When the value is null, the let block is skipped
println("\n=== LET WITH NULL VALUE ===")
val emptyName: String? = null
val length = emptyName?.let {
    it.length  // This block is skipped if emptyName is null
} ?: 0
println("Length of null name: $length")

// Example 4: Let for data transformation
// Let is great for transforming data safely
println("\n=== LET FOR DATA TRANSFORMATION ===")
val userInput: String? = "  hello world  "

val processedInput = userInput?.let {
    it.trim()           // Remove whitespace
        .lowercase()     // Convert to lowercase
        .replace(" ", "_") // Replace spaces with underscores
} ?: "default_value"

println("Original input: '$userInput'")
println("Processed input: '$processedInput'")

// Example 5: Let with multiple operations
// You can perform complex operations within the let block
println("\n=== LET WITH MULTIPLE OPERATIONS ===")
val email: String? = "user@example.com"

val userInfo = email?.let {
    val username = it.substringBefore('@')
    val domain = it.substringAfter('@')
    val isValid = it.contains('@') && it.contains('.')
    
    //mapOf is a function that creates a map from the given key-value pairs
    mapOf(
        "email" to it,
        "username" to username,
        "domain" to domain,
        "isValid" to isValid
    )
} ?: mapOf("error" to "No email provided")

println("User info: $userInfo")

// Example 6: Let for object initialization
// Let can be used to safely initialize objects
println("\n=== LET FOR OBJECT INITIALIZATION ===")
val configString: String? = "name=John,age=25,city=New York"

val config = configString?.let {
    val pairs = it.split(",")
    val configMap = mutableMapOf()
    
    for (pair in pairs) {
        val (key, value) = pair.split("=")
        configMap[key.trim()] = value.trim()
    }
    
    configMap
} ?: emptyMap()

println("Configuration: $config")

// Example 7: Let with chaining
// You can chain let calls for complex operations
println("\n=== LET WITH CHAINING ===")
val numberString: String? = "42"

val result2 = numberString?.let { str ->
    str.toIntOrNull()?.let { num ->
        if (num > 0) {
            num * 2
        } else {
            num * -1
        }
    }
} ?: 0

println("Original string: '$numberString'")
println("Processed result: $result2")

// Example 8: Real-world let usage scenarios
println("\n=== REAL-WORLD LET SCENARIOS ===")

// Scenario 1: Processing user input
val userInput2: String? = "  123.45  "
val processedNumber = userInput2?.let {
    it.trim().toDoubleOrNull()
}?.let { num ->
    if (num > 0) num else 0.0
} ?: 0.0

println("User input: '$userInput2'")
println("Processed number: $processedNumber")

// Scenario 2: Database query result
val queryResult: String? = "user_id=123,name=Alice,email=alice@example.com"
val user = queryResult?.let {
    val parts = it.split(",")
    val userMap = parts.associate { part ->
        val (key, value) = part.split("=")
        key to value
    }
    userMap
} ?: emptyMap()

println("Query result: '$queryResult'")
println("Parsed user: $user")

// Scenario 3: API response processing
val apiResponse: String? = """{"status": "success", "data": {"name": "Bob", "age": 30}}"""
val userName = apiResponse?.let {
    // In a real app, you'd use a JSON parser
    if (it.contains("\"name\"")) {
        val nameStart = it.indexOf("\"name\": \"") + 9
        val nameEnd = it.indexOf("\"", nameStart)
        it.substring(nameStart, nameEnd)
    } else {
        null
    }
} ?: "Unknown User"

println("API response: '$apiResponse'")
println("Extracted name: $userName")

Type Casting

Type casting is the process of converting a value from one type to another. Kotlin provides two operators for type casting: as and as?.

as is the unsafe cast operator, which throws an exception if the cast fails. as? is the safe cast operator, which returns null if the cast fails.

When to Use

• When working with heterogeneous collections
• When dealing with inheritance hierarchies
• When interacting with less type-safe Java code

Practical Examples

// ===========================================
// TYPE CASTING EXAMPLES
// ===========================================

// Example 1: Type checking with 'is' operator
// This is the safest way to check types
println("=== TYPE CHECKING WITH 'IS' ===")
val value: Any = "Hello World"

if (value is String) {
    // Smart cast: value is treated as String inside this block
    println("Value is a String: '$value'")
    println("Length: ${value.length}")
    println("Uppercase: ${value.uppercase()}")
    
    // You can also use string-specific methods
    val words = value.split(" ")
    println("Number of words: ${words.size}")
} else {
    println("Value is not a String")
}

// Example 2: Type checking with different types
// You can check for multiple types
println("\n=== CHECKING MULTIPLE TYPES ===")
val mixedList: List<Any> = listOf("Hello", 42, 3.14, true, 'A')

for (item in mixedList) {
    when (item) {
        is String -> {
            println("String: '$item' (length: ${item.length})")
        }
        is Int -> {
            println("Integer: $item (doubled: ${item * 2})")
        }
        is Double -> {
            println("Double: $item (rounded: ${item.toInt()})")
        }
        is Boolean -> {
            println("Boolean: $item (opposite: ${!item})")
        }
        is Char -> {
            println("Character: '$item' (code: ${item.code})")
        }
        else -> {
            println("Unknown type: ${item::class.simpleName}")
        }
    }
}

// Example 3: Unsafe cast with 'as' operator
// This throws an exception if the cast fails
println("\n=== UNSAFE CAST WITH 'AS' ===")

val obj: Any = "I'm a string"
try {
    val str: String = obj as String  // Works because obj is actually a String
    println("Successfully cast to String: '$str'")
    
    // This would throw ClassCastException
    val willCrash: Int = obj as Int
    println("This will never print: $willCrash")
} catch (e: ClassCastException) {
    println("Cast failed: ${e.message}")
}

// Example 4: Safe cast with 'as?' operator
// This returns null if the cast fails instead of throwing an exception
println("\n=== SAFE CAST WITH 'AS?' ===")

val anyValue: Any = 123
val safeString: String? = anyValue as? String  // Will be null since anyValue is not a String
val safeInt: Int? = anyValue as? Int           // Will be 123

println("Safe cast to String: $safeString")
println("Safe cast to Int: $safeInt")

// Example 5: Combining safe cast with Elvis operator
// This provides a default value when the cast fails
println("\n=== SAFE CAST WITH ELVIS OPERATOR ===")

val mixedData: List<Any> = listOf("Hello", 42, 3.14, "World", 100)

for (item in mixedData) {
    val stringValue = (item as? String) ?: "Not a string"
    val intValue = (item as? Int) ?: 0
    val doubleValue = (item as? Double) ?: 0.0
    
    println("Item: $item")
    println("  As String: '$stringValue'")
    println("  As Int: $intValue")
    println("  As Double: $doubleValue")
    println()
}

// Example 6: Type casting in inheritance scenarios
// This is common when working with class hierarchies
println("\n=== TYPE CASTING WITH INHERITANCE ===")

// Simulate a class hierarchy
open class Animal(val name: String)
class Dog(name: String, val breed: String) : Animal(name)
class Cat(name: String, val color: String) : Animal(name)

val animals: List<Animal> = listOf(
    Dog("Buddy", "Golden Retriever"),
    Cat("Whiskers", "Orange"),
    Dog("Max", "Labrador"),
    Cat("Shadow", "Black")
)

for (animal in animals) {
    when (animal) {
        is Dog -> {
            println("Dog: ${animal.name} (Breed: ${animal.breed})")
            // You can access Dog-specific properties
        }
        is Cat -> {
            println("Cat: ${animal.name} (Color: ${animal.color})")
            // You can access Cat-specific properties
        }
        else -> {
            println("Unknown animal: ${animal.name}")
        }
    }
}

// Example 7: Real-world type casting scenarios
println("\n=== REAL-WORLD TYPE CASTING SCENARIOS ===")

// Scenario 1: Processing API responses
val apiResponse: Any = mapOf(
    "status" to "success",
    "data" to mapOf(
        "users" to listOf(
            mapOf("id" to 1, "name" to "Alice"),
            mapOf("id" to 2, "name" to "Bob")
        )
    )
)

// Safely extract user data
val users = (apiResponse as? Map<*, *>)?.let { response ->
    (response["data"] as? Map<*, *>)?.let { data ->
        (data["users"] as? List<*>)?.let { userList ->
            userList.mapNotNull { user ->
                (user as? Map<*, *>)?.let { userMap ->
                    val id = userMap["id"] as? Int
                    val name = userMap["name"] as? String
                    if (id != null && name != null) {
                        "User $id: $name"
                    } else null
                }
            }
        }
    }
} ?: emptyList()

println("API Response: $apiResponse")
println("Extracted users: $users")

// Scenario 2: Database result processing
val dbResult: Any = listOf(
    mapOf("id" to 1, "name" to "Product A", "price" to 29.99),
    mapOf("id" to 2, "name" to "Product B", "price" to 49.99),
    mapOf("id" to 3, "name" to "Product C", "price" to 19.99)
)

val products = (dbResult as? List<*>)?.mapNotNull { row ->
    (row as? Map<*, *>)?.let { product ->
        val id = product["id"] as? Int
        val name = product["name"] as? String
        val price = product["price"] as? Double
        
        if (id != null && name != null && price != null) {
            "ID: $id, Name: $name, Price: $${String.format("%.2f", price)}"
        } else null
    }
} ?: emptyList()

println("Database Result: $dbResult")
println("Processed products: $products")

String Formatting

When to Use

• When precise control over number formatting is needed
• When working with tabular data presentation
• When creating complex string patterns

Practical Examples

// ===========================================
// STRING FORMATTING EXAMPLES
// ===========================================

// Example 1: Simple string templates (Kotlin's preferred way)
// This is the most readable and flexible approach
println("=== SIMPLE STRING TEMPLATES ===")
val name = "John"
val age = 25
val simple = "Hello, $name! You are $age years old."
println(simple)

// Example 2: Using expressions in templates
// You can put any valid Kotlin expression inside ${}
println("\n=== EXPRESSIONS IN STRING TEMPLATES ===")
val score = 85
val message = "${name.uppercase()} scored $score points, which is ${if (score >= 80) "excellent" else "good"}!"
println(message)

// Example 3: Complex expressions in templates
// You can perform calculations and method calls
println("\n=== COMPLEX EXPRESSIONS IN TEMPLATES ===")
val price = 29.99
val quantity = 3
val total = price * quantity
val discount = if (quantity >= 5) 0.10 else 0.0
val finalTotal = total * (1 - discount)

val receipt = """
Receipt for $name:
  Item price: $${String.format("%.2f", price)}
  Quantity: $quantity
  Subtotal: $${String.format("%.2f", total)}
  Discount: ${(discount * 100).toInt()}%
  Final total: $${String.format("%.2f", finalTotal)}
""".trimIndent()

println(receipt)

// Example 4: String.format for precise formatting
// Use this when you need specific formatting control
println("\n=== STRING.FORMAT EXAMPLES ===")
val productName = "Laptop"
val productPrice = 999.99
val productQuantity = 2

val formatted = String.format("Product: %s, Price: $%.2f, Quantity: %d", 
                             productName, productPrice, productQuantity)
println(formatted)

// Example 5: Multiple values in one format string
// This is useful for creating structured output
println("\n=== MULTIPLE VALUES IN FORMAT STRING ===")
val customerName = "Alice Smith"
val orderNumber = "ORD-2024-001"
val orderDate = "2024-01-15"
val orderTotal = 149.99

val orderSummary = String.format("""
Order Summary:
  Customer: %s
  Order #: %s
  Date: %s
  Total: $%.2f
""".trimIndent(), customerName, orderNumber, orderDate, orderTotal)

println(orderSummary)

// Example 6: Number formatting with different precision
// Control decimal places and number formatting
println("\n=== NUMBER FORMATTING ===")
val pi = 3.14159265359
val largeNumber = 1234567.89
val percentage = 0.1234

println("Pi to 2 decimal places: ${String.format("%.2f", pi)}")
println("Pi to 4 decimal places: ${String.format("%.4f", pi)}")
println("Large number with commas: ${String.format("%,.2f", largeNumber)}")
println("Percentage: ${String.format("%.2f%%", percentage * 100)}")

// Example 7: Alignment and spacing
// Control how text is positioned
println("\n=== TEXT ALIGNMENT AND SPACING ===")
val items = listOf("Apple", "Banana", "Cherry", "Date")
val prices = listOf(1.99, 0.99, 3.99, 2.49)

println("Product List:")
for (i in items.indices) {
    val formattedLine = String.format("%-10s $%6.2f", items[i], prices[i])
    println(formattedLine)
}

// Example 8: Real-world formatting scenarios
println("\n=== REAL-WORLD FORMATTING SCENARIOS ===")

// Scenario 1: Financial report
val companyName = "TechCorp Inc."
val revenue = 1250000.50
val expenses = 875000.25
val profit = revenue - expenses
val profitMargin = (profit / revenue) * 100

val financialReport = String.format("""
FINANCIAL REPORT - %s
==========================================
Revenue:     $%,.2f
Expenses:    $%,.2f
Profit:      $%,.2f
Margin:      %.2f%%
""".trimIndent(), companyName, revenue, expenses, profit, profitMargin)

println(financialReport)

// Scenario 2: User profile display
val userName = "john_doe"
val userEmail = "john.doe@example.com"
val userAge = 28
val userScore = 95.5
val isActive = true

val userProfile = """
USER PROFILE
============
Username:    $userName
Email:       $userEmail
Age:         $userAge
Score:       ${String.format("%.1f", userScore)}%
Status:      ${if (isActive) "Active" else "Inactive"}
""".trimIndent()

println(userProfile)

// Scenario 3: Table formatting
val students = listOf(
    Triple("Alice", 95, "A"),
    Triple("Bob", 87, "B"),
    Triple("Charlie", 92, "A"),
    Triple("Diana", 78, "C")
)

println("STUDENT GRADES")
println("==============")
println(String.format("%-10s %-8s %-6s", "Name", "Score", "Grade"))
println("---------- -------- ------")

for ((name, score, grade) in students) {
    val formattedRow = String.format("%-10s %-8d %-6s", name, score, grade)
    println(formattedRow)
}

Arithmetic Operators

When to Use

• When you need to perform mathematical calculations
• When working with numbers in your program
• When calculating totals, averages, or other numeric results

Practical Examples

// ===========================================
// BASIC ARITHMETIC OPERATIONS
// ===========================================

// Example 1: Simple calculations
// These demonstrate the basic arithmetic operators
val a = 15
val b = 4

println("=== BASIC ARITHMETIC ===")
println("a = $a, b = $b")
println("Addition: $a + $b = ${a + b}")
println("Subtraction: $a - $b = ${a - b}")
println("Multiplication: $a * $b = ${a * b}")
println("Division: $a / $b = ${a / b}")
println("Modulo: $a % $b = ${a % b}")

// Example 2: Real-world calculations
// This shows practical applications of arithmetic
println("\n=== REAL-WORLD CALCULATIONS ===")

// Shopping cart calculations
val itemPrice = 29.99
val quantity = 3
val taxRate = 0.08  // 8% tax
val discount = 0.10  // 10% discount

val subtotal = itemPrice * quantity
val discountAmount = subtotal * discount
val discountedSubtotal = subtotal - discountAmount
val taxAmount = discountedSubtotal * taxRate
val finalTotal = discountedSubtotal + taxAmount

println("Shopping Cart Calculation:")
println("  Item price: $${String.format("%.2f", itemPrice)}")
println("  Quantity: $quantity")
println("  Subtotal: $${String.format("%.2f", subtotal)}")
println("  Discount (10%): $${String.format("%.2f", discountAmount)}")
println("  After discount: $${String.format("%.2f", discountedSubtotal)}")
println("  Tax (8%): $${String.format("%.2f", taxAmount)}")
println("  Final total: $${String.format("%.2f", finalTotal)}")

// Example 3: Mathematical formulas
// This demonstrates using arithmetic in formulas
println("\n=== MATHEMATICAL FORMULAS ===")

// Circle calculations
val radius = 5.0
val pi = 3.14159

val circumference = 2 * pi * radius
val area = pi * radius * radius

println("Circle with radius $radius:")
println("  Circumference: ${String.format("%.2f", circumference)}")
println("  Area: ${String.format("%.2f", area)}")

// Temperature conversion
val celsius = 25.0
val fahrenheit = (celsius * 9/5) + 32

println("Temperature conversion:")
println("  Celsius: $celsius°C")
println("  Fahrenheit: ${String.format("%.1f", fahrenheit)}°F")

// Example 4: Working with different data types
// This shows how arithmetic works with different types
println("\n=== DATA TYPE ARITHMETIC ===")

val intValue = 10
val doubleValue = 3.5
val longValue = 100L

// Int arithmetic
println("Int arithmetic:")
println("  $intValue + 5 = ${intValue + 5}")
println("  $intValue * 2 = ${intValue * 2}")

// Double arithmetic
println("Double arithmetic:")
println("  $doubleValue + 2.5 = ${doubleValue + 2.5}")
println("  $doubleValue * 3 = ${doubleValue * 3}")

// Mixed type arithmetic
println("Mixed type arithmetic:")
println("  $intValue + $doubleValue = ${intValue + doubleValue}")
println("  $intValue * $longValue = ${intValue * longValue}")

// Example 5: Modulo operations
// This demonstrates the modulo operator for remainders
println("\n=== MODULO OPERATIONS ===")

val numbers = listOf(7, 15, 23, 30, 42)
val divisor = 5

for (number in numbers) {
    val remainder = number % divisor
    val quotient = number / divisor
    println("$number ÷ $divisor = $quotient remainder $remainder")
}

// Check if numbers are even or odd
println("\nEven/Odd check:")
for (number in numbers) {
    val isEven = number % 2 == 0
    println("$number is ${if (isEven) "even" else "odd"}")
}

Comparison Operators

When to Use

• When you need to compare values
• When making decisions in your code
• When checking if conditions are true or false

Practical Examples

// ===========================================
// COMPARISON OPERATOR EXAMPLES
// ===========================================

// Example 1: Basic comparisons
// These demonstrate the fundamental comparison operators
println("=== BASIC COMPARISONS ===")

val x = 10
val y = 5
val z = 10

println("x = $x, y = $y, z = $z")
println("x == y: ${x == y}")      // Equal to
println("x != y: ${x != y}")      // Not equal to
println("x > y: ${x > y}")        // Greater than
println("x < y: ${x < y}")        // Less than
println("x >= z: ${x >= z}")      // Greater than or equal to
println("x <= z: ${x <= z}")      // Less than or equal to

// Example 2: String comparisons
// This shows how comparison works with text
println("\n=== STRING COMPARISONS ===")

val name1 = "Alice"
val name2 = "Bob"
val name3 = "Alice"

println("name1 = '$name1', name2 = '$name2', name3 = '$name3'")
println("name1 == name2: ${name1 == name2}")
println("name1 == name3: ${name1 == name3}")
println("name1 != name2: ${name1 != name2}")

// String ordering (alphabetical)
println("name1 < name2: ${name1 < name2}")  // 'Alice' comes before 'Bob'
println("name2 > name1: ${name2 > name1}")  // 'Bob' comes after 'Alice'

// Example 3: Real-world comparison scenarios
// This demonstrates practical uses of comparisons
println("\n=== REAL-WORLD COMPARISONS ===")

// Age verification system
val userAge = 17
val minimumAge = 18
val seniorAge = 65

val canVote = userAge >= minimumAge
val isMinor = userAge < minimumAge
val isSenior = userAge >= seniorAge

println("Age verification for user age $userAge:")
println("  Can vote: $canVote")
println("  Is minor: $isMinor")
println("  Is senior: $isSenior")

// Grade calculation
val score = 85
val passingScore = 60
val excellentScore = 90

val isPassing = score >= passingScore
val isExcellent = score >= excellentScore
val needsImprovement = score < passingScore

println("\nGrade analysis for score $score:")
println("  Is passing: $isPassing")
println("  Is excellent: $isExcellent")
println("  Needs improvement: $needsImprovement")

// Example 4: Range checking
// This shows how to check if values fall within ranges
println("\n=== RANGE CHECKING ===")

val temperature = 72
val lowTemp = 65
val highTemp = 78

val isComfortable = temperature >= lowTemp && temperature <= highTemp
val isTooCold = temperature < lowTemp
val isTooHot = temperature > highTemp

println("Temperature analysis for $temperature°F:")
println("  Is comfortable: $isComfortable")
println("  Is too cold: $isTooCold")
println("  Is too hot: $isTooHot")

// Example 5: Multiple comparisons
// This demonstrates combining multiple comparison operations
println("\n=== MULTIPLE COMPARISONS ===")

val testScores = listOf(95, 87, 72, 100, 58, 89)

for (score in testScores) {
    val grade = when {
        score >= 90 -> "A"
        score >= 80 -> "B"
        score >= 70 -> "C"
        score >= 60 -> "D"
        else -> "F"
    }
    
    val status = when {
        score == 100 -> "Perfect!"
        score >= 90 -> "Excellent"
        score >= 80 -> "Good"
        score >= 70 -> "Satisfactory"
        score >= 60 -> "Needs improvement"
        else -> "Failed"
    }
    
    println("Score $score: Grade $grade - $status")
}

Logical Operators

When to Use

• When you need to combine multiple conditions
• When creating complex decision logic
• When you need to check if multiple things are true or false

Understanding Short-Circuit Evaluation

Short-circuit evaluation is an important optimization feature of logical operators that can improve performance and prevent errors:

• With && (AND): If the first condition is false, Kotlin doesn't evaluate the remaining conditions because the result will always be false. This is useful when checking if something exists before using it (e.g., list != null && list.size > 0).
• With || (OR): If the first condition is true, Kotlin doesn't evaluate the remaining conditions because the result will always be true. This can save time when checking multiple conditions.

Example: In the expression user != null && user.isActive, if user is null, Kotlin won't try to access user.isActive, preventing a null pointer error.

Practical Examples

// ===========================================
// LOGICAL OPERATOR EXAMPLES
// ===========================================

// Example 1: Basic logical operations
// These demonstrate the fundamental logical operators
println("=== BASIC LOGICAL OPERATIONS ===")

val isSunny = true
val isWarm = true
val isRaining = false

println("Weather conditions:")
println("  Is sunny: $isSunny")
println("  Is warm: $isWarm")
println("  Is raining: $isRaining")

// Logical AND - both conditions must be true
val isGoodWeather = isSunny && isWarm
println("  Is good weather (sunny AND warm): $isGoodWeather")

// Logical OR - either condition can be true
val isOutdoorWeather = isSunny || isWarm
println("  Is outdoor weather (sunny OR warm): $isOutdoorWeather")

// Logical NOT - inverts the value
val isNotRaining = !isRaining
println("  Is not raining: $isNotRaining")

// Example 2: Complex logical expressions
// This shows how to combine multiple logical operations
println("\n=== COMPLEX LOGICAL EXPRESSIONS ===")

// User authentication system
val hasValidUsername = true
val hasValidPassword = true
val isAccountActive = false
val isNotLocked = true

// User can login if they have valid credentials AND account is active AND not locked
val canLogin = hasValidUsername && hasValidPassword && isAccountActive && isNotLocked

// User can reset password if they have valid username OR if account is locked
val canResetPassword = hasValidUsername || !isNotLocked

println("Authentication status:")
println("  Has valid username: $hasValidUsername")
println("  Has valid password: $hasValidPassword")
println("  Is account active: $isAccountActive")
println("  Is not locked: $isNotLocked")
println("  Can login: $canLogin")
println("  Can reset password: $canResetPassword")

// Example 3: Real-world logical scenarios
// This demonstrates practical applications of logical operators
println("\n=== REAL-WORLD LOGICAL SCENARIOS ===")

// Shopping cart validation
val hasItems = true
val hasValidPayment = true
val isWithinBudget = false
val hasShippingAddress = true

// Order can be placed if all conditions are met
val canPlaceOrder = hasItems && hasValidPayment && isWithinBudget && hasShippingAddress

// Order can be saved for later if it has items but doesn't meet other criteria
val canSaveForLater = hasItems && (!hasValidPayment || !isWithinBudget || !hasShippingAddress)

println("Shopping cart status:")
println("  Has items: $hasItems")
println("  Has valid payment: $hasValidPayment")
println("  Is within budget: $isWithinBudget")
println("  Has shipping address: $hasShippingAddress")
println("  Can place order: $canPlaceOrder")
println("  Can save for later: $canSaveForLater")

// Example 4: De Morgan's Law demonstration
// This shows how logical expressions can be rewritten
println("\n=== DE MORGAN'S LAW DEMONSTRATION ===")

val a = true
val b = false

// Original expression: !(a && b)
val original = !(a && b)

// Using De Morgan's Law: !a || !b
val demorgan = !a || !b

println("De Morgan's Law demonstration:")
println("  a = $a, b = $b")
println("  Original: !(a && b) = $original")
println("  De Morgan: !a || !b = $demorgan")
println("  Are they equal? ${original == demorgan}")

// Example 5: Short-circuit evaluation
// This demonstrates how logical operators can short-circuit
println("\n=== SHORT-CIRCUIT EVALUATION ===")

fun checkFirst(): Boolean {
    println("  Checking first condition...")
    return false
}

fun checkSecond(): Boolean {
    println("  Checking second condition...")
    return true
}

fun checkThird(): Boolean {
    println("  Checking third condition...")
    return true
}

println("Short-circuit with AND (&&):")
val result1 = checkFirst() && checkSecond() && checkThird()
println("  Final result: $result1")

println("\nShort-circuit with OR (||):")
val result2 = checkFirst() || checkSecond() || checkThird()
println("  Final result: $result2")

Assignment Operators

When to Use

• When you need to update variable values
• When performing calculations and storing results
• When incrementing or decrementing values

Practical Examples

// ===========================================
// ASSIGNMENT OPERATOR EXAMPLES
// ===========================================

// Example 1: Basic assignment operators
// These demonstrate the fundamental assignment operations
println("=== BASIC ASSIGNMENT OPERATORS ===")

var number = 10
println("Initial value: $number")

// Simple assignment
number = 15
println("After simple assignment: $number")

// Add and assign
number += 5
println("After += 5: $number")

// Subtract and assign
number -= 3
println("After -= 3: $number")

// Multiply and assign
number *= 2
println("After *= 2: $number")

// Divide and assign
number /= 4
println("After /= 4: $number")

// Modulo and assign
number %= 3
println("After %= 3: $number")

// Example 2: Counter and accumulator patterns
// This shows common programming patterns using assignment operators
println("\n=== COUNTER AND ACCUMULATOR PATTERNS ===")

// Counter pattern
var counter = 0
println("Counter pattern:")
for (i in 1..5) {
    counter += 1
    println("  Iteration $i: counter = $counter")
}

// Accumulator pattern
var total = 0
val numbers = listOf(10, 20, 30, 40, 50)
println("\nAccumulator pattern:")
for (number in numbers) {
    total += number
    println("  Added $number, total = $total")
}

// Running average
var sum = 0.0
var count = 0
val scores = listOf(85, 92, 78, 96, 88)

println("\nRunning average calculation:")
for (score in scores) {
    sum += score
    count += 1
    val average = sum / count
    println("  Score: $score, Running average: ${String.format("%.1f", average)}")
}

// Example 3: Real-world assignment scenarios
// This demonstrates practical uses of assignment operators
println("\n=== REAL-WORLD ASSIGNMENT SCENARIOS ===")

// Bank account balance management
var balance = 1000.0
val transactions = listOf(150.0, -75.0, 200.0, -50.0, 300.0)

println("Bank account transactions:")
println("  Initial balance: $${String.format("%.2f", balance)}")

for (transaction in transactions) {
    if (transaction > 0) {
        balance += transaction
        println("  Deposited $${String.format("%.2f", transaction)}, new balance: $${String.format("%.2f", balance)}")
    } else {
        balance += transaction  // transaction is negative, so this subtracts
        println("  Withdrew $${String.format("%.2f", -transaction)}, new balance: $${String.format("%.2f", balance)}")
    }
}

// Example 4: Increment and decrement operations
// This shows how to increase or decrease values
println("\n=== INCREMENT AND DECREMENT ===")

var count = 0
println("Increment operations:")
count += 1
println("  count += 1: $count")
count += 1
println("  count += 1: $count")

var temperature = 72
println("\nTemperature adjustments:")
temperature += 5
println("  Temperature increased by 5: $temperature")
temperature -= 3
println("  Temperature decreased by 3: $temperature")

// Example 5: Compound assignment with different types
// This demonstrates assignment operators with various data types
println("\n=== COMPOUND ASSIGNMENT WITH DIFFERENT TYPES ===")

// String concatenation
var message = "Hello"
message += " World"
message += "!"
println("String concatenation: $message")

// List operations
var numbers = mutableListOf(1, 2, 3)
numbers += 4
numbers += 5
println("List addition: $numbers")

// Boolean operations
var isActive = true
isActive = isActive && false
println("Boolean assignment: $isActive")

Loops

When to Use Different Loops

• Use for loops when you know the number of iterations
• Use while loops when you don't know how many iterations you'll need
• Use do-while loops when you need to execute code at least once

Practical Examples

// ===========================================
// FOR LOOP EXAMPLES
// ===========================================

// Example 1: Iterating over a list of fruits
// This is useful when you have a collection of items to process
val fruits = listOf("apple", "banana", "cherry", "orange", "grape")
println("=== PROCESSING FRUIT LIST ===")
for (fruit in fruits) {
    // Each iteration, 'fruit' contains the next item from the list
    println("I like $fruit")
    // You can perform any operation on each item
    println("  - $fruit has ${fruit.length} letters")
}
// Output:
// I like apple
//   - apple has 5 letters
// I like banana
//   - banana has 6 letters
// ... and so on

// Example 2: Counting with ranges
// The '..' operator creates a range from 1 to 5 (inclusive)
println("\n=== COUNTING WITH RANGES ===")
for (i in 1..5) {
    // 'i' takes the values: 1, 2, 3, 4, 5
    println("Count: $i")
    
    // You can use the counter variable in calculations
    val square = i * i
    println("  $i squared is $square")
}

// Example 3: Processing with index
// Sometimes you need both the item and its position
println("\n=== PROCESSING WITH INDEX ===")
val colors = listOf("red", "green", "blue", "yellow")
for ((index, color) in colors.withIndex()) {
    // 'index' is the position (0, 1, 2, 3)
    // 'color' is the actual color value
    println("Color #${index + 1}: $color")
}

// Example 4: Counting backwards
// Use 'downTo' to count in reverse order
println("\n=== COUNTDOWN EXAMPLE ===")
for (countdown in 5 downTo 1) {
    println("T-minus $countdown seconds")
}
println("Blast off!")

// ===========================================
// WHILE LOOP EXAMPLES
// ===========================================

// Example 1: Input validation loop
// This loop continues until the user provides valid input
println("\n=== INPUT VALIDATION LOOP ===")
var age = -1  // Start with invalid value
var attempts = 0  // Track how many times user tries

while (age < 0 || age > 120) {
    attempts++
    print("Enter your age (0-120): ")
    
    // Simulate user input (in real app, this would be readLine())
    val userInput = when (attempts) {
        1 -> "150"      // First attempt: invalid (too high)
        2 -> "-5"       // Second attempt: invalid (negative)
        3 -> "abc"      // Third attempt: invalid (not a number)
        else -> "25"    // Fourth attempt: valid
    }
    
    // Try to convert input to integer
    age = userInput.toIntOrNull() ?: -1
    
    if (age < 0 || age > 120) {
        println("Invalid age: $userInput. Please try again.")
    }
}

println("Valid age entered: $age (after $attempts attempts)")

// Example 2: Game loop simulation
// This simulates a simple game that continues until certain conditions
println("\n=== GAME LOOP SIMULATION ===")
var playerHealth = 100
var enemyHealth = 80
var round = 1

while (playerHealth > 0 && enemyHealth > 0) {
    println("=== ROUND $round ===")
    println("Player Health: $playerHealth, Enemy Health: $enemyHealth")
    
    // Simulate combat
    val playerDamage = (10..20).random()  // Random damage between 10-20
    val enemyDamage = (8..18).random()    // Random damage between 8-18
    
    enemyHealth -= playerDamage
    playerHealth -= enemyDamage
    
    println("Player deals $playerDamage damage to enemy")
    println("Enemy deals $enemyDamage damage to player")
    
    round++
    
    // Add a small delay to make the output readable
    Thread.sleep(500)
}

// Determine winner
if (playerHealth > 0) {
    println("Player wins! Final health: $playerHealth")
} else {
    println("Enemy wins! Player defeated.")
}

// ===========================================
// DO-WHILE LOOP EXAMPLES
// ===========================================

// Example 1: Menu system
// This loop always shows the menu at least once
println("\n=== MENU SYSTEM EXAMPLE ===")
var choice: Int
var menuShown = 0

do {
    menuShown++
    println("\n--- MENU (shown $menuShown times) ---")
    println("1. Play Game")
    println("2. Settings")
    println("3. View High Scores")
    println("4. Exit")
    
    // Simulate user input
    choice = when (menuShown) {
        1 -> 5  // First time: invalid choice
        2 -> 2  // Second time: valid choice (Settings)
        else -> 4  // Third time: valid choice (Exit)
    }
    
    if (choice !in 1..4) {
        println("Invalid choice: $choice. Please select 1-4.")
    } else if (choice == 2) {
        println("Opening Settings...")
        // In a real app, this would open settings
    }
    
} while (choice !in 1..4)  // Continue until valid choice

println("Menu loop completed. Final choice: $choice")

// Example 2: Password validation
// This ensures the user gets at least one chance to enter a password
println("\n=== PASSWORD VALIDATION ===")
var password = ""
var attempts = 0

do {
    attempts++
    print("Enter password (attempt $attempts): ")
    
    // Simulate password input
    password = when (attempts) {
        1 -> ""           // First attempt: empty password
        2 -> "123"        // Second attempt: too short
        3 -> "password"   // Third attempt: too weak
        else -> "SecurePass123!"  // Fourth attempt: valid
    }
    
    // Check password requirements
    val isValid = password.length >= 8 && 
                  password.any { it.isUpperCase() } &&
                  password.any { it.isDigit() }
    
    if (!isValid) {
        println("Password too weak. Must be at least 8 characters with uppercase and number.")
    }
    
} while (!isValid && attempts < 5)

if (isValid) {
    println("Password accepted after $attempts attempts!")
} else {
    println("Too many failed attempts. Account locked.")
}

Loop Control Statements

When to Use

• Use break when you need to exit a loop early
• Use continue when you need to skip the current iteration
• Use labels when working with nested loops

Practical Examples

// ===========================================
// BREAK STATEMENT EXAMPLES
// ===========================================

// Example 1: Finding a specific number in a list
// This demonstrates how to exit a loop once you find what you need
println("=== FINDING A NUMBER WITH BREAK ===")
val numbers = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
val targetNumber = 7
var found = false
var searchCount = 0

for (num in numbers) {
    searchCount++
    println("Checking number: $num")
    
    if (num == targetNumber) {
        found = true
        println("Found $targetNumber at position ${searchCount - 1}!")
        break  // Exit the loop immediately - no need to check remaining numbers
    }
}

if (found) {
    println("Search completed in $searchCount steps")
} else {
    println("Number $targetNumber not found")
}

// Example 2: Processing until a condition is met
// This shows how to stop processing when certain criteria are met
println("\n=== PROCESSING UNTIL CONDITION MET ===")
val temperatures = listOf(72, 75, 68, 80, 85, 90, 95, 88, 82, 78)
var comfortableCount = 0

for (temp in temperatures) {
    if (temp > 85) {
        println("Temperature $temp°F is too hot! Stopping processing.")
        break  // Stop when we find an uncomfortable temperature
    }
    
    if (temp in 68..78) {
        comfortableCount++
        println("Temperature $temp°F is comfortable")
    } else {
        println("Temperature $temp°F is acceptable")
    }
}

println("Found $comfortableCount comfortable temperatures before stopping")

// ===========================================
// CONTINUE STATEMENT EXAMPLES
// ===========================================

// Example 1: Skipping even numbers
// This demonstrates how to skip certain iterations
println("\n=== SKIPPING EVEN NUMBERS ===")
for (i in 1..10) {
    if (i % 2 == 0) {
        continue  // Skip to next iteration when number is even
    }
    // This code only runs for odd numbers
    println("Processing odd number: $i")
    val square = i * i
    println("  $i squared is $square")
}

// Example 2: Processing only valid data
// This shows how to skip invalid or unwanted data
println("\n=== PROCESSING VALID DATA ONLY ===")
val userInputs = listOf("123", "abc", "456", "", "789", "def", "0")
var validNumbers = 0
var total = 0

for (input in userInputs) {
    // Skip empty strings
    if (input.isEmpty()) {
        println("Skipping empty input")
        continue
    }
    
    // Skip non-numeric inputs
    val number = input.toIntOrNull()
    if (number == null) {
        println("Skipping non-numeric input: '$input'")
        continue
    }
    
    // Skip zero values
    if (number == 0) {
        println("Skipping zero value")
        continue
    }
    
    // Process valid numbers
    validNumbers++
    total += number
    println("Processing valid number: $number (running total: $total)")
}

println("Processed $validNumbers valid numbers with total: $total")

// ===========================================
// LABELED LOOPS EXAMPLES
// ===========================================

// Example 1: Breaking out of nested loops
// This shows how to exit multiple loop levels at once
println("\n=== BREAKING OUT OF NESTED LOOPS ===")
outerLoop@ for (i in 1..3) {
    println("Outer loop iteration: $i")
    
    for (j in 1..3) {
        println("  Inner loop: i=$i, j=$j")
        
        // Break out of both loops when specific condition is met
        if (i == 2 && j == 2) {
            println("  Breaking out of both loops!")
            break@outerLoop  // Exit the outer loop (and inner loop)
        }
        
        // Simulate some work
        Thread.sleep(200)
    }
    
    // This line won't execute when break@outerLoop is used
    println("Completed outer loop iteration $i")
}

println("Both loops completed")

// Example 2: Continuing outer loop from inner loop
// This demonstrates how to skip to the next iteration of an outer loop
println("\n=== CONTINUING OUTER LOOP FROM INNER LOOP ===")
mainLoop@ for (row in 1..4) {
    println("Processing row $row")
    
    for (col in 1..3) {
        println("  Processing column $col")
        
        // Skip to next row if we encounter a problem
        if (row == 2 && col == 2) {
            println("  Problem encountered! Moving to next row.")
            continue@mainLoop  // Skip to next iteration of mainLoop
        }
        
        // Simulate processing
        println("  Successfully processed position ($row, $col)")
    }
    
    // This line won't execute when continue@mainLoop is used
    println("Completed processing row $row")
}

println("All rows processed")

Conditional Statements

When to Use

• Use if for simple yes/no decisions
• Use if-else when you need two alternatives
• Use if-else-if for multiple conditions
• Use when for complex decision trees

Practical Examples

// ===========================================
// IF STATEMENT EXAMPLES
// ===========================================

// Example 1: Simple age check
// This demonstrates basic if statement usage
println("=== SIMPLE AGE CHECK ===")
val age = 20

if (age >= 18) {
    // This block only executes when age is 18 or greater
    println("You are an adult!")
    println("You can vote!")
    println("You can drive!")
}

// Example 2: Temperature-based clothing advice
// This shows how to use if statements for practical decisions
println("\n=== TEMPERATURE-BASED CLOTHING ADVICE ===")
val temperature = 75

if (temperature > 80) {
    println("It's hot outside!")
    println("Wear light clothing")
    println("Don't forget sunscreen!")
} else {
    // This block executes when temperature is 80 or less
    println("It's comfortable outside")
    println("Regular clothing should be fine")
}

// ===========================================
// IF-ELSE-IF EXAMPLES
// ===========================================

// Example 1: Grade calculation system
// This demonstrates handling multiple conditions in order
println("\n=== GRADE CALCULATION SYSTEM ===")
val score = 85

if (score >= 90) {
    println("Grade: A")
    println("Excellent work!")
} else if (score >= 80) {
    // This executes when score is 80-89
    println("Grade: B")
    println("Good job!")
} else if (score >= 70) {
    // This executes when score is 70-79
    println("Grade: C")
    println("Satisfactory")
} else if (score >= 60) {
    // This executes when score is 60-69
    println("Grade: D")
    println("Needs improvement")
} else {
    // This executes when score is below 60
    println("Grade: F")
    println("Failed")
}

// Example 2: Weather-based activity recommendations
// This shows practical decision-making with multiple conditions
println("\n=== WEATHER-BASED ACTIVITIES ===")
val weather = "rainy"
val temperature2 = 65

if (weather == "sunny" && temperature2 > 70) {
    println("Perfect weather for outdoor activities!")
    println("Go to the beach, have a picnic, or play sports")
} else if (weather == "sunny" && temperature2 <= 70) {
    println("Sunny but cool")
    println("Good for a walk or light outdoor activities")
} else if (weather == "rainy") {
    println("It's raining")
    if (temperature2 > 60) {
        println("Warm rain - good for indoor activities")
    } else {
        println("Cold rain - stay inside and stay warm")
    }
} else if (weather == "snowy") {
    println("It's snowing!")
    println("Great for winter sports or building snowmen")
} else {
    println("Weather is unclear")
    println("Check the forecast for better planning")
}

// ===========================================
// WHEN STATEMENT EXAMPLES
// ===========================================

// Example 1: Day of week decisions
// This demonstrates the when statement for multiple choices
println("\n=== DAY OF WEEK DECISIONS ===")
val day = "Monday"

when (day) {
    "Monday", "Tuesday", "Wednesday", "Thursday", "Friday" -> {
        // Multiple values can share the same action
        println("It's a weekday")
        println("Time to work or study")
        println("Set your alarm for tomorrow")
    }
    "Saturday", "Sunday" -> {
        println("It's the weekend!")
        println("Time to relax and have fun")
        println("Sleep in if you want")
    }
    else -> {
        // This handles any other values
        println("Invalid day: $day")
        println("Please enter a valid day of the week")
    }
}

// Example 2: Type-based processing
// This shows how when can handle different data types
println("\n=== TYPE-BASED PROCESSING ===")
val x: Any = "Hello World"

when (x) {
    // Check if value is in a specific range
    in 1..10 -> {
        println("Single digit number: $x")
        println("This is a small number")
    }
    in 11..99 -> {
        println("Double digit number: $x")
        println("This is a medium number")
    }
    // Check the type of the value
    is String -> {
        println("String value: '$x'")
        println("Length: ${x.length} characters")
        println("Uppercase: ${x.uppercase()}")
    }
    is Boolean -> {
        println("Boolean value: $x")
        if (x) {
            println("This is true")
        } else {
            println("This is false")
        }
    }
    // Handle null case
    null -> {
        println("Value is null")
        println("No processing possible")
    }
    // Default case for any other types
    else -> {
        println("Unknown type: ${x::class.simpleName}")
        println("Value: $x")
    }
}

// Example 3: Complex when with expressions
// This demonstrates advanced when statement features
println("\n=== COMPLEX WHEN WITH EXPRESSIONS ===")
val userInput = "admin"
val userLevel = when {
    // Multiple conditions can be combined
    userInput == "admin" && userLevel > 100 -> "Super Admin"
    userInput == "admin" -> "Administrator"
    userInput == "moderator" -> "Moderator"
    userInput == "user" -> "Regular User"
    userInput.isEmpty() -> "Guest"
    userInput.length < 3 -> "Invalid Username"
    else -> "Unknown User"
}

println("User level determined: $userLevel")

// Example 4: When as an expression
// When can also return values directly
println("\n=== WHEN AS AN EXPRESSION ===")
val score2 = 87
val grade = when (score2) {
    in 90..100 -> "A"
    in 80..89 -> "B"
    in 70..79 -> "C"
    in 60..69 -> "D"
    else -> "F"
}

println("Score: $score2")
println("Grade: $grade")

// You can also use when to assign multiple variables
val (status, message) = when (score2) {
    in 90..100 -> "Pass" to "Excellent work!"
    in 80..89 -> "Pass" to "Good job!"
    in 70..79 -> "Pass" to "Satisfactory"
    in 60..69 -> "Pass" to "Barely passing"
    else -> "Fail" to "Needs improvement"
}

println("Status: $status")
println("Message: $message")

Basic Functions

When to Use

• When you need to perform a specific task multiple times
• When you want to organize your code into logical units
• When you need to reuse code in different parts of your program
• When you want to make your code more readable and maintainable

Practical Examples

// ===========================================
// BASIC FUNCTION EXAMPLES
// ===========================================

// Example 1: Function with no parameters
// This function performs a simple task without needing any input
fun greet() {
    println("Hello, World!")
    println("Welcome to Kotlin programming!")
}

// Example 2: Function with parameters
// This function accepts input and uses it in its logic
fun greetPerson(name: String) {
    // 'name' is a parameter - it holds the value passed when calling the function
    println("Hello, $name!")
    println("Nice to meet you!")
    
    // You can use the parameter multiple times
    if (name.length > 5) {
        println("That's a long name, $name!")
    }
}

// Example 3: Function with return value
// This function performs a calculation and returns the result
fun calculateTotal(price: Double, quantity: Int): Double {
    // Calculate the total cost
    val subtotal = price * quantity
    
    // Apply 10% tax
    val tax = subtotal * 0.10
    
    // Calculate final total
    val total = subtotal + tax
    
    // Return the calculated total
    return total
}

// Example 4: Function with multiple parameters and complex logic
// This function creates a user profile string with validation
fun createUser(name: String, age: Int, isActive: Boolean): String {
    // Validate the input parameters
    if (name.isEmpty()) {
        return "Error: Name cannot be empty"
    }
    
    if (age < 0 || age > 150) {
        return "Error: Age must be between 0 and 150"
    }
    
    // Create a status message based on age and active status
    val status = when {
        age < 18 -> "Minor"
        age < 65 -> "Adult"
        else -> "Senior"
    }
    
    val activeStatus = if (isActive) "Active" else "Inactive"
    
    // Build and return the user profile string
    return "User: $name, Age: $age, Status: $status, Account: $activeStatus"
}

// Example 5: Function that returns different types based on conditions
// This function demonstrates conditional returns
fun getMessage(score: Int): String {
    return when {
        score >= 90 -> "Excellent! You're doing great!"
        score >= 80 -> "Good job! Keep up the good work!"
        score >= 70 -> "Not bad, but there's room for improvement."
        score >= 60 -> "You're passing, but consider studying more."
        else -> "You need to work harder to pass this course."
    }
}

// ===========================================
// CALLING FUNCTIONS EXAMPLES
// ===========================================

println("=== CALLING BASIC FUNCTIONS ===")

// Call the greet function (no parameters needed)
greet()
// Output:
// Hello, World!
// Welcome to Kotlin programming!

// Call greetPerson with different names
greetPerson("Alice")
// Output:
// Hello, Alice!
// Nice to meet you!
// That's a long name, Alice!

greetPerson("Bob")
// Output:
// Hello, Bob!
// Nice to meet you!

// Call calculateTotal and store the result
val totalCost = calculateTotal(29.99, 3)
println("Total cost for 3 items at $29.99 each: $${String.format("%.2f", totalCost)}")
// Output: Total cost for 3 items at $29.99 each: $98.97

// Call createUser with different parameters
val user1 = createUser("John Doe", 25, true)
val user2 = createUser("Jane Smith", 17, false)
val user3 = createUser("", 30, true)  // Invalid name

println("User 1: $user1")
println("User 2: $user2")
println("User 3: $user3")

// Call getMessage with different scores
println("Score 95: ${getMessage(95)}")
println("Score 75: ${getMessage(75)}")
println("Score 45: ${getMessage(45)}")

Function Features

When to Use

• Use default parameters when some arguments are optional
• Use varargs when you need to accept any number of arguments
• Use single expression functions for simple calculations
• Use local functions for helper code that's only needed in one place

Practical Examples

// ===========================================
// DEFAULT PARAMETERS EXAMPLES
// ===========================================

// Example 1: Function with default parameters
// This makes the function more flexible by providing sensible defaults
fun greetUser(name: String = "Guest", greeting: String = "Hello") {
    println("$greeting, $name!")
    
    // You can use the parameters in conditional logic
    if (name == "Guest") {
        println("Welcome! Please consider creating an account.")
    } else {
        println("Welcome back, $name!")
    }
}

// Example 2: Function with multiple default parameters
// This function calculates shipping cost with optional parameters
fun calculateShipping(
    weight: Double,
    distance: Double = 100.0,  // Default distance of 100 miles
    isExpress: Boolean = false,  // Default to standard shipping
    insurance: Double = 0.0     // Default to no insurance
): Double {
    // Base shipping cost based on weight
    var baseCost = weight * 0.50
    
    // Add distance cost
    baseCost += distance * 0.10
    
    // Add express shipping premium
    if (isExpress) {
        baseCost *= 1.5
        println("Express shipping selected - 50% premium applied")
    }
    
    // Add insurance cost
    if (insurance > 0) {
        baseCost += insurance * 0.05
        println("Insurance added: $${String.format("%.2f", insurance * 0.05)}")
    }
    
    return baseCost
}

// ===========================================
// VARARGS EXAMPLES
// ===========================================

// Example 1: Function that accepts any number of strings
// The 'vararg' keyword allows flexible argument counts
fun printAll(vararg messages: String) {
    println("Received ${messages.size} messages:")
    
    // Process each message
    for ((index, message) in messages.withIndex()) {
        println("  ${index + 1}. $message")
    }
    
    // You can also perform operations on all messages
    val totalLength = messages.sumOf { it.length }
    println("Total characters in all messages: $totalLength")
}

// Example 2: Function that processes any number of numbers
// This function can handle different amounts of numeric data
fun analyzeNumbers(vararg numbers: Int): Map {
    if (numbers.isEmpty()) {
        return mapOf("error" to "No numbers provided")
    }
    
    val result = mutableMapOf()
    
    // Calculate various statistics
    result["count"] = numbers.size
    result["sum"] = numbers.sum()
    result["average"] = numbers.average()
    result["min"] = numbers.minOrNull() ?: 0
    result["max"] = numbers.maxOrNull() ?: 0
    
    // Find even and odd numbers
    val evens = numbers.filter { it % 2 == 0 }
    val odds = numbers.filter { it % 2 != 0 }
    
    result["evenCount"] = evens.size
    result["oddCount"] = odds.size
    
    return result
}

// ===========================================
// SINGLE EXPRESSION FUNCTIONS
// ===========================================

// Example 1: Simple mathematical functions
// These functions are so simple they can be written in one line
fun square(x: Int) = x * x
fun cube(x: Int) = x * x * x
fun isEven(x: Int) = x % 2 == 0
fun isPositive(x: Int) = x > 0

// Example 2: String utility functions
// Simple text processing functions
fun capitalizeFirst(str: String) = str.replaceFirstChar { it.uppercase() }
fun reverseString(str: String) = str.reversed()
fun countVowels(str: String) = str.count { it.lowercase() in "aeiou" }

// Example 3: Type conversion functions
// Simple conversion functions
fun toFahrenheit(celsius: Double) = celsius * 9/5 + 32
fun toCelsius(fahrenheit: Double) = (fahrenheit - 32) * 5/9
fun toMiles(kilometers: Double) = kilometers * 0.621371

// ===========================================
// LOCAL FUNCTIONS EXAMPLES
// ===========================================

// Example 1: Function with local helper function
// This function calculates total cost with tax and applies discounts
fun calculateTotalWithTax(price: Double, quantity: Int): Double {
    // Local function to calculate tax
    fun applyTax(amount: Double): Double {
        val taxRate = 0.08  // 8% tax rate
        return amount * taxRate
    }
    
    // Local function to apply quantity discount
    fun applyQuantityDiscount(amount: Double, qty: Int): Double {
        return when {
            qty >= 10 -> amount * 0.15  // 15% discount for 10+ items
            qty >= 5 -> amount * 0.10   // 10% discount for 5+ items
            else -> 0.0                  // No discount
        }
    }
    
    // Calculate subtotal
    val subtotal = price * quantity
    
    // Apply discount
    val discount = applyQuantityDiscount(subtotal, quantity)
    val discountedSubtotal = subtotal - discount
    
    // Apply tax
    val tax = applyTax(discountedSubtotal)
    
    // Return final total
    return discountedSubtotal + tax
}

// Example 2: Function with local validation functions
// This function processes user registration with multiple validation steps
fun registerUser(username: String, email: String, age: Int): String {
    // Local function to validate username
    fun isValidUsername(name: String): Boolean {
        return name.length >= 3 && 
               name.all { it.isLetterOrDigit() || it == '_' } &&
               name[0].isLetter()
    }
    
    // Local function to validate email format
    fun isValidEmail(email: String): Boolean {
        return email.contains("@") && 
               email.contains(".") && 
               email.indexOf("@") < email.lastIndexOf(".")
    }
    
    // Local function to validate age
    fun isValidAge(age: Int): Boolean {
        return age >= 13 && age <= 120
    }
    
    // Perform all validations
    if (!isValidUsername(username)) {
        return "Error: Invalid username. Must be 3+ characters, start with letter, only letters/numbers/underscore allowed."
    }
    
    if (!isValidEmail(email)) {
        return "Error: Invalid email format. Must contain @ and . in correct positions."
    }
    
    if (!isValidAge(age)) {
        return "Error: Invalid age. Must be between 13 and 120."
    }
    
    // If all validations pass, return success message
    return "User '$username' registered successfully with email '$email' (age: $age)"
}

// ===========================================
// USING ALL FUNCTION FEATURES TOGETHER
// ===========================================

println("=== DEMONSTRATING ALL FUNCTION FEATURES ===")

// Test default parameters
println("\n--- Default Parameters ---")
greetUser()  // Uses all defaults
greetUser("Alice")  // Uses default greeting
greetUser("Bob", "Hi there")  // Overrides all defaults

// Test varargs
println("\n--- Varargs ---")
printAll("Hello", "World", "Kotlin", "Programming")
printAll("Single message")

val stats = analyzeNumbers(10, 25, 30, 15, 40, 5)
println("Number analysis: $stats")

// Test single expression functions
println("\n--- Single Expression Functions ---")
println("5 squared: ${square(5)}")
println("3 cubed: ${cube(3)}")
println("Is 8 even? ${isEven(8)}")
println("Is -5 positive? ${isPositive(-5)}")
println("'hello' capitalized: ${capitalizeFirst("hello")}")
println("'kotlin' reversed: ${reverseString("kotlin")}")
println("Vowels in 'programming': ${countVowels("programming")}")

// Test local functions
println("\n--- Local Functions ---")
val totalCost = calculateTotalWithTax(25.0, 3)
println("Total cost with tax and discounts: $${String.format("%.2f", totalCost)}")

val registrationResult = registerUser("john_doe", "john@example.com", 25)
println("Registration result: $registrationResult")

val invalidRegistration = registerUser("j", "invalid-email", 5)
println("Invalid registration result: $invalidRegistration")

Advanced Functions

Lambda Expressions - are anonymous functions that can be stored in variables. They are often used for short, one-time operations. They are defined using the lambda keyword.

Higher-Order Functions - are functions that take other functions as parameters or return functions. They are often used to create flexible, reusable code patterns.

Function References - are references to functions that can be passed around and used as arguments. They are often used to pass functions as arguments to other functions.

When to Use

• Use lambda expressions for short, one-time operations
• Use higher-order functions when you need flexible, reusable code patterns
• Use function references when you need to pass functions as arguments

Practical Examples

// ===========================================
// LAMBDA EXPRESSIONS EXAMPLES
// ===========================================

// Example 1: Basic lambda expressions
// Lambdas are anonymous functions that can be stored in variables
val add = { x: Int, y: Int -> x + y }
val multiply = { x: Int, y: Int -> x * y }
val isEven = { x: Int -> x % 2 == 0 }
val getLength = { str: String -> str.length }

println(add(3, 4))        // 7
println(multiply(5, 6))   // 30
println(isEven(10))       // true
println(isEven(7))        // false
println(getLength("Scott")) // 5

// Example 2: Lambda with different parameter types
// Lambdas can work with any data types
val formatPrice = { price: Double -> "$${String.format("%.2f", price)}" }
val capitalize = { str: String -> str.uppercase() }
val isAdult = { age: Int -> age >= 18 }

println(formatPrice(29.99))  // $29.99
println(capitalize("hello world")) // HELLO WORLD
println(isAdult(25))        // true

// Example 3: Lambda with complex logic
// Lambdas can contain multiple statements
val processUser = { name: String, age: Int ->
    val status = if (age >= 18) "Adult" else "Minor"
    val greeting = if (age >= 18) "Welcome" else "Hello young one"
    "$greeting, $name! You are a $status."
}

println(processUser("Alice", 25)) // Welcome, Alice! You are an Adult.
println(processUser("Bob", 15)) // Hello young one, Bob! You are a Minor.

// ===========================================
// HIGHER-ORDER FUNCTIONS EXAMPLES
// ===========================================

// Example 1: Function that takes another function as parameter
// This function can perform any operation on two numbers
fun performOperation(x: Int, y: Int, operation: (Int, Int) -> Int): Int {
    println("Performing operation on $x and $y")
    val result = operation(x, y)
    println("Result: $result")
    return result
}

println(performOperation(10, 5, add)) // 15
println(performOperation(10, 5, multiply)) // 50

// Example 2: Function that returns a function
// This function creates different greeting functions
fun createGreeter(greeting: String): (String) -> String {
    return { name -> "$greeting, $name!" }
}

println(createGreeter("Good day")("Mr. Smith")) // Good day, Mr. Smith!
println(createGreeter("Hey")("John")) // Hey, John!

// Example 3: Function that processes a list with a custom operation
// This function applies any transformation to list elements
fun processList(
    items: List<String>, 
    processor: (String) -> String,
    filter: (String) -> Boolean = { true }  // Default filter accepts everything
): List<String> {
    return items
        .filter(filter)           // Apply the filter function
        .map(processor)           // Apply the processor function
}

// Example 4: Function that combines multiple operations
// This function can chain different operations together
fun  chainOperations(
    initial: T,
    operations: List<(T) -> T>
): T {
    var result = initial
    println("Starting with: $result")
    
    for ((index, operation) in operations.withIndex()) {
        result = operation(result)
        println("After operation ${index + 1}: $result")
    }
    
    return result
}

// ===========================================
// FUNCTION REFERENCES EXAMPLES
// ===========================================

// Example 1: Basic function references
// These functions can be referenced and passed around
fun inchesToFeet(inches: Double): Double {
    return inches * 0.0833333
}

fun inchesToYards(inches: Double): Double {
    return inches * 0.0277778
}

fun inchesToMeters(inches: Double): Double {
    return inches * 0.0254
}

// Example 2: Function that uses function references
// This function can convert measurements using any conversion function
fun convertMeasurement(value: Double, converter: (Double) -> Double): Double {
    val result = converter(value)
    println("Converted $value inches to ${String.format("%.4f", result)} units")
    return result
}

// Example 3: Function that creates conversion chains
// This function can apply multiple conversions in sequence
fun createConversionChain(
    startValue: Double,
    conversions: List<(Double) -> Double>
): List<Double> {
    val results = mutableListOf<Double>()
    var currentValue = startValue
    
    for (conversion in conversions) {
        currentValue = conversion(currentValue)
        results.add(currentValue)
    }
    
    return results
}

// ===========================================
// USING ALL ADVANCED FUNCTION FEATURES
// ===========================================

println("=== DEMONSTRATING ADVANCED FUNCTION FEATURES ===")

// Test lambda expressions
println("\n--- Lambda Expressions ---")
println("5 + 3 = ${add(5, 3)}")
println("4 * 6 = ${multiply(4, 6)}")
println("Is 7 even? ${isEven(7)}")
println("Length of 'Kotlin': ${getLength("Kotlin")}")
println("Formatted price: ${formatPrice(29.99)}")
println("Capitalized: ${capitalize("hello world")}")
println("User processing: ${processUser("Alice", 25)}")

// Test higher-order functions
println("\n--- Higher-Order Functions ---")
val sum = performOperation(10, 5, add)
val product = performOperation(10, 5, multiply)

// Create custom operations
val power = { x: Int, y: Int -> 
    var result = 1
    repeat(y) { result *= x }
    result
}
val powerResult = performOperation(2, 8, power)

// Test function that returns functions
val formalGreeter = createGreeter("Good day")
val casualGreeter = createGreeter("Hey")
println("Formal: ${formalGreeter("Mr. Smith")}")
println("Casual: ${casualGreeter("John")}")

// Test list processing
val names = listOf("alice", "bob", "charlie", "diana", "eve")
val processedNames = processList(
    items = names,
    processor = { it.uppercase() },
    filter = { it.length > 3 }
)
println("Processed names: $processedNames")

// Test operation chaining
val numbers = listOf(
    { x: Int -> x + 10 },
    { x: Int -> x * 2 },
    { x: Int -> x - 5 }
)
val finalResult = chainOperations(5, numbers)
println("Final result after chaining: $finalResult")

// Test function references
println("\n--- Function References ---")
val feet = convertMeasurement(12.0, ::inchesToFeet)
val yards = convertMeasurement(36.0, ::inchesToYards)
val meters = convertMeasurement(39.37, ::inchesToMeters)

// Test conversion chains
val conversionChain = createConversionChain(12.0, listOf(
    ::inchesToFeet,
    ::inchesToYards,
    ::inchesToMeters
))
println("Conversion chain results: $conversionChain")

// Test with custom lambda instead of function reference
val customConversion = { inches: Double -> inches * 0.1 }  // Convert to custom units
val customResult = convertMeasurement(10.0, customConversion)

Classes and Objects

When to Use

• When you need to represent real-world entities in your code
• When you want to organize related data and functions together
• When you need to create multiple objects with similar properties
• When you want to reuse code across your program

Practical Examples

// ===========================================
// BASIC CLASS WITH PROPERTIES AND METHODS
// ===========================================

// Example 1: Simple Dog class
// This demonstrates the basic structure of a class
class Dog {
    // Properties - data that describes the dog
    var name: String = "Unknown"
    var age: Int = 0
    var breed: String = "Mixed"
    var isHungry: Boolean = true
    
    // Methods - actions the dog can perform
    fun bark() {
        println("$name says: Woof! Woof!")
    }
    
    fun eat() {
        if (isHungry) {
            println("$name is eating...")
            isHungry = false
            println("$name is no longer hungry!")
        } else {
            println("$name is not hungry right now.")
        }
    }
    
    fun sleep() {
        println("$name is sleeping... Zzz...")
        isHungry = true  // Dog gets hungry while sleeping
    }
    
    fun celebrateBirthday() {
        age++
        println("Happy Birthday, $name! You are now $age years old!")
    }
    
    fun displayInfo() {
        println("""
        Dog Information:
          Name: $name
          Age: $age
          Breed: $breed
          Hungry: $isHungry
        """.trimIndent())
    }
}

// Example 2: Bank Account class
// This shows a more practical business application
class BankAccount {
    // Properties
    var accountNumber: String = ""
    var accountHolder: String = ""
    var balance: Double = 0.0
    var isActive: Boolean = true
    
    // Methods
    fun deposit(amount: Double) {
        if (amount > 0 && isActive) {
            balance += amount
            println("Deposited $${String.format("%.2f", amount)} to account $accountNumber")
            println("New balance: $${String.format("%.2f", balance)}")
        } else {
            println("Invalid deposit amount or account inactive")
        }
    }
    
    fun withdraw(amount: Double): Boolean {
        if (amount > 0 && amount <= balance && isActive) {
            balance -= amount
            println("Withdrew $${String.format("%.2f", amount)} from account $accountNumber")
            println("New balance: $${String.format("%.2f", balance)}")
            return true
        } else {
            println("Insufficient funds, invalid amount, or account inactive")
            return false
        }
    }
    
    fun checkBalance() {
        println("Account $accountNumber balance: $${String.format("%.2f", balance)}")
    }
    
    fun deactivate() {
        isActive = false
        println("Account $accountNumber has been deactivated")
    }
}

// ===========================================
// CREATING AND USING OBJECTS
// ===========================================

println("=== CREATING AND USING DOG OBJECTS ===")

// Create a new Dog object (instance of the Dog class)
val myDog = Dog()

// Set the dog's properties
myDog.name = "Buddy"
myDog.age = 3
myDog.breed = "Golden Retriever"

// Use the dog's methods
myDog.displayInfo()
myDog.bark()
myDog.eat()
myDog.sleep()
myDog.celebrateBirthday()
myDog.displayInfo()

println("\n=== CREATING MULTIPLE DOG OBJECTS ===")

// Create another dog object
val anotherDog = Dog()
anotherDog.name = "Max"
anotherDog.age = 5
anotherDog.breed = "Labrador"

// Each dog object has its own state
println("First dog: ${myDog.name}, Age: ${myDog.age}")
println("Second dog: ${anotherDog.name}, Age: ${anotherDog.age}")

// Dogs can have different states
myDog.eat()      // Buddy eats
anotherDog.eat() // Max eats
myDog.eat()      // Buddy is not hungry anymore

println("\n=== CREATING AND USING BANK ACCOUNTS ===")

// Create a bank account
val account1 = BankAccount()
account1.accountNumber = "ACC001"
account1.accountHolder = "John Doe"
account1.balance = 1000.0

// Use the bank account
account1.checkBalance()
account1.deposit(500.0)
account1.withdraw(200.0)
account1.checkBalance()

// Create another account
val account2 = BankAccount()
account2.accountNumber = "ACC002"
account2.accountHolder = "Jane Smith"
account2.balance = 2500.0

// Each account has its own state
println("\nAccount Summary:")
println("Account 1: $${String.format("%.2f", account1.balance)}")
println("Account 2: $${String.format("%.2f", account2.balance)}")

Constructors

When to Use

• When you need to initialize objects with specific values
• When you want to ensure objects are created with valid data
• When you need different ways to create objects

Practical Examples

// ===========================================
// PRIMARY CONSTRUCTOR EXAMPLES
// ===========================================

// Example 1: Class with primary constructor
// This is the most common way to create classes in Kotlin
class Person(val name: String, var age: Int) {
    // The constructor parameters automatically create properties
    // 'val name' creates an immutable property
    // 'var age' creates a mutable property
    
    // You can add additional properties
    var email: String = ""
    var isActive: Boolean = true
    
    // Initializer block - runs when object is created
    init {
        println("Creating person: $name, age $age")
        
        // You can add validation logic
        if (age < 0) {
            throw IllegalArgumentException("Age cannot be negative")
        }
        
        if (name.isEmpty()) {
            throw IllegalArgumentException("Name cannot be empty")
        }
    }
    
    // Methods
    fun introduce() {
        println("Hi, I'm $name and I'm $age years old.")
    }
    
    fun haveBirthday() {
        age++
        println("Happy Birthday, $name! You are now $age years old!")
    }
    
    fun updateEmail(newEmail: String) {
        email = newEmail
        println("$name's email updated to: $email")
    }
}

// Example 2: Class with default parameters
// This makes the class more flexible
class Car(
    val brand: String,
    val model: String,
    var year: Int = 2024,
    var color: String = "White",
    var mileage: Double = 0.0
) {
    init {
        println("Creating car: $year $brand $model in $color")
    }
    
    fun start() {
        println("Starting $brand $model...")
    }
    
    fun drive(distance: Double) {
        mileage += distance
        println("Drove $distance miles. Total mileage: $mileage")
    }
    
    fun displayInfo() {
        println("""
        Car Information:
          Brand: $brand
          Model: $model
          Year: $year
          Color: $color
          Mileage: $mileage miles
        """.trimIndent())
    }
}

// ===========================================
// SECONDARY CONSTRUCTOR EXAMPLES
// ===========================================

// Example 3: Class with secondary constructor
// This provides alternative ways to create objects
class BankAccount(val accountNumber: String, var balance: Double) {
    var accountHolder: String = "Unknown"
    var accountType: String = "Checking"
    var isActive: Boolean = true
    
    // Primary constructor
    init {
        println("Account $accountNumber created with balance $${String.format("%.2f", balance)}")
    }
    
    // Secondary constructor - calls primary constructor with 'this'
    constructor(number: String, balance: Double, holder: String) : this(number, balance) {
        accountHolder = holder
        println("Account created for $holder")
    }
    
    // Another secondary constructor
    constructor(number: String, balance: Double, holder: String, type: String) : this(number, balance, holder) {
        accountType = type
        println("Account type set to: $type")
    }
    
    // Methods
    fun displayAccountInfo() {
        println("""
        Account Information:
          Number: $accountNumber
          Holder: $accountHolder
          Type: $accountType
          Balance: $${String.format("%.2f", balance)}
          Active: $isActive
        """.trimIndent())
    }
    
    fun deposit(amount: Double) {
        if (amount > 0 && isActive) {
            balance += amount
            println("Deposited $${String.format("%.2f", amount)}")
        }
    }
    
    fun withdraw(amount: Double): Boolean {
        if (amount > 0 && amount <= balance && isActive) {
            balance -= amount
            println("Withdrew $${String.format("%.2f", amount)}")
            return true
        }
        return false
    }
}

// ===========================================
// USING CONSTRUCTORS
// ===========================================

println("=== USING PRIMARY CONSTRUCTORS ===")

// Create Person objects using primary constructor
val person1 = Person("Alice", 25)
val person2 = Person("Bob", 30)

person1.introduce()
person2.introduce()

person1.haveBirthday()
person1.updateEmail("alice@example.com")

println("\n=== USING CAR CONSTRUCTORS WITH DEFAULTS ===")

// Create cars with different numbers of parameters
val car1 = Car("Toyota", "Camry")  // Uses defaults for year, color, mileage
val car2 = Car("Honda", "Civic", 2023, "Blue")  // Override some defaults
val car3 = Car("Ford", "Mustang", 2022, "Red", 15000.0)  // Override all defaults

car1.displayInfo()
car2.displayInfo()
car3.displayInfo()

car1.start()
car1.drive(50.0)
car1.displayInfo()

println("\n=== USING SECONDARY CONSTRUCTORS ===")

// Create bank accounts using different constructors
val account1 = BankAccount("ACC001", 1000.0)  // Primary constructor
val account2 = BankAccount("ACC002", 2000.0, "John Doe")  // Secondary constructor
val account3 = BankAccount("ACC003", 3000.0, "Jane Smith", "Savings")  // Another secondary constructor

account1.displayAccountInfo()
account2.displayAccountInfo()
account3.displayAccountInfo()

// Test account operations
account1.deposit(500.0)
account2.withdraw(300.0)
account3.deposit(1000.0)

println("\nAfter transactions:")
account1.displayAccountInfo()
account2.displayAccountInfo()
account3.displayAccountInfo()

Properties and Accessors

When to Use

• Use properties to store data in your classes
• Use custom accessors when you need to control how properties are accessed
• Use private properties when you want to restrict access

Practical Examples

// ===========================================
// BASIC PROPERTIES AND ACCESSORS
// ===========================================

// Example 1: Class with basic properties
// This shows the standard way to define properties
class Student(
    val studentId: String,  // Immutable property (read-only)
    var name: String,       // Mutable property (read-write)
    var age: Int            // Mutable property (read-write)
) {
    // Additional properties
    var email: String = ""
    var major: String = "Undeclared"
    var gpa: Double = 0.0
    
    // Method to display student information
    fun displayInfo() {
        println("""
        Student Information:
          ID: $studentId
          Name: $name
          Age: $age
          Email: $email
          Major: $major
          GPA: $gpa
        """.trimIndent())
    }
}

// Example 2: Class with custom getters and setters
// This demonstrates how to control property access
class BankAccount(val accountNumber: Int, private var accountBalance: Double) {
    // Public property with custom getter
    val balance: Double
        get() {
            println("Balance accessed for account $accountNumber")
            return accountBalance
        }
    
    // Public property with custom getter and setter
    var balanceLessFees: Double
        get() = accountBalance - 25.0  // $25 monthly fee
        set(value) {
            // Validate the new value
            if (value >= 0) {
                accountBalance = value + 25.0  // Add fee back to get actual balance
                println("Balance updated to $${String.format("%.2f", value)} (plus fees)")
            } else {
                println("Error: Balance cannot be negative")
            }
        }
    
    // Private property for internal use
    private val monthlyFee: Double = 25.0
    
    // Method to get account type
    val accountType: String
        get() = when {
            accountBalance >= 10000 -> "Premium"
            accountBalance >= 5000 -> "Standard"
            else -> "Basic"
        }
    
    // Method to display account information
    fun displayAccountInfo() {
        println("""
        Account Information:
          Number: $accountNumber
          Balance: $${String.format("%.2f", balance)}
          Balance after fees: $${String.format("%.2f", balanceLessFees)}
          Account Type: $accountType
          Monthly Fee: $${String.format("%.2f", monthlyFee)}
        """.trimIndent())
    }
    
    // Method to deposit money
    fun deposit(amount: Double) {
        if (amount > 0) {
            accountBalance += amount
            println("Deposited $${String.format("%.2f", amount)}")
            println("New balance: $${String.format("%.2f", balance)}")
        } else {
            println("Invalid deposit amount")
        }
    }
    
    // Method to withdraw money
    fun withdraw(amount: Double): Boolean {
        if (amount > 0 && amount <= balance) {
            accountBalance -= amount
            println("Withdrew $${String.format("%.2f", amount)}")
            println("New balance: $${String.format("%.2f", balance)}")
            return true
        } else {
            println("Invalid withdrawal amount or insufficient funds")
            return false
        }
    }
}

// Example 3: Class with computed properties
// This shows properties that calculate values on demand
class Rectangle(val width: Double, val height: Double) {
    // Computed property for area
    val area: Double
        get() = width * height
    
    // Computed property for perimeter
    val perimeter: Double
        get() = 2 * (width + height)
    
    // Computed property for diagonal
    val diagonal: Double
        get() = kotlin.math.sqrt(width * width + height * height)
    
    // Computed property for shape description
    val shapeDescription: String
        get() = when {
            width == height -> "Square"
            width > height -> "Landscape Rectangle"
            else -> "Portrait Rectangle"
        }
    
    // Method to display rectangle information
    fun displayInfo() {
        println("""
        Rectangle Information:
          Width: $width
          Height: $height
          Area: $area
          Perimeter: $perimeter
          Diagonal: ${String.format("%.2f", diagonal)}
          Shape: $shapeDescription
        """.trimIndent())
    }
}

// Example 4: Class with validation in setters
// This demonstrates how to validate data when setting properties
class Person(var name: String, var age: Int) {
    // Custom setter with validation for name
    var fullName: String = name
        set(value) {
            if (value.isNotBlank() && value.length >= 2) {
                field = value.trim()  // 'field' refers to the backing field
                println("Name updated to: '$field'")
            } else {
                println("Error: Name must be at least 2 characters long")
            }
        }
    
    // Custom setter with validation for age
    var personAge: Int = age
        set(value) {
            if (value >= 0 && value <= 150) {
                field = value
                println("Age updated to: $field")
            } else {
                println("Error: Age must be between 0 and 150")
            }
        }
    
    // Computed property for age group
    val ageGroup: String
        get() = when {
            personAge < 13 -> "Child"
            personAge < 20 -> "Teenager"
            personAge < 65 -> "Adult"
            else -> "Senior"
        }
    
    // Computed property for voting eligibility
    val canVote: Boolean
        get() = personAge >= 18
    
    // Method to display person information
    fun displayInfo() {
        println("""
        Person Information:
          Name: '$fullName'
          Age: $personAge
          Age Group: $ageGroup
          Can Vote: $canVote
        """.trimIndent())
    }
}

// ===========================================
// USING PROPERTIES AND ACCESSORS
// ===========================================

println("=== USING BASIC PROPERTIES ===")

// Create and use Student objects
val student1 = Student("S001", "Alice Johnson", 20)
student1.email = "alice@university.edu"
student1.major = "Computer Science"
student1.gpa = 3.8

student1.displayInfo()

println("\n=== USING CUSTOM ACCESSORS ===")

// Create and use BankAccount objects
val account1 = BankAccount(1001, 5000.0)
account1.displayAccountInfo()

// Test custom getters and setters
println("\nAccessing balance: ${account1.balance}")
account1.balanceLessFees = 2000.0  // This will update the actual balance
account1.displayAccountInfo()

// Test deposit and withdrawal
account1.deposit(1000.0)
account1.withdraw(500.0)
account1.displayAccountInfo()

println("\n=== USING COMPUTED PROPERTIES ===")

// Create and use Rectangle objects
val rect1 = Rectangle(5.0, 3.0)
val rect2 = Rectangle(4.0, 4.0)

rect1.displayInfo()
println()
rect2.displayInfo()

println("\n=== USING VALIDATION IN SETTERS ===")

// Create and use Person objects
val person1 = Person("John", 25)
person1.displayInfo()

// Test validation in setters
person1.fullName = "John Doe"      // Valid name
person1.fullName = "A"             // Invalid name (too short)
person1.fullName = "   "           // Invalid name (blank)

person1.personAge = 30             // Valid age
person1.personAge = -5             // Invalid age (negative)
person1.personAge = 200            // Invalid age (too high)

person1.displayInfo()

Companion Objects

When to Use

• When you need to create static members in your class
• When you want to create factory methods
• When you need to track class-level information

Practical Examples

// ===========================================
// COMPANION OBJECT EXAMPLES
// ===========================================

// Example 1: Basic companion object
// This demonstrates the fundamental concept
class Car {
    var brand: String = "Unknown"
    var model: String = "Unknown"
    var year: Int = 2024
    
    companion object {
        // Static property - shared across all Car instances
        var totalCars: Int = 0
        
        // Static method - can be called without creating an instance
        fun getTotalCars(): Int {
            return totalCars
        }
        
        // Factory method - creates cars in a controlled way
        fun createCar(brand: String, model: String, year: Int): Car {
            val car = Car()
            car.brand = brand
            car.model = model
            car.year = year
            totalCars++  // Increment the counter
            return car
        }
        
        // Static method to reset counter
        fun resetCounter() {
            totalCars = 0
            println("Car counter reset to 0")
        }
    }
    
    // Instance method
    fun displayInfo() {
        println("$year $brand $model")
    }
}

// Example 2: Companion object with constants and utilities
// This shows more practical usage patterns
class MathUtils {
    companion object {
        // Mathematical constants
        const val PI = 3.14159265359
        const val E = 2.71828182846
        const val GOLDEN_RATIO = 1.61803398875
        
        // Utility functions
        fun factorial(n: Int): Long {
            return if (n <= 1) 1 else n * factorial(n - 1)
        }
        
        fun isPrime(n: Int): Boolean {
            if (n < 2) return false
            for (i in 2..kotlin.math.sqrt(n.toDouble()).toInt()) {
                if (n % i == 0) return false
            }
            return true
        }
        
        fun fibonacci(n: Int): Long {
            return if (n <= 1) n.toLong() else fibonacci(n - 1) + fibonacci(n - 2)
        }
        
        fun roundToDecimal(value: Double, decimals: Int): Double {
            val factor = kotlin.math.pow(10.0, decimals.toDouble())
            return kotlin.math.round(value * factor) / factor
        }
    }
}

// Example 3: Companion object for configuration and settings
// This demonstrates managing application-wide settings
class AppConfig {
    companion object {
        // Application settings
        var debugMode: Boolean = false
        var maxUsers: Int = 100
        var sessionTimeout: Int = 3600  // seconds
        var databaseUrl: String = "localhost:5432"
        
        // Configuration methods
        fun enableDebugMode() {
            debugMode = true
            println("Debug mode enabled")
        }
        
        fun disableDebugMode() {
            debugMode = false
            println("Debug mode disabled")
        }
        
        fun updateMaxUsers(newMax: Int) {
            if (newMax > 0) {
                maxUsers = newMax
                println("Maximum users updated to: $maxUsers")
            } else {
                println("Error: Maximum users must be positive")
            }
        }
        
        fun displayConfig() {
            println("""
            Application Configuration:
              Debug Mode: $debugMode
              Max Users: $maxUsers
              Session Timeout: ${sessionTimeout} seconds
              Database URL: $databaseUrl
            """.trimIndent())
        }
    }
}

// Example 4: Companion object for validation and formatting
// This shows utility functions that don't need instance data
class StringUtils {
    companion object {
        // Validation functions
        fun isValidEmail(email: String): Boolean {
            return email.contains("@") && 
                   email.contains(".") && 
                   email.indexOf("@") < email.lastIndexOf(".")
        }
        
        fun isValidPhoneNumber(phone: String): Boolean {
            val digits = phone.filter { it.isDigit() }
            return digits.length in 10..11
        }
        
        fun isValidPassword(password: String): Boolean {
            return password.length >= 8 && 
                   password.any { it.isUpperCase() } &&
                   password.any { it.isDigit() }
        }
        
        // Formatting functions
        fun formatPhoneNumber(phone: String): String {
            val digits = phone.filter { it.isDigit() }
            return when {
                digits.length == 10 -> "(${digits.substring(0, 3)}) ${digits.substring(3, 6)}-${digits.substring(6)}"
                digits.length == 11 && digits.startsWith("1") -> "1 (${digits.substring(1, 4)}) ${digits.substring(4, 7)}-${digits.substring(7)}"
                else -> phone
            }
        }
        
        fun formatCurrency(amount: Double): String {
            return "$${String.format("%.2f", amount)}"
        }
        
        fun capitalizeWords(text: String): String {
            return text.split(" ").joinToString(" ") { word ->
                word.lowercase().replaceFirstChar { it.uppercase() }
            }
        }
    }
}

// ===========================================
// USING COMPANION OBJECTS
// ===========================================

println("=== USING CAR COMPANION OBJECT ===")

// Use companion object methods without creating instances
println("Total cars before creation: ${Car.getTotalCars()}")

// Create cars using the factory method
val car1 = Car.createCar("Toyota", "Camry", 2024)
val car2 = Car.createCar("Honda", "Civic", 2023)
val car3 = Car.createCar("Ford", "Mustang", 2022)

// Display car information
car1.displayInfo()
car2.displayInfo()
car3.displayInfo()

// Check total cars
println("Total cars after creation: ${Car.getTotalCars()}")

// Reset counter
Car.resetCounter()
println("Total cars after reset: ${Car.getTotalCars()}")

println("\n=== USING MATH UTILS COMPANION OBJECT ===")

// Use mathematical constants and utilities
println("PI: ${MathUtils.PI}")
println("E: ${MathUtils.E}")
println("Golden Ratio: ${MathUtils.GOLDEN_RATIO}")

println("Factorial of 5: ${MathUtils.factorial(5)}")
println("Is 17 prime? ${MathUtils.isPrime(17)}")
println("Fibonacci number 10: ${MathUtils.fibonacci(10)}")
println("3.14159 rounded to 2 decimals: ${MathUtils.roundToDecimal(3.14159, 2)}")

println("\n=== USING APP CONFIG COMPANION OBJECT ===")

// Display initial configuration
AppConfig.displayConfig()

// Modify configuration
AppConfig.enableDebugMode()
AppConfig.updateMaxUsers(200)
AppConfig.sessionTimeout = 7200

// Display updated configuration
AppConfig.displayConfig()

println("\n=== USING STRING UTILS COMPANION OBJECT ===")

// Test validation functions
val testEmails = listOf("user@example.com", "invalid-email", "test@", "@domain.com")
val testPhones = listOf("555-123-4567", "1234567890", "1-800-555-0123", "invalid")
val testPasswords = listOf("StrongPass123", "weak", "12345678", "NoNumbers")

println("Email Validation:")
for (email in testEmails) {
    println("  '$email': ${StringUtils.isValidEmail(email)}")
}

println("\nPhone Validation:")
for (phone in testPhones) {
    println("  '$phone': ${StringUtils.isValidPhoneNumber(phone)}")
}

println("\nPassword Validation:")
for (password in testPasswords) {
    println("  '$password': ${StringUtils.isValidPassword(password)}")
}

// Test formatting functions
println("\nFormatting Examples:")
println("Phone: ${StringUtils.formatPhoneNumber("5551234567")}")
println("Currency: ${StringUtils.formatCurrency(1234.56)}")
println("Capitalized: ${StringUtils.capitalizeWords("hello world kotlin programming")}")

Inheritance Basics

When to Use

• When you need to create a new class that is a specialized version of an existing class
• When you want to reuse code from an existing class
• When you need to create a hierarchy of related classes
• When you want to extend functionality without modifying the original class

Practical Examples

// ===========================================
// BASIC INHERITANCE EXAMPLE
// ===========================================

// Step 1: Create a base class (parent class)
// The 'open' keyword makes this class inheritable
open class Animal {
    // Properties that all animals will have
    var name: String = ""
    var age: Int = 0
    
    // Constructor - called when creating an Animal object
    constructor(name: String, age: Int) {
        this.name = name
        this.age = age
    }
    
    // Method that can be overridden by subclasses
    open fun makeSound() {
        println("Some animal sound")
    }
    
    // Method to display animal info
    fun displayInfo() {
        println("Name: $name, Age: $age")
    }
}

// Step 2: Create a subclass (child class)
// The colon ':' means "inherits from"
// Dog inherits all properties and methods from Animal
class Dog : Animal {
    // Additional property specific to dogs
    var breed: String = ""
    
    // Constructor for Dog - must call parent constructor
    constructor(name: String, age: Int, breed: String) : super(name, age) {
        this.breed = breed
    }
    
    // Override the makeSound method from Animal
    override fun makeSound() {
        println("Woof! Woof!")
    }
    
    // New method specific to dogs
    fun wagTail() {
        println("$name is wagging their tail!")
    }
}

// ===========================================
// INHERITANCE WITH CONSTRUCTORS EXAMPLE
// ===========================================

// Base class for vehicles
open class Vehicle(val brand: String) {
    // Properties
    var isRunning: Boolean = false
    var currentSpeed: Int = 0
    
    // Method that can be overridden
    open fun start() {
        isRunning = true
        println("Starting $brand vehicle")
    }
    
    // Method to stop the vehicle
    fun stop() {
        isRunning = false
        currentSpeed = 0
        println("Stopping $brand vehicle")
    }
    
    // Method to accelerate
    open fun accelerate(speed: Int) {
        if (isRunning) {
            currentSpeed += speed
            println("$brand vehicle accelerating to $currentSpeed mph")
        } else {
            println("Cannot accelerate - vehicle is not running!")
        }
    }
}

// Subclass for cars - inherits from Vehicle
class Car(brand: String, val model: String) : Vehicle(brand) {
    // Additional properties specific to cars
    var numberOfDoors: Int = 4
    var fuelType: String = "Gasoline"
    
    // Override the start method to add car-specific behavior
    override fun start() {
        super.start()  // Call the parent class start method first
        println("Starting $model car with $numberOfDoors doors")
    }
    
    // Override accelerate method for car-specific behavior
    override fun accelerate(speed: Int) {
        super.accelerate(speed)  // Call parent method
        if (currentSpeed > 80) {
            println("Warning: $model is going fast!")
        }
    }
    
    // New method specific to cars
    fun honkHorn() {
        println("$model car honking horn: Beep! Beep!")
    }
}

// ===========================================
// USING THE CLASSES EXAMPLE
// ===========================================

// Create and use Animal and Dog objects
println("=== ANIMAL INHERITANCE EXAMPLE ===")
val genericAnimal = Animal("Unknown", 5)
genericAnimal.makeSound()  // Outputs: Some animal sound
genericAnimal.displayInfo() // Outputs: Name: Unknown, Age: 5

val myDog = Dog("Buddy", 3, "Golden Retriever")
myDog.makeSound()    // Outputs: Woof! Woof! (overridden method)
myDog.displayInfo()  // Outputs: Name: Buddy, Age: 3 (inherited method)
myDog.wagTail()      // Outputs: Buddy is wagging their tail! (new method)

println("\n=== VEHICLE INHERITANCE EXAMPLE ===")
val genericVehicle = Vehicle("Generic")
genericVehicle.start()      // Outputs: Starting Generic vehicle
genericVehicle.accelerate(30) // Outputs: Generic vehicle accelerating to 30 mph

val myCar = Car("Toyota", "Camry")
myCar.start()        // Outputs: Starting Toyota vehicle, Starting Camry car with 4 doors
myCar.accelerate(50) // Outputs: Toyota vehicle accelerating to 50 mph
myCar.accelerate(40) // Outputs: Toyota vehicle accelerating to 90 mph, Warning: Camry is going fast!
myCar.honkHorn()     // Outputs: Camry car honking horn: Beep! Beep!

Method Overriding

When to Use

• When you need to customize behavior inherited from a parent class
• When you want to extend functionality of a parent method
• When you need to provide a different implementation for a method

Practical Examples

// ===========================================
// METHOD OVERRIDING WITH BANK ACCOUNTS
// ===========================================

// Base class for all bank accounts
open class BankAccount(val accountNumber: Int, var balance: Double) {
    // Properties
    val accountType: String = "Basic Account"
    var isActive: Boolean = true
    
    // Method that can be overridden
    open fun displayBalance() {
        println("Account $accountNumber ($accountType): Balance is $${String.format("%.2f", balance)}")
    }
    
    // Method to deposit money
    open fun deposit(amount: Double) {
        if (amount > 0 && isActive) {
            balance += amount
            println("Deposited $${String.format("%.2f", amount)} to account $accountNumber")
            println("New balance: $${String.format("%.2f", balance)}")
        } else {
            println("Invalid deposit amount or account inactive")
        }
    }
    
    // Method to withdraw money
    open fun withdraw(amount: Double): Boolean {
        if (amount > 0 && amount <= balance && isActive) {
            balance -= amount
            println("Withdrew $${String.format("%.2f", amount)} from account $accountNumber")
            println("New balance: $${String.format("%.2f", balance)}")
            return true
        } else {
            println("Insufficient funds, invalid amount, or account inactive")
            return false
        }
    }
}

// Subclass for savings accounts
class SavingsAccount(accountNumber: Int, balance: Double, val interestRate: Double) 
    : BankAccount(accountNumber, balance) {
    
    // Override the accountType property
    override val accountType: String = "Savings Account"
    
    // Override displayBalance to show additional info
    override fun displayBalance() {
        super.displayBalance()  // Call parent method first to show basic info
        println("  Interest Rate: ${(interestRate * 100)}%")  // Add savings-specific info
        println("  Interest earned this period: $${String.format("%.2f", calculateInterest())}")
    }
    
    // Override deposit to add interest calculation
    override fun deposit(amount: Double) {
        super.deposit(amount)  // Use parent method for basic deposit
        // Add interest calculation for savings
        val interest = calculateInterest()
        if (interest > 0) {
            println("  Interest added: $${String.format("%.2f", interest)}")
        }
    }
    
    // Override withdraw to add savings-specific logic
    override fun withdraw(amount: Double): Boolean {
        // Check if withdrawal would leave minimum balance
        if (balance - amount < 100) {
            println("Warning: This withdrawal would leave less than $100 minimum balance")
        }
        
        // Use parent method for actual withdrawal
        return super.withdraw(amount)
    }
    
    // New method specific to savings accounts
    fun calculateInterest(): Double {
        return balance * interestRate
    }
    
    // Method to add interest to balance
    fun addInterest() {
        val interest = calculateInterest()
        balance += interest
        println("Interest of $${String.format("%.2f", interest)} added to savings account")
    }
}

// Subclass for checking accounts
class CheckingAccount(accountNumber: Int, balance: Double, val monthlyFee: Double) 
    : BankAccount(accountNumber, balance) {
    
    override val accountType: String = "Checking Account"
    
    // Override displayBalance to show fees
    override fun displayBalance() {
        super.displayBalance()  // Call parent method
        println("  Monthly fee: $${String.format("%.2f", monthlyFee)}")
    }
    
    // Override withdraw to add checking-specific logic
    override fun withdraw(amount: Double): Boolean {
        // Check if withdrawal would cause overdraft
        if (amount > balance) {
            println("Warning: This withdrawal will cause overdraft!")
        }
        
        return super.withdraw(amount)
    }
    
    // New method to apply monthly fee
    fun applyMonthlyFee() {
        balance -= monthlyFee
        println("Monthly fee of $${String.format("%.2f", monthlyFee)} applied to checking account")
    }
}

// ===========================================
// USING THE OVERRIDDEN METHODS
// ===========================================

println("=== BANK ACCOUNT OVERRIDING EXAMPLE ===")

// Create different types of accounts
val basicAccount = BankAccount(1001, 500.0)
val savingsAccount = SavingsAccount(1002, 1000.0, 0.025)  // 2.5% interest
val checkingAccount = CheckingAccount(1003, 750.0, 5.0)   // $5 monthly fee

// Test basic account
println("--- Basic Account ---")
basicAccount.displayBalance()
basicAccount.deposit(200.0)
basicAccount.withdraw(100.0)

// Test savings account with overridden methods
println("\n--- Savings Account ---")
savingsAccount.displayBalance()  // Shows interest rate and earned interest
savingsAccount.deposit(500.0)   // Shows interest calculation
savingsAccount.addInterest()     // Adds interest to balance
savingsAccount.displayBalance()  // Shows updated balance with interest

// Test checking account with overridden methods
println("\n--- Checking Account ---")
checkingAccount.displayBalance() // Shows monthly fee
checkingAccount.withdraw(800.0) // Shows overdraft warning
checkingAccount.applyMonthlyFee() // Applies monthly fee
checkingAccount.displayBalance()  // Shows balance after fee

Interfaces

When to Use

• When you need to define a contract that multiple classes can implement
• When you want to ensure certain methods are available in a class
• When you need to support multiple inheritance of behavior

Practical Examples

// ===========================================
// INTERFACE BASICS EXAMPLE
// ===========================================

// Interface defines what methods a class MUST have
// Think of it as a "contract" or "promise"
interface Drivable {
    // Any class that implements Drivable MUST have these methods
    fun drive()
    fun stop()
    fun getSpeed(): Int
}

interface Flyable {
    fun fly()
    fun land()
    fun getAltitude(): Int
}

interface Swimmable {
    fun swim()
    fun dive()
    fun getDepth(): Int
}

// ===========================================
// IMPLEMENTING SINGLE INTERFACE
// ===========================================

// Car implements only the Drivable interface
class Car : Drivable {
    private var currentSpeed: Int = 0
    private var isEngineRunning: Boolean = false
    
    // MUST implement all methods from Drivable interface
    override fun drive() {
        if (isEngineRunning) {
            currentSpeed = 60
            println("Car is driving at $currentSpeed mph")
        } else {
            println("Cannot drive - engine is not running!")
        }
    }
    
    override fun stop() {
        currentSpeed = 0
        println("Car has stopped")
    }
    
    override fun getSpeed(): Int {
        return currentSpeed
    }
    
    // Additional methods specific to cars
    fun startEngine() {
        isEngineRunning = true
        println("Car engine started")
    }
    
    fun turnOffEngine() {
        isEngineRunning = false
        currentSpeed = 0
        println("Car engine turned off")
    }
}

// ===========================================
// IMPLEMENTING MULTIPLE INTERFACES
// ===========================================

// Duck can implement multiple interfaces
// This gives it the behavior of multiple different types
class Duck : Drivable, Flyable, Swimmable {
    private var currentSpeed: Int = 0
    private var currentAltitude: Int = 0
    private var currentDepth: Int = 0
    private var isFlying: Boolean = false
    private var isSwimming: Boolean = false
    
    // Implement Drivable interface methods
    override fun drive() {
        // Ducks don't really "drive" but we can make them walk
        currentSpeed = 5
        println("Duck is waddling at $currentSpeed mph")
    }
    
    override fun stop() {
        currentSpeed = 0
        println("Duck has stopped waddling")
    }
    
    override fun getSpeed(): Int {
        return currentSpeed
    }
    
    // Implement Flyable interface methods
    override fun fly() {
        isFlying = true
        currentAltitude = 100
        println("Duck is flying at altitude $currentAltitude feet")
    }
    
    override fun land() {
        isFlying = false
        currentAltitude = 0
        println("Duck has landed")
    }
    
    override fun getAltitude(): Int {
        return currentAltitude
    }
    
    // Implement Swimmable interface methods
    override fun swim() {
        isSwimming = true
        currentDepth = 0
        println("Duck is swimming on the surface")
    }
    
    override fun dive() {
        if (isSwimming) {
            currentDepth = 10
            println("Duck is diving to depth $currentDepth feet")
        } else {
            println("Duck must be swimming before diving!")
        }
    }
    
    override fun getDepth(): Int {
        return currentDepth
    }
    
    // Additional methods specific to ducks
    fun quack() {
        println("Duck says: Quack! Quack!")
    }
    
    fun flapWings() {
        if (isFlying) {
            println("Duck is flapping wings while flying")
        } else {
            println("Duck is flapping wings on the ground")
        }
    }
}

// ===========================================
// USING INTERFACES FOR POLYMORPHISM
// ===========================================

// Function that works with ANY Drivable object
fun testDriving(vehicle: Drivable) {
    println("Testing driving capabilities...")
    vehicle.drive()
    println("Current speed: ${vehicle.getSpeed()} mph")
    vehicle.stop()
    println("---")
}

// Function that works with ANY Flyable object
fun testFlying(aircraft: Flyable) {
    println("Testing flying capabilities...")
    aircraft.fly()
    println("Current altitude: ${aircraft.getAltitude()} feet")
    aircraft.land()
    println("---")
}

// Function that works with ANY Swimmable object
fun testSwimming(swimmer: Swimmable) {
    println("Testing swimming capabilities...")
    swimmer.swim()
    swimmer.dive()
    println("Current depth: ${swimmer.getDepth()} feet")
    println("---")
}

// ===========================================
// USING THE INTERFACE-BASED CLASSES
// ===========================================

println("=== INTERFACE IMPLEMENTATION EXAMPLE ===")

// Create objects
val car = Car()
val duck = Duck()

// Test car (implements only Drivable)
println("--- Testing Car ---")
car.startEngine()
testDriving(car)  // Car can be used anywhere a Drivable is expected
car.turnOffEngine()

// Test duck (implements multiple interfaces)
println("\n--- Testing Duck ---")
duck.quack()
testDriving(duck)   // Duck can be used as a Drivable
testFlying(duck)    // Duck can be used as a Flyable
testSwimming(duck)  // Duck can be used as a Swimmable

// Show how interfaces enable polymorphism
println("\n=== POLYMORPHISM EXAMPLE ===")
val drivableObjects: List = listOf(car, duck)
val flyableObjects: List = listOf(duck)
val swimmableObjects: List = listOf(duck)

println("All drivable objects:")
for (obj in drivableObjects) {
    testDriving(obj)
}

println("All flyable objects:")
for (obj in flyableObjects) {
    testFlying(obj)
}

Compose Basics

When to Use

• When building new Android apps
• When you want to write UI code in Kotlin
• When you need a more modern approach to Android development
• When you want to create responsive UIs that update automatically

A Few Examples

// Basic text display
fun Greeting() {
    Text("Hello, world!")//notice the text does not have brackets {..}
}

// Interactive button
fun Counter() {
    var count by remember { mutableStateOf(0) }
    
    Column {
        Text("Count: $count")
        Button(onClick = { count++ }) {
            Text("Increment")
        }
    }
}

// Layout with multiple elements
fun ProfileCard(name: String, role: String) {
    Column (modifier = Modifier.padding(16.dp))  // Notice the column here has (...) this is calling parameters
    //The curly braces here is a trailing lambda passed as the last paremeter of the function.  In Compose, that trailing lambda is the content block (sometimes called a content lambda or slot).
    {
        Text(name, style = MaterialTheme.typography.h5)
        Text(role, style = MaterialTheme.typography.body1)
        Button(onClick = { /* Handle click */ }) {  //notice the button does have brackets {...}
            Text("Contact")
        }
    }
}

What These Examples Are Doing

Here’s what each snippet does in plain terms:

• Greeting: A minimal composable that only shows the text "Hello, world!" on the screen. There are no parameters and no child elements—just one Text call.
• Counter: A small interactive example. It uses remember { mutableStateOf(0) } to keep a number in memory. The screen shows "Count: 0" (or whatever the current count is) and a button labeled "Increment." Each time you tap the button, count++ runs, the count updates, and Compose redraws the UI so the new number appears. This is a simple example of state driving the UI.
• ProfileCard: A composable that takes a name and role as parameters. It puts them in a Column (so they stack vertically), with the name in a larger heading style and the role in body text, plus a "Contact" button at the bottom. So you can reuse the same card for different people by passing different names and roles.

Why Some Composables Use Brackets and Others Don't

The difference comes down to whether the composable can contain children:

Composables Without a Content Lambda → Just (...)

Text("Hello World")

• Text doesn't expect child composables.
• It just draws some text, and its parameters (text, modifier, style, etc.) are enough.
• Therefore, you only pass arguments in parentheses.

Composables With a Content Lambda → (...){ ... }

Button(onClick = { /* do something */ }) {
            Text("Click Me")
        }

• Button is a container composable.
• It needs:
  • Parameters (like onClick) → go in the (...).
  • Child content (UI inside the button, like Text) → goes in the trailing { ... } lambda.
• That trailing lambda is called the content slot or content lambda.

Why This Matters

Think of it like HTML:

• Text(...) is like <span>Hello</span> → no nested tags.
• Button(...){ ... } is like <button><span>Click Me</span></button> → it wraps other UI elements.

Compose vs. Traditional Android

When to Use

• Use Compose for new projects or modernizing existing apps
• Use traditional XML layouts when maintaining older apps
• Use Compose when you want to write UI code in Kotlin

Practical Examples

// Traditional XML approach
<TextView
    android:id="@+id/textView"
    android:text="Hello, world!"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content" />

// Traditional Kotlin approach
val textView = findViewById<TextView>(R.id.textView)
textView.text = "Hello, world!"

// Compose approach
fun Greeting() {
    Text("Hello, world!")
}

What These Three Approaches Are Doing

All three snippets show "Hello, world!" on the screen, but in different ways:

• Traditional XML: The first block is an XML layout file. It defines a TextView with an id and the text "Hello, world!". The layout and the text are declared in XML, separate from your Kotlin code.
• Traditional Kotlin: The second block is Kotlin code that runs after the screen is built. It finds the TextView by its id (findViewById) and then sets its text. So you have two steps: define the UI in XML, then change it from Kotlin.
• Compose approach: The third block is a Compose function. It describes the UI directly in Kotlin: when Greeting() is called, it draws a Text that says "Hello, world!". There is no separate XML file and no findViewById—just one function that builds the UI.

Quick Reference of Composable Function Components

When to Use

• When you need to create any part of your app's UI
• When you want to display text, buttons, or other UI elements
• When you need to create reusable UI components
• When you want to build responsive layouts

Practical Example

This is a small example; we will go much deeper into composable functions as we continue through this book. In this example we have a function named MainScreen that creates a Box that contains a Column. The column calls Greeting three times; Greeting displays a line of text. Greeting can take a value for name or use a default value, and it can take an optional modifier for extra styling.

Note about Callback Parameters: When you need to handle user interactions (like button clicks, text input changes, etc.), you use callback parameters. These are lambda functions (function types) that get called when the interaction occurs. For example, a Button composable uses onClick: () -> Unit as a callback parameter to handle click events. We'll explore interactive composables with callbacks in more detail in later chapters.

@Composable
fun MainScreen() {
    Box(modifier = Modifier.fillMaxSize()) {
        Column(
            modifier = Modifier
                .fillMaxSize()
                .padding(50.dp),
            horizontalAlignment = Alignment.CenterHorizontally
        ) {
            // Demonstrates different ways to use the Greeting composable:
            Greeting()  // Uses default values
            Greeting(name = "Android")  // Custom name
            Greeting(
                name = "Developer",
                modifier = Modifier.padding(24.dp) //dp stands for density pixels
            )
        }
    }
}


@Composable
fun Greeting(
    modifier: Modifier = Modifier,
    name: String = "Compose"
    
) {
    Text(
        text = "Hello, $name!",
        modifier = modifier.padding(16.dp),
        style = TextStyle(
            fontSize = 24.sp, //sp stands for Scale-independent Pixels
            fontWeight = FontWeight.Bold
        ),
        color = MaterialTheme.colorScheme.primary
    )
}

What This Example Is Doing

Here’s a simple walkthrough of what the code above does, step by step.

• MainScreen is the top-level composable. It creates a Box that fills the screen, then puts a Column inside it. The column fills the space and has 50 density-independent pixels of padding on all sides, and it centers its children horizontally.
• Inside that column, three Greeting composables are called:
  • Greeting() — No arguments, so it uses the default name "Compose". The user sees: Hello, Compose!
  • Greeting(name = "Android") — Passes a custom name. The user sees: Hello, Android!
  • Greeting(name = "Developer", modifier = Modifier.padding(24.dp)) — Passes both a name and extra padding (24 dp) around that text. The user sees: Hello, Developer! with more space around it.
• Greeting is a reusable composable that shows one line of text. It takes an optional modifier (defaults to no extra styling) and a name (defaults to "Compose"). It displays "Hello, $name!" with 16 dp padding, bold 24 sp text, and the theme’s primary color. So the same function can show different messages depending on the parameters you pass.

In short: MainScreen sets up the layout (a centered column), and Greeting is the small building block that displays each greeting. Using parameters like name and modifier makes Greeting reusable without copying and pasting code.

When to Use

• When you need to organize multiple UI elements on a screen
• When you want to create structured, visually appealing layouts
• When you need to position elements relative to each other
• When you want to create responsive designs that adapt to different screen sizes

You also use something called a Modifier with layouts (and their children) to control appearance and positioning, like adding padding, setting size, alignment, or background color. We'll talk about modifiers in more detail later in the book, but for now, just see how they are used in the code examples.

Column Layout

When to Use

• When you need to stack elements vertically
• When creating forms or lists
• When displaying content that flows from top to bottom
• When you want to create a vertical navigation menu

Practical Example

@Composable
fun ColumnExample() {
    Column(
        modifier = Modifier
            .padding(16.dp)  // Add space around the column
            .border(2.dp, MaterialTheme.colorScheme.secondary)  // Add a border
    ) {
        Text("Part 1")
        Text("Part 2")
        Text("Part 3")
        Text("Part 4")
        Text("Part 5")
    }
}

In this example, everything inside the Column is stacked vertically. The Modifier.padding(16.dp) adds space around the column so its content doesn't touch the edge of the screen. The Modifier.border(2.dp, MaterialTheme.colorScheme.secondary) adds a border around the column to make it easier to see its size and position.

Row Layout

When to Use

• When you need to arrange elements horizontally
• When creating navigation bars or toolbars
• When displaying items side by side
• When you want to create a horizontal list of options

Practical Example

@Composable
fun RowExample() {
    Row(
        modifier = Modifier
            .padding(16.dp)  // Add space around the row
            .border(2.dp, MaterialTheme.colorScheme.tertiary)  // Add a border
    ) {
        Text("Part 1")
        Spacer(modifier = Modifier.width(20.dp))  // Add space between elements
        Text("Part 2")
        Spacer(modifier = Modifier.width(20.dp))
        Text("Part 3")
        Spacer(modifier = Modifier.width(20.dp))
        Text("Part 4")
        Spacer(modifier = Modifier.width(20.dp))
        Text("Part 5")
    }
}

In the RowExample, the text elements are displayed side by side. The Spacer adds horizontal space between them. The Modifier.padding(16.dp) adds space around the row so its content doesn't touch the edge of the screen. The Modifier.border(2.dp, MaterialTheme.colorScheme.tertiary) adds a border around the row to make it easier to see its size and position.

Box Layout

When to Use

• When you need to overlay elements on top of each other
• When you want to position elements precisely within a container
• When you need to layer UI elements
• When you want to create complex layouts with overlapping components

Practical Example

@Composable
fun BoxExample() {
    Box(
        modifier = Modifier
            .size(300.dp)  // Set the size of the box
            .padding(16.dp)  // Add space around the box
            .border(2.dp, MaterialTheme.colorScheme.primary)  // Add a border
    ) {
        Text(
            text = "This is the top part of a box",
            modifier = Modifier.align(Alignment.TopCenter)  // Position at the top center
        )
        Text(
            text = "This is the middle part of a box",
            modifier = Modifier.align(Alignment.Center)  // Position in the center
        )
        Text(
            text = "This is the bottom part of a box",
            modifier = Modifier.align(Alignment.BottomCenter)  // Position at the bottom center
        )
    }
}

In the BoxExample, the three text elements are displayed on top of each other. The Modifier.size(300.dp) sets the size of the box. The Modifier.padding(16.dp) adds space around the box so its content doesn't touch the edge of the screen. The Modifier.border(2.dp, MaterialTheme.colorScheme.primary) adds a border around the box to make it easier to see its size and position.

How these examples render

The image below shows what the three layout examples look like when you run them: a column with "Part 1" through "Part 5" stacked vertically, a row with "Part 1" through "Part 5" side by side with space between them, and a box with three lines of text at the top, center, and bottom. The snippets above are only part of the code; to see and run the full project, go to my GitHub page and open the chapter4 layout_code.kt file.

Your First Column

When to Use

• When you need to stack elements vertically
• When creating forms or lists
• When displaying content that flows from top to bottom
• When you want to create a vertical navigation menu

Practical Example

@Composable
fun ColumnExample() {
    Column(
        modifier = Modifier.padding(16.dp)  // Add space around the column
    ) {
        Text("Welcome to Compose!")  // First text element
        Text("Let's build a layout.") // Second text element
    }
}

What's happening here:

• The Column is like a container that holds everything together
• Modifier.padding(16.dp) adds some breathing room around the edges
• The two Text elements stack on top of each other, just like blocks

Centering Your Column Items

When to Use

• When you want to center items horizontally
• When creating a balanced, symmetrical layout
• When you want to create a more polished look
• When you need to align items in the middle of the screen

Practical Example

@Composable
fun CenteredColumn() {
    Column(
        modifier = Modifier.fillMaxWidth(),  // Make the column as wide as the screen
        horizontalAlignment = Alignment.CenterHorizontally  // Center items horizontally
    ) {
        Text("Centered Item 1")  // First centered text
        Text("Centered Item 2")  // Second centered text
    }
}

This code does two important things:

• fillMaxWidth() makes the Column stretch across the whole screen
• horizontalAlignment = Alignment.CenterHorizontally centers everything inside

Adding Space Between Items

When to Use

• When you need consistent spacing between items
• When you want to create a more readable layout
• When you need to separate different sections of content
• When you want to create a more visually appealing design

Practical Example

This is one way to add space between items. Using verticalArrangement = Arrangement.spacedBy(12.dp) adds exactly 12 units of space between each item automatically. Think of it like adding invisible spacers between your blocks.

@Composable
fun SpacedColumn() {
    Column(
        modifier = Modifier.padding(16.dp),  // Add space around the column
        verticalArrangement = Arrangement.spacedBy(12.dp)  // Add space between items
    ) {
        Text("Item One")    // First item
        Text("Item Two")    // Second item
        Text("Item Three")  // Third item
    }
}

Another way to add space between items is to use the Spacer composable. You can also add Spacer composables between items when you want different amounts of space in different places. For example:

Column {
    Text("First Item")
    Spacer(modifier = Modifier.height(20.dp))  // Adds 20 units of space
    Text("Second Item")
    Spacer(modifier = Modifier.height(10.dp))  // Adds 10 units of space
    Text("Third Item")
}

What This Second Example Is Doing

This version uses Spacer composables instead of Arrangement.spacedBy. The column shows "First Item," then an invisible Spacer that is 20 dp tall, then "Second Item," then a 10 dp Spacer, then "Third Item." So you get a different amount of space between the first and second items (20 dp) than between the second and third (10 dp). That gives you more control when you want different spacing in different places.

Making Your Column Look Fancy

When to Use

• When you want to create a visually appealing UI
• When you need to highlight important content
• When you want to create a card-like container
• When you need to create a more polished, professional look

Practical Example

@Composable
fun StyledColumn() {
    // First, let's set up our Column with some basic styling
    Column(
        // This modifier chain sets up the Column's appearance
        modifier = Modifier
            .fillMaxWidth()  // Makes the Column as wide as the screen
            .padding(16.dp)  // Adds space around the edges
            .background(     // Adds a background color
                color = MaterialTheme.colorScheme.primaryContainer,
                shape = RoundedCornerShape(16.dp)  // Makes the corners rounded
            )
            .border(        // Adds a border around the Column
                width = 2.dp,
                color = MaterialTheme.colorScheme.primary,
                shape = RoundedCornerShape(16.dp)
            )
            .padding(16.dp),  // Adds more space inside the Column
        
        // Center everything horizontally
        horizontalAlignment = Alignment.CenterHorizontally,
        // Add space between items
        verticalArrangement = Arrangement.spacedBy(8.dp)
    ) {
        // First item: A large, bold title
        Text(
            text = "Styled Column",
            style = TextStyle(
                fontSize = 24.sp,        // Makes the text bigger
                fontWeight = FontWeight.Bold,  // Makes it bold
                color = MaterialTheme.colorScheme.primary  // Uses the primary color
            ),
            modifier = Modifier.padding(bottom = 8.dp)  // Adds space below
        )
        
        // Second item: A smaller, regular text
        Text(
            text = "This is a styled text",
            style = TextStyle(
                fontSize = 16.sp,  // Smaller text size
                color = MaterialTheme.colorScheme.onPrimaryContainer  // Different color
            )
        )
        
        // Third item: A button
        Button(
            onClick = { /* TODO: Add click action */ },
            modifier = Modifier.padding(top = 8.dp)  // Adds space above
        ) {
            Text("Styled Button")
        }
        
        // Fourth item: A colored box with text
        Box(
            modifier = Modifier
                .size(100.dp)  // Makes the box 100x100 units
                .background(    // Adds a different background color
                    color = MaterialTheme.colorScheme.secondaryContainer,
                    shape = RoundedCornerShape(8.dp)  // Rounded corners
                )
                .padding(8.dp),  // Adds space inside the box
            contentAlignment = Alignment.Center  // Centers the text inside
        ) {
            Text(
                text = "Box",
                color = MaterialTheme.colorScheme.onSecondaryContainer
            )
        }
    }
}

Let's understand what each part does:

The Column Setup

• fillMaxWidth() makes the Column stretch across the screen
• padding(16.dp) adds space around the edges
• background() gives it a nice background color with rounded corners
• border() adds a colored border around it

The Items Inside

• Title Text: Big, bold text in the primary color
• Regular Text: Smaller text in a different color
• Button: A clickable button with text
• Box: A colored square with centered text

Spacing and Alignment

• horizontalAlignment = Alignment.CenterHorizontally centers everything
• verticalArrangement = Arrangement.spacedBy(8.dp) adds space between items
• Individual padding() modifiers add extra space where needed

How these examples render

The image below shows what the column examples look like when you run them: a simple column, a centered column, a spaced column, and the styled column with title, text, button, and colored box. The snippets above are only part of the code; to see and run the full project, go to my GitHub page and open the chapter4 column_code.kt file.

Let's Start Simple: A Basic Row

When to Use

• When you need to arrange elements horizontally
• When creating navigation bars or toolbars
• When displaying items side by side
• When you want to create a horizontal list of options

Practical Example

@Composable
fun RowExample() {
    Row(
        modifier = Modifier
            .padding(16.dp)  // Outer padding
            .border(width = 1.dp, color = Color.Blue)  // Add a border
            .padding(16.dp)  // Inner padding between elements and border
    ) {
        Text("First")
        Text("Second")
        Text("Third")
        Text("Fourth")
        Text("Fifth")
    }
}

What's happening here?

• We create a row with some space around it (that's what padding does - like margins in a notebook)
• We add a blue border so we can see where our row is (like drawing a box around our words)
• We put five words inside: "First", "Second", "Third", "Fourth", and "Fifth"

Adding Space Between Items

When to Use

• When you need consistent spacing between items
• When you want to create a more readable layout
• When you need to separate different sections of content
• When you want to create a more visually appealing design

Using Spacers (Like Adding Invisible Bookends)

This is one way to add space between items. Using Spacer composables between items when you want different amounts of space in different places. For example:

@Composable
fun RowWithSpacer() {
    Row(modifier = Modifier.padding(16.dp)) {
        Text("First")
        Spacer(modifier = Modifier.width(10.dp))  // Add 10dp of space
        Text("Second")
        Spacer(modifier = Modifier.width(10.dp))  // Add 10dp of space
        Text("Third")
        Spacer(modifier = Modifier.width(10.dp))  // Add 10dp of space
        Text("Fourth")
        Spacer(modifier = Modifier.width(10.dp))  // Add 10dp of space
        Text("Fifth")
    }
}

Here, we're adding invisible spacers between our words. Each spacer is exactly 10dp wide (dp is just a measurement unit - like inches or centimeters, but for screens).

Spreading Things Out Automatically

This is another way to add space between items. Using Arrangement.SpaceBetween to spread items evenly across the row. For example:

@Composable
fun RowWithArrangement() {
    Row(
        modifier = Modifier
            .fillMaxWidth()  // Make the row as wide as the screen
            .padding(16.dp),  // Add space around the row
        horizontalArrangement = Arrangement.SpaceBetween  // Spread items evenly
    ) {
        Text("First")
        Text("Second")
        Text("Third")
        Text("Fourth")
        Text("Fifth")
    }
}

This time, instead of adding specific spaces, we tell the row to spread things out evenly across the whole width. It's like telling five people to spread out equally across a room!

Making Things Line Up Vertically

When to Use

• When you want to align items at the top, middle, or bottom
• When creating a more polished, professional look
• When you need to create a balanced, symmetrical layout
• When you want to create a more visually appealing design

Lining Things Up

In these examples, we make the row 100dp tall.

Top Alignment

@Composable
fun RowTopAlignment() {
    Row(
        modifier = Modifier
            .height(100.dp)  // Set the height of the row
            .fillMaxWidth()  // Make the row as wide as the screen
            .border(width = 1.dp, color = Color.Blue)  // Add a border
            .padding(16.dp),  // Add space around the row
        verticalAlignment = Alignment.Top  // Align items at the top
    ) {
        Text("First")
        Spacer(modifier = Modifier.width(16.dp))  // Add space between items
        Text("Second")
        Spacer(modifier = Modifier.width(16.dp))
        Text("Third")
        Spacer(modifier = Modifier.width(16.dp))
        Text("Fourth")
        Spacer(modifier = Modifier.width(16.dp))
        Text("Fifth")
    }
}

What this does: The row is 100 dp tall with a blue border. verticalAlignment = Alignment.Top pulls all the text and spacers to the top of that row, so "First," "Second," "Third," "Fourth," and "Fifth" sit on the top edge instead of in the middle or bottom.

Center Alignment

@Composable
fun RowCenterAlignment() {
    Row(
        modifier = Modifier
            .height(100.dp)  // Set the height of the row
            .fillMaxWidth()  // Make the row as wide as the screen
            .border(width = 1.dp, color = Color.Blue)  // Add a border
            .padding(16.dp),  // Add space around the row
        verticalAlignment = Alignment.CenterVertically  // Align items in the center
    ) {
        Text("First")
        Spacer(modifier = Modifier.width(16.dp))  // Add space between items
        Text("Second")
        Spacer(modifier = Modifier.width(16.dp))
        Text("Third")
        Spacer(modifier = Modifier.width(16.dp))
        Text("Fourth")
        Spacer(modifier = Modifier.width(16.dp))
        Text("Fifth")
    }
}

What this does: Same row size and border, but verticalAlignment = Alignment.CenterVertically centers all the items vertically inside the row. The five words and the spacers between them sit in the middle of the 100 dp height.

Bottom Alignment

@Composable
fun RowBottomAlignment() {
    Row(
        modifier = Modifier
            .height(100.dp)  // Set the height of the row
            .fillMaxWidth()  // Make the row as wide as the screen
            .border(width = 1.dp, color = Color.Blue)  // Add a border
            .padding(16.dp),  // Add space around the row
        verticalAlignment = Alignment.Bottom  // Align items at the bottom
    ) {
        Text("First")
        Spacer(modifier = Modifier.width(16.dp))  // Add space between items
        Text("Second")
        Spacer(modifier = Modifier.width(16.dp))
        Text("Third")
        Spacer(modifier = Modifier.width(16.dp))
        Text("Fourth")
        Spacer(modifier = Modifier.width(16.dp))
        Text("Fifth")
    }
}

What this does: Same row again, but verticalAlignment = Alignment.Bottom pushes all the items to the bottom of the row. The five words sit on the bottom edge of the 100 dp tall row.

How these examples render

The image below shows what the row examples look like when you run them: a basic row of five words, a row with spacers between items, a row with items spread across the width, and the three alignment variants (top, center, bottom). The snippets above are only part of the code; to see and run the full project, go to my GitHub page and open the chapter4 row_code.kt file.

Let's Start Simple: A Basic Box

When to Use

• When you need to layer elements on top of each other
• When you want to position elements precisely within a container
• When you need to create complex layouts with overlapping components
• When you want to create a more visually appealing design

Practical Example

@Composable
fun BoxExample() {
    Box(modifier = Modifier
        .size(150.dp)  // Set the size of the box
        .padding(16.dp)  // Add space around the box
        .border(width = 1.dp, color = Color.Blue)  // Add a border
    ) {
        Text(
            text = "Top Text",
            modifier = Modifier.align(Alignment.TopCenter)  // Position at the top center
        )
        Text(
            text = "Bottom Text",
            modifier = Modifier.align(Alignment.BottomCenter)  // Position at the bottom center
        )
    }
}

Let's break down what this does:

• Creates a box that's 150 by 150 units big (like a square sticky note)
• Adds some space around it (16 units of padding)
• Adds a blue border so we can see where the box is
• Puts "Top Text" at the top center (like sticking it to the top of the note)
• Puts "Bottom Text" at the bottom center (like sticking it to the bottom)

Making a Box Look Pretty

When to Use

• When you want to create a visually appealing UI
• When you need to highlight important content
• When you want to create a card-like container
• When you need to create a more polished, professional look

Practical Example

@Composable
fun ColoredBox() {
    Box(
        modifier = Modifier
            .size(200.dp)  // Set the size of the box
            .padding(16.dp)  // Add space around the box
            .background(  // Add a background color
                Color(0xFF673AB7),  // Purple color
                shape = androidx.compose.foundation.shape.RoundedCornerShape(24.dp)  // Rounded corners
            )
            .border(  // Add a border
                width = 1.dp,
                color = Color(0xFF512DA8),  // Darker purple
                shape = androidx.compose.foundation.shape.RoundedCornerShape(24.dp)  // Rounded corners
            )
    ) {
        Text(
            "Box Content",
            color = Color.White,  // White text
            modifier = Modifier.align(Alignment.Center)  // Center the text
        )
    }
}

This is like:

• Taking a box and making it 200 units big
• Adding some breathing room (16 units of padding)
• Painting it in a nice purple color (that's what the Color(0xFF673AB7) does)
• Making the corners round (like a rounded rectangle)
• Adding a darker purple border to make it pop
• Putting white text right in the middle so it's easy to read against the purple

Putting One Thing On Top of Another

When to Use

• When you need to overlay elements on top of each other
• When you want to position elements precisely within a container
• When you need to layer UI elements
• When you want to create complex layouts with overlapping components

Practical Example

@Composable
fun BoxWithOverlay() {
    Box(
        modifier = Modifier
            .size(200.dp)  // Set the size of the box
            .padding(16.dp)  // Add space around the box
            .background(Color.Cyan)  // Add a cyan background
    ) {
        Text(
            text = "Overlay",
            color = Color.White,  // White text
            modifier = Modifier
                .align(Alignment.BottomEnd)  // Position at the bottom right
                .background(Color.DarkGray)  // Dark gray background
                .padding(4.dp)  // Add space around the text
        )
    }
}

Here's what's happening:

• We make a bigger cyan (light blue) box that's 200 units big
• We add some space around it (16 units of padding)
• We add the word "Overlay" on top of it
• We put that word in the bottom-right corner
• We give the word a dark gray background and some space around it (padding) so it's easy to read

How these examples render

The image below shows what the three box examples look like when you run them: a basic box with "Top Text" and "Bottom Text" at the top and bottom, a purple rounded box with centered "Box Content," and a cyan box with an "Overlay" label in the bottom-right corner. The snippets above are only part of the code; to see and run the full project, go to my GitHub page and open the chapter4 box_code.kt file.