Kotlin Exception Handling: Tame Errors Like a Pro in 2025!
Handle runtime issues with Kotlin’s exception handling. This 2025 guide provides practical examples, a utility class, and tips to make your code crash-proof!
Key Constructs
- 🔍 try: Wraps risky code, paired with catch or finally.
- 🛡️ catch: Handles specific exceptions from try.
- ✅ finally: Runs cleanup tasks, exception or not.
- 💥 throw: Triggers custom exceptions.
Exception Types ⚠️🔍
Kotlin exceptions are unchecked, inheriting from Throwable (Error or Exception). Key types:
- ➗ ArithmeticException: Division by zero.
- 📏 ArrayIndexOutOfBoundsException: Invalid array index.
- 🔄 ClassCastException: Invalid type casting.
- 📁 FileNotFoundException: Non-existent file access.
- 💾 IOException: Input/output errors.
- ⏸️ InterruptedException: Thread interruption.
- 🚫 NullPointerException: Null object access.
- 🔒 SecurityException: Security violations.
- 🔢 NumberFormatException: Invalid number conversion.
- 📉 IndexOutOfBoundsException: Invalid list/array index.
- 🌐 RemoteException: Remote service errors.
- ⚠️ IllegalStateException: Invalid state operations.
- 🚫 UnsupportedOperationException: Unsupported operations.
- 💥 RuntimeException: General runtime errors.
- 🔍 NoSuchElementException: Missing collection elements.
- 🔄 ConcurrentModificationException: Collection modified during iteration.
ExceptionUtils: Logging Utility 🐞📝
Log exceptions consistently with ExceptionUtils.
try {
val str: String? = null
val length = str!!.length // 🚫 NullPointerException
} catch (e: Exception) {
ExceptionUtils.handleException(e, "NullCheck: Missing string")
}
Log Output:
🐞 🐞 🐞 🐞 🐞 🐞 🐞 🐞 🐞 🐞 🐞 🐞 🐞 🐞 🐞 🐞 🐞
🐞 Feature : NullCheck: Missing string
🐞 Exception : 🚫 NullPointerException
🐞 Message : null
🐞 Method : someMethod
🐞 Line no : 123
🐞 File name : (SomeFile.kt:123)
Multiple Catch Blocks 🛡️🔄
Handle different exceptions with multiple catch blocks.
fun main() {
try {
val a = IntArray(5)
a[5] = 10 / 0 // 📏 ArrayIndexOutOfBoundsException
} catch (e: ArithmeticException) {
println("Arithmetic exception caught")
} catch (e: ArrayIndexOutOfBoundsException) {
println("Array index out of bounds caught") // 📜 Output
} catch (e: Exception) {
println("General exception caught")
}
}
Nested Try-Catch Blocks 🛡️🔗
Handle layered risks with nested try-catch.
fun main() {
val nume = intArrayOf(4, 8, 16, 32, 64, 128, 256, 512)
val deno = intArrayOf(2, 0, 4, 4, 0, 8)
try {
for (i in nume.indices) {
try {
println("${nume[i]} / ${deno[i]} is ${nume[i] / deno[i]}") // ➗ ArithmeticException
} catch (exc: ArithmeticException) {
println("Can't divide by zero!") // 📜 Output
}
}
} catch (exc: ArrayIndexOutOfBoundsException) {
println("Element not found.") // 📜 Output
}
}
Finally Block ✅🧹
Cleanup with finally, runs regardless of exceptions.
fun main() {
try {
val data = 10 / 5
println(data) // 📜 Output: 2
} catch (e: NullPointerException) {
println(e)
} finally {
println("Finally block always executes") // 📜 Output
}
}
Throw Keyword 💥🚨
Trigger custom exceptions with throw.
fun main() {
try {
validate(15)
println("Code after validation check...")
} catch (e: ArithmeticException) {
println("Caught: ${e.message}") // 📜 Output: Caught: under age
}
}
fun validate(age: Int) {
if (age < 18) {
throw ArithmeticException("under age") // 💥
} else {
println("Eligible to drive")
}
}
Try as an Expression 🧠🔄
Use try as an expression for functional error handling.
fun parseNumber(input: String?): Int = try {
input?.toInt() ?: throw IllegalArgumentException("Input is null")
} catch (e: NumberFormatException) {
println("Invalid number: $input")
-1
} catch (e: IllegalArgumentException) {
println("Error: ${e.message}")
-2
}
fun main() {
println(parseNumber("123")) // 📜 Output: 123
println(parseNumber("abc")) // 📜 Output: Invalid number: abc, -1
println(parseNumber(null)) // 📜 Output: Error: Input is null, -2
}
Resource Management with use 🧹⚙️
Auto-close resources with use.
import java.io.BufferedReader
import java.io.StringReader
fun readFirstLine(fileName: String?): String? = try {
BufferedReader(StringReader(fileName ?: "")).use { reader ->
reader.readLine()
}
} catch (e: java.io.IOException) {
println("IO Error: ${e.message}")
null
}
fun main() {
println(readFirstLine("Hello, Kotlin!")) // 📜 Output: Hello, Kotlin!
println(readFirstLine(null)) // 📜 Output: null
}
ExceptionUtils Class 🐞📝
package com.boltuix.androidmasterypro
import android.os.RemoteException
import android.util.Log
import java.io.FileNotFoundException
import java.io.IOException
import java.io.PrintWriter
import java.io.StringWriter
/**
* Utility for logging exceptions with emojis.
*
* Usage:
* ```
* try {
* // Risky code
* } catch (e: Exception) {
* ExceptionUtils.handleException(e, "FeatureName: Description")
* }
* ```
*/
object ExceptionUtils {
private val exceptionTypeMap = mapOf(
ArithmeticException::class.java to Pair("ArithmeticException", "➗"),
ArrayIndexOutOfBoundsException::class.java to Pair("ArrayIndexOutOfBoundsException", "📏"),
ClassCastException::class.java to Pair("ClassCastException", "🔄"),
FileNotFoundException::class.java to Pair("FileNotFoundException", "📁"),
IOException::class.java to Pair("IOException", "💾"),
InterruptedException::class.java to Pair("InterruptedException", "⏸️"),
NullPointerException::class.java to Pair("NullPointerException", "🚫"),
SecurityException::class.java to Pair("SecurityException", "🔒"),
NumberFormatException::class.java to Pair("NumberFormatException", "🔢"),
IndexOutOfBoundsException::class.java to Pair("IndexOutOfBoundsException", "📉"),
RemoteException::class.java to Pair("RemoteException", "🌐"),
IllegalStateException::class.java to Pair("IllegalStateException", "⚠️"),
UnsupportedOperationException::class.java to Pair("UnsupportedOperationException", "🚫"),
RuntimeException::class.java to Pair("RuntimeException", "💥"),
NoSuchElementException::class.java to Pair("NoSuchElementException", "🔍"),
ConcurrentModificationException::class.java to Pair("ConcurrentModificationException", "🔄")
)
/**
* Retrieves supported exception types with names and emojis.
*
* @return List of triples (class, name, emoji).
*/
fun getSupportedExceptions(): List<Triple<Class<out Exception>, String, String>> {
return exceptionTypeMap.map { (clazz, pair) ->
Triple(clazz, pair.first, pair.second)
}
}
/**
* Logs a message to the console (in debug mode).
*
* @param message The message to log.
* @param level Log level (default: ERROR).
*/
private fun logMessage(message: String, level: String = "ERROR") {
if (!isDebugMode()) return
val tag = "error01"
when (level) {
"ERROR" -> Log.e(tag, message)
"DEBUG" -> Log.d(tag, message)
"WARN" -> Log.w(tag, message)
}
}
/**
* Handles an exception and logs it with an emoji (in debug mode).
*
* @param e The exception to handle.
* @param customMessage A descriptive message for the feature or context.
*/
fun handleException(e: Exception, customMessage: String) {
if (!isDebugMode()) return
try {
val (errorMessage, emoji) = exceptionTypeMap[e::class.java] ?: Pair("GenericException", "❓")
val stackElement = e.stackTrace.firstOrNull { it.className.contains("com.boltuix.androidmasterypro") }
val methodName = stackElement?.methodName ?: "Unknown"
val lineNumber = stackElement?.lineNumber?.toString() ?: "Unknown"
val fileName = stackElement?.fileName ?: "Unknown"
val stackTrace = if (e.message == null) {
StringWriter().also { sw ->
PrintWriter(sw).use { pw -> e.printStackTrace(pw) }
}.toString()
} else {
""
}
val logMessage = StringBuilder().apply {
appendLine("🐞 🐞 🐞 🐞 🐞 🐞 🐞 🐞 🐞 🐞 🐞 🐞 🐞 🐞 🐞 🐞 🐞")
appendLine("🐞 Feature : $customMessage")
appendLine("🐞 Exception : $emoji $errorMessage")
appendLine("🐞 Message : ${e.message ?: "No message"}")
appendLine("🐞 Method : $methodName")
appendLine("🐞 Line no : $lineNumber")
appendLine("🐞 File name : ($fileName:$lineNumber)")
if (stackTrace.isNotEmpty()) appendLine("🐞 Stack trace : $stackTrace")
appendLine()
}.toString()
logMessage(logMessage)
} catch (e: Exception) {
logMessage("Error handling exception: ${e.message} | Context: $customMessage")
}
}
/**
* Checks if the application is in debug mode.
*
* @return True if debug mode is enabled, false otherwise.
*/
private fun isDebugMode(): Boolean = BuildConfig.DEBUG
}
ExceptionUtils Usage Demo 🛠️
try {
val arr = IntArray(5)
val value = arr[10] // 📏 ArrayIndexOutOfBoundsException
} catch (e: Exception) {
ExceptionUtils.handleException(e, "Test1: Array Index Out of Bounds Exception")
}
try {
val a: Any = "Hello"
val num = a as Int // 🔄 ClassCastException
} catch (e: Exception) {
ExceptionUtils.handleException(e, "Test2: Class Cast Exception")
}
try {
val file = java.io.File("non_existent_file.txt")
val reader = java.io.FileReader(file) // 📁 FileNotFoundException
} catch (e: Exception) {
ExceptionUtils.handleException(e, "Test3: File Not Found Exception")
}
try {
val inputStream = java.io.FileInputStream("non_existent_file.txt")
val data = inputStream.read() // 💾 IOException
} catch (e: Exception) {
ExceptionUtils.handleException(e, "Test4: I/O Exception")
}
try {
Thread.sleep(1000)
throw InterruptedException("Thread interrupted") // ⏸️ InterruptedException
} catch (e: Exception) {
ExceptionUtils.handleException(e, "Test5: Interrupted Exception")
}
try {
val str: String? = null
val length = str!!.length // 🚫 NullPointerException
} catch (e: Exception) {
ExceptionUtils.handleException(e, "Test6: Null Pointer Exception")
}
try {
System.setSecurityManager(SecurityManager()) // 🔒 SecurityException
} catch (e: Exception) {
ExceptionUtils.handleException(e, "Test7: Security Exception")
}
try {
val str = "abc"
val num = str.toInt() // 🔢 NumberFormatException
} catch (e: Exception) {
ExceptionUtils.handleException(e, "Test8: Number Format Exception")
}
try {
throw RemoteException() // 🌐 RemoteException
} catch (e: Exception) {
ExceptionUtils.handleException(e, "Test9: Remote Exception")
}
try {
throw IllegalStateException("Illegal state") // ⚠️ IllegalStateException
} catch (e: Exception) {
ExceptionUtils.handleException(e, "Test10: Illegal State Exception")
}
try {
val num = 10 / 0 // ➗ ArithmeticException
} catch (e: Exception) {
ExceptionUtils.handleException(e, "Test11: Arithmetic Exception")
}
try {
val list = listOf(1, 2, 3)
list[10] // 📉 IndexOutOfBoundsException
} catch (e: Exception) {
ExceptionUtils.handleException(e, "Test12: Index Out of Bounds Exception")
}
try {
throw UnsupportedOperationException("Operation not supported") // 🚫 UnsupportedOperationException
} catch (e: Exception) {
ExceptionUtils.handleException(e, "Test13: Unsupported Operation Exception")
}
try {
throw RuntimeException("Runtime error") // 💥 RuntimeException
} catch (e: Exception) {
ExceptionUtils.handleException(e, "Test14: Runtime Exception")
}
try {
val iterator = listOf<Int>().iterator()
iterator.next() // 🔍 NoSuchElementException
} catch (e: Exception) {
ExceptionUtils.handleException(e, "Test15: No Such Element Exception")
}
try {
val list = mutableListOf(1, 2, 3)
for (item in list) {
list.remove(item) // 🔄 ConcurrentModificationException
}
} catch (e: Exception) {
ExceptionUtils.handleException(e, "Test16: Concurrent Modification Exception")
}
Last Updated: June 27, 2025
Tags:
Kotlin
