What is Annotation in Kotlin: Simple Explanation and Example

In Kotlin, an annotation is a special kind of metadata that you can add to code elements like classes, functions, or properties to provide extra information. Annotations do not change the code behavior directly but can be used by tools, libraries, or the compiler to generate code or enforce rules.

How It Works

Think of annotations like sticky notes you put on your code. These notes don't change what the code does but give hints or extra details to other tools or the Kotlin compiler. For example, you might mark a function with an annotation to say it should only be called in certain situations or to generate extra code automatically.

When Kotlin code is compiled, these annotations can be read by the compiler or other programs to perform special actions, like checking for errors, generating helper code, or integrating with frameworks. This is similar to how a teacher might use marks on a student's paper to give feedback without changing the student's writing.

Example

This example shows how to use a built-in annotation @Deprecated to mark a function as outdated. When someone uses this function, the compiler will warn them.

kotlin

fun oldFunction() {
    println("This function is old.")
}

@Deprecated("Use newFunction() instead")
fun deprecatedFunction() {
    println("This function is deprecated.")
}

fun newFunction() {
    println("This function is new and preferred.")
}

fun main() {
    oldFunction()
    deprecatedFunction()  // This will show a warning
    newFunction()
}

Output

This function is old.
This function is deprecated.
This function is new and preferred.

When to Use

Use annotations when you want to add extra information to your code that helps tools or the compiler do more work for you. For example, you can mark functions as deprecated to warn others not to use them, or you can create custom annotations to mark parts of your code for special processing.

In real life, annotations are useful in frameworks like Android development, where annotations tell the system how to connect UI elements or handle permissions. They help keep your code clean and let tools automate repetitive tasks.

Key Points

• Annotations add metadata to code without changing its behavior.
• They help tools and the compiler understand how to treat your code.
• You can use built-in annotations or create your own custom ones.
• Common uses include marking deprecated code, generating code, or configuring frameworks.

Key Takeaways

Annotations in Kotlin provide extra information about code elements without changing their behavior.

They are used by the compiler and tools to generate code, show warnings, or enforce rules.

You can use built-in annotations like @Deprecated or create your own custom annotations.

Annotations help keep code clean and improve automation in development workflows.