The Kotlin if statement is a conditional control structure that executes a block of code only when a specified condition evaluates to true. Unlike many other programming languages, Kotlin if statements can function both as statements (performing actions) and as expressions (returning values).
val userAge = 25
if (userAge >= 18) {
println("User is eligible for adult content")
}
In this example, the if statement checks whether the user’s age meets the minimum requirement. The condition userAge >= 18
must evaluate to a boolean value (true or false).
The basic Kotlin if else syntax follows this pattern:
if (condition) {
// Code executed when condition is true
} else {
// Code executed when condition is false
}
The condition must be a boolean expression. When the condition is true, the if block executes; when false, the else block executes. Only one block will ever execute in a single if-else evaluation.
Kotlin if else statements rely on boolean conditions created using comparison operators:
==
(equal to)!=
(not equal to)>
(greater than)<
(less than)>=
(greater than or equal to)<=
(less than or equal to)val temperature = 32
val humidity = 75
if (temperature > 30 && humidity > 70) {
println("Weather is hot and humid")
} else {
println("Weather conditions are moderate")
}
One of Kotlin’s most powerful features is treating if else as an expression. Unlike traditional statements that just execute code, expressions return values that can be assigned to variables or used in calculations.
val userRole = "admin"
// Traditional statement approach
var accessLevel: String
if (userRole == "admin") {
accessLevel = "full"
} else {
accessLevel = "limited"
}
// Expression approach (preferred in Kotlin)
val accessLevel = if (userRole == "admin") "full" else "limited"
The expression approach is more concise and functional, eliminating the need for mutable variables.
When using Kotlin if as expression, the else branch becomes mandatory. This ensures that the expression always returns a value, preventing potential runtime errors.
val score = 85
// This works - complete expression with else
val grade = if (score >= 90) "A" else "B"
// This would cause compilation error - missing else
// val grade = if (score >= 90) "A"
Kotlin if else expressions can contain multiple statements in each branch. The last expression in each block becomes the returned value.
val gameScore = 2500
val playerLevel = if (gameScore > 2000) {
println("Calculating advanced level...")
val baseLevel = gameScore / 1000
val bonusPoints = gameScore % 1000
baseLevel + (bonusPoints / 100) // This value is returned
} else {
println("Calculating beginner level...")
gameScore / 500 // This value is returned
}
For handling multiple conditions, Kotlin if else if statements create a ladder-like structure where conditions are evaluated sequentially until one matches.
val batteryLevel = 45
val batteryStatus = if (batteryLevel >= 80) {
"Excellent"
} else if (batteryLevel >= 60) {
"Good"
} else if (batteryLevel >= 40) {
"Fair"
} else if (batteryLevel >= 20) {
"Low"
} else {
"Critical"
}
println("Battery status: $batteryStatus")
Each condition is checked in order. Once a condition evaluates to true, that block executes and the remaining conditions are skipped.
Nested if statements in Kotlin allow you to place if conditions inside other if blocks, creating complex decision trees for sophisticated logic.
val userType = "premium"
val subscriptionActive = true
val paymentCurrent = true
if (userType == "premium") {
if (subscriptionActive) {
if (paymentCurrent) {
println("Access granted to all premium features")
} else {
println("Please update payment method")
}
} else {
println("Please renew your subscription")
}
} else {
println("Upgrade to premium for full access")
}
While powerful, excessive nesting can reduce code readability. Consider refactoring deeply nested conditions into separate functions or using when expressions for better maintainability.
Kotlin supports logical operators to combine multiple conditions:
&&
(logical AND)||
(logical OR)!
(logical NOT)val age = 25
val hasLicense = true
val hasInsurance = true
if (age >= 18 && hasLicense && hasInsurance) {
println("Eligible to drive")
} else if (age >= 18 && hasLicense && !hasInsurance) {
println("Need insurance to drive legally")
} else if (age >= 18 && !hasLicense) {
println("Need to obtain a driving license")
} else {
println("Too young to drive")
}
For multiple condition checks, Kotlin when expression often provides cleaner syntax than lengthy if-else-if chains. When expressions are particularly useful for matching against multiple values or ranges.
val dayOfWeek = 3
// Using if-else-if
val dayType = if (dayOfWeek == 1 || dayOfWeek == 7) {
"Weekend"
} else if (dayOfWeek in 2..6) {
"Weekday"
} else {
"Invalid day"
}
// Using when (cleaner)
val dayType = when (dayOfWeek) {
1, 7 -> "Weekend"
in 2..6 -> "Weekday"
else -> "Invalid day"
}
When expressions excel at checking ranges and collection membership:
val studentGrade = 'B'
val description = when (studentGrade) {
'A' -> "Excellent performance"
'B' -> "Good performance"
'C' -> "Average performance"
in 'D'..'F' -> "Needs improvement"
else -> "Invalid grade"
}
fun authenticateUser(username: String, password: String, isActive: Boolean): String {
return if (username.isNotEmpty() && password.length >= 8) {
if (isActive) {
"Authentication successful"
} else {
"Account is deactivated"
}
} else {
"Invalid credentials"
}
}
fun checkAppPermissions(hasCamera: Boolean, hasLocation: Boolean, hasStorage: Boolean): String {
val permissionCount = listOf(hasCamera, hasLocation, hasStorage).count { it }
return if (permissionCount == 3) {
"All permissions granted - full functionality available"
} else if (permissionCount >= 2) {
"Most permissions granted - limited functionality"
} else if (permissionCount == 1) {
"Minimal permissions - basic functionality only"
} else {
"No permissions granted - app functionality restricted"
}
}
fun calculateDiscount(totalAmount: Double, customerType: String, isFirstPurchase: Boolean): Double {
val baseDiscount = if (customerType == "premium") {
0.15
} else if (customerType == "regular") {
0.10
} else {
0.05
}
val finalDiscount = if (isFirstPurchase) {
baseDiscount + 0.05 // Additional 5% for first purchase
} else {
baseDiscount
}
return totalAmount * (1 - finalDiscount)
}
import kotlin.random.Random
fun main() {
// Sample student data
val students = listOf(
Student("Alice", 92),
Student("Bob", 78),
Student("Charlie", 85),
Student("Diana", 67),
Student("Eve", 94)
)
println("=== Student Grade Report ===")
students.forEach { student ->
val grade = calculateGrade(student.score)
val status = if (student.score >= 70) "PASS" else "FAIL"
val recommendation = getRecommendation(student.score)
println("Student: ${student.name}")
println("Score: ${student.score}")
println("Grade: $grade")
println("Status: $status")
println("Recommendation: $recommendation")
println("---")
}
}
data class Student(val name: String, val score: Int)
fun calculateGrade(score: Int): String {
return if (score >= 90) {
"A+"
} else if (score >= 85) {
"A"
} else if (score >= 80) {
"B+"
} else if (score >= 75) {
"B"
} else if (score >= 70) {
"C+"
} else if (score >= 65) {
"C"
} else if (score >= 60) {
"D"
} else {
"F"
}
}
fun getRecommendation(score: Int): String {
return if (score >= 90) {
"Excellent work! Consider advanced courses."
} else if (score >= 80) {
"Good performance! Keep up the effort."
} else if (score >= 70) {
"Satisfactory. Focus on weak areas."
} else if (score >= 60) {
"Additional study required."
} else {
"Needs significant improvement. Consider tutoring."
}
}
Output:
=== Student Grade Report ===
Student: Alice
Score: 92
Grade: A+
Status: PASS
Recommendation: Excellent work! Consider advanced courses.
---
Student: Bob
Score: 78
Grade: B
Status: PASS
Recommendation: Good performance! Keep up the effort.
---
Student: Charlie
Score: 85
Grade: A
Status: PASS
Recommendation: Good performance! Keep up the effort.
---
Student: Diana
Score: 67
Grade: C
Status: FAIL
Recommendation: Additional study required.
---
Student: Eve
Score: 94
Grade: A+
Status: PASS
Recommendation: Excellent work! Consider advanced courses.
---
import java.time.LocalDateTime
import java.time.format.DateTimeFormatter
fun main() {
val account = BankAccount("ACC123456", 1500.0)
// Process various transactions
val transactions = listOf(
Transaction("DEPOSIT", 500.0),
Transaction("WITHDRAWAL", 200.0),
Transaction("WITHDRAWAL", 2000.0), // Should fail
Transaction("TRANSFER", 300.0),
Transaction("DEPOSIT", 1000.0)
)
println("=== Banking Transaction Processor ===")
println("Initial Balance: $${account.balance}")
println("Account: ${account.accountNumber}")
println()
transactions.forEach { transaction ->
val result = processTransaction(account, transaction)
println("Transaction: ${transaction.type} - $${transaction.amount}")
println("Result: $result")
println("New Balance: $${account.balance}")
println("---")
}
// Generate account summary
val summary = generateAccountSummary(account)
println(summary)
}
data class BankAccount(val accountNumber: String, var balance: Double)
data class Transaction(val type: String, val amount: Double)
fun processTransaction(account: BankAccount, transaction: Transaction): String {
val timestamp = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"))
return if (transaction.amount <= 0) {
"FAILED: Invalid amount. Amount must be positive."
} else if (transaction.type == "WITHDRAWAL" || transaction.type == "TRANSFER") {
if (account.balance >= transaction.amount) {
account.balance -= transaction.amount
"SUCCESS: ${transaction.type} processed at $timestamp"
} else {
"FAILED: Insufficient funds. Available: $${account.balance}"
}
} else if (transaction.type == "DEPOSIT") {
account.balance += transaction.amount
"SUCCESS: DEPOSIT processed at $timestamp"
} else {
"FAILED: Unknown transaction type: ${transaction.type}"
}
}
fun generateAccountSummary(account: BankAccount): String {
val status = if (account.balance >= 1000) {
"PREMIUM"
} else if (account.balance >= 500) {
"STANDARD"
} else if (account.balance >= 100) {
"BASIC"
} else {
"MINIMUM"
}
val creditLimit = if (status == "PREMIUM") {
account.balance * 0.5
} else if (status == "STANDARD") {
account.balance * 0.3
} else {
0.0
}
return """
=== Account Summary ===
Account: ${account.accountNumber}
Current Balance: $${account.balance}
Account Status: $status
Available Credit: $${creditLimit}
Account Health: ${if (account.balance > 0) "HEALTHY" else "OVERDRAWN"}
""".trimIndent()
}
Output:
=== Banking Transaction Processor ===
Initial Balance: $1500.0
Account: ACC123456
Transaction: DEPOSIT - $500.0
Result: SUCCESS: DEPOSIT processed at 2025-06-13 14:30:25
New Balance: $2000.0
---
Transaction: WITHDRAWAL - $200.0
Result: SUCCESS: WITHDRAWAL processed at 2025-06-13 14:30:25
New Balance: $1800.0
---
Transaction: WITHDRAWAL - $2000.0
Result: FAILED: Insufficient funds. Available: $1800.0
New Balance: $1800.0
---
Transaction: TRANSFER - $300.0
Result: SUCCESS: TRANSFER processed at 2025-06-13 14:30:25
New Balance: $1500.0
---
Transaction: DEPOSIT - $1000.0
Result: SUCCESS: DEPOSIT processed at 2025-06-13 14:30:25
New Balance: $2500.0
---
=== Account Summary ===
Account: ACC123456
Current Balance: $2500.0
Account Status: PREMIUM
Available Credit: $1250.0
Account Health: HEALTHY
import kotlin.random.Random
fun main() {
val settingsManager = AppSettingsManager()
// Simulate various user actions
println("=== Mobile App Settings Manager ===")
// Check notification permissions
val notificationAccess = checkNotificationPermission(Random.nextBoolean())
println("Notification Permission: $notificationAccess")
// Handle theme settings
val themes = listOf("light", "dark", "auto", "custom")
themes.forEach { theme ->
val themeResult = settingsManager.setTheme(theme)
println("Theme '$theme': $themeResult")
}
println()
// Test privacy settings
val privacyLevels = listOf("public", "friends", "private", "custom")
privacyLevels.forEach { level ->
val privacyResult = settingsManager.setPrivacyLevel(level)
println("Privacy '$level': $privacyResult")
}
println()
// Generate settings summary
val summary = settingsManager.generateSettingsSummary()
println(summary)
}
class AppSettingsManager {
private var currentTheme = "light"
private var privacyLevel = "friends"
private var notificationsEnabled = true
private var locationEnabled = false
fun setTheme(theme: String): String {
return if (theme == "light" || theme == "dark") {
currentTheme = theme
"Theme set to $theme mode successfully"
} else if (theme == "auto") {
currentTheme = theme
"Auto theme enabled - will follow system settings"
} else if (theme == "custom") {
currentTheme = theme
"Custom theme enabled - user preferences applied"
} else {
"Invalid theme option. Available: light, dark, auto, custom"
}
}
fun setPrivacyLevel(level: String): String {
return if (level == "public") {
privacyLevel = level
"Privacy set to public - profile visible to everyone"
} else if (level == "friends") {
privacyLevel = level
"Privacy set to friends only - limited visibility"
} else if (level == "private") {
privacyLevel = level
"Privacy set to private - maximum protection"
} else if (level == "custom") {
privacyLevel = level
"Custom privacy settings applied"
} else {
"Invalid privacy level. Available: public, friends, private, custom"
}
}
fun generateSettingsSummary(): String {
val securityScore = if (privacyLevel == "private") {
100
} else if (privacyLevel == "friends") {
70
} else if (privacyLevel == "custom") {
80
} else {
40
}
val accessibilityFeatures = if (currentTheme == "dark") {
"Enhanced for low-light viewing"
} else if (currentTheme == "auto") {
"Adaptive display based on time"
} else {
"Standard display settings"
}
return """
=== Settings Summary ===
Current Theme: $currentTheme
Privacy Level: $privacyLevel
Security Score: $securityScore/100
Accessibility: $accessibilityFeatures
Notifications: ${if (notificationsEnabled) "Enabled" else "Disabled"}
Recommendation: ${getRecommendation(securityScore)}
""".trimIndent()
}
private fun getRecommendation(score: Int): String {
return if (score >= 90) {
"Excellent security configuration!"
} else if (score >= 70) {
"Good security settings. Consider private mode for better protection."
} else if (score >= 50) {
"Moderate security. Review privacy settings."
} else {
"Low security score. Enable private mode and review permissions."
}
}
}
fun checkNotificationPermission(hasPermission: Boolean): String {
return if (hasPermission) {
"Granted - App can send notifications"
} else {
"Denied - Please enable in system settings for full functionality"
}
}
Output:
=== Mobile App Settings Manager ===
Notification Permission: Granted - App can send notifications
Theme 'light': Theme set to light mode successfully
Theme 'dark': Theme set to dark mode successfully
Theme 'auto': Auto theme enabled - will follow system settings
Theme 'custom': Custom theme enabled - user preferences applied
Privacy 'public': Privacy set to public - profile visible to everyone
Privacy 'friends': Privacy set to friends only - limited visibility
Privacy 'private': Privacy set to private - maximum protection
Privacy 'custom': Custom privacy settings applied
=== Settings Summary ===
Current Theme: custom
Privacy Level: custom
Security Score: 80/100
Accessibility: Standard display settings
Notifications: Enabled
Recommendation: Good security settings. Consider private mode for better protection.
Understanding Kotlin if else statements is crucial for effective Android development and Kotlin programming. The unique expression-based approach of Kotlin conditional statements offers more flexibility and functional programming benefits compared to traditional imperative languages.
Remember these essential points:
Kotlin if else can function as both statements and expressions
When using if as expression, the else branch is mandatory
Nested if statements should be used judiciously to maintain code readability
When expressions often provide cleaner alternatives to complex if-else-if chains
Logical operators (&&
, ||
, !
) enable sophisticated condition combinations