Uso de anotaciones
Anote el código
Uso de anotaciones es una lección gratuita de Kotlin Academy en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Kotlin Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Kotlin Academy incluye 4 lecciones en total.
¿Qué son las anotaciones?
Las anotaciones adjuntan metadatos al código. No cambian el comportamiento por sí mismas, pero las herramientas, los compiladores y las bibliotecas las leen para tomar decisiones.
Una anotación se escribe con @ seguido de su nombre, justo antes del elemento al que se aplica.
Una primera anotación
La biblioteca estándar incluye varias anotaciones útiles. @Deprecated marca el código que ya no debería utilizarse y muestra una advertencia en el lugar de la llamada.
@Deprecated("Use newGreet() instead")
fun greet() = "Hi"
fun newGreet() = "Hello"
fun main() {
println(newGreet())
}Anotaciones con argumentos
Las anotaciones pueden recibir argumentos, escritos como parámetros de un constructor. @Deprecated acepta un mensaje y, opcionalmente, una indicación ReplaceWith.
@Deprecated(
message = "Renamed for clarity",
replaceWith = ReplaceWith("sum(a, b)")
)
fun add(a: Int, b: Int) = a + b
fun sum(a: Int, b: Int) = a + b
fun main() {
println(sum(2, 3))
}Suprimir advertencias
@Suppress indica al compilador que silencie advertencias específicas para el elemento anotado. Debe pasar los nombres de las advertencias como cadenas.
@Suppress("UNUSED_VARIABLE")
fun main() {
val unused = 42
println("Runs without the unused-variable warning")
}JvmStatic y otras anotaciones
Algunas anotaciones afectan a la forma en que Kotlin compila para la JVM. @JvmStatic, @JvmField y @JvmName controlan el bytecode para que quienes llaman desde Java vean APIs más sencillas.
No tienen efecto en código exclusivamente Kotlin, pero son importantes para la interoperabilidad.
class Math {
companion object {
@JvmStatic
fun square(x: Int) = x * x
}
}
fun main() {
println(Math.square(5))
}Objetivos de uso de las anotaciones
Una propiedad puede generar varios elementos de la JVM: un campo, un getter, un setter y parámetros del constructor. Los objetivos de uso indican dónde debe aplicarse una anotación.
Sintaxis: @get:, @set:, @field:, @param:.
class User(@get:JvmName("fetchName") val name: String)
fun main() {
val u = User("Ada")
println(u.name)
}Throws para la interoperabilidad con Java
Kotlin no tiene excepciones comprobadas, por lo que quienes llaman desde Java nunca ven cláusulas throws a menos que añada @Throws. Esta anotación registra el tipo de excepción en la firma del bytecode.
import java.io.IOException
@Throws(IOException::class)
fun readData(): String {
return "data"
}
fun main() {
println(readData())
}Varias anotaciones
Puede apilar varias anotaciones sobre un mismo elemento. Cada una va en su propia línea o separada por espacios. El orden no importa.
@Deprecated("old")
@Suppress("DEPRECATION")
fun legacy() = "still here"
fun main() {
println(legacy())
}Anotaciones en expresiones
Las anotaciones también pueden aplicarse a expresiones y declaraciones locales, no solo a funciones o clases de nivel superior. Esto es habitual con @Suppress dentro del cuerpo de una función.
fun main() {
@Suppress("UNUSED_VARIABLE")
val temp = computeOnce()
println("Done")
}
fun computeOnce() = 99OptIn y APIs experimentales
Las bibliotecas marcan las APIs inestables con anotaciones personalizadas de aceptación explícita. Para usarlas, reconoce el riesgo con @OptIn(SomeApi::class) o propaga la anotación.
Así, las funciones experimentales quedan explícitas en lugar de usarse accidentalmente.
fun main() {
// @OptIn would appear here when calling an experimental function
println("Opt-in keeps unstable APIs visible")
}¿Por qué usar anotaciones?
Las anotaciones permiten comunicar su intención a las herramientas: los compiladores avisan sobre llamadas obsoletas, las bibliotecas de serialización asignan campos, los frameworks de pruebas encuentran métodos de prueba y los frameworks de inyección de dependencias conectan las dependencias.
- Metadatos, no lógica
- Se leen en tiempo de compilación o de ejecución
- Mantienen la configuración cerca del código
Comprobación rápida
Compruebe cuánto ha entendido sobre el uso de anotaciones.
Repaso
Ha aprendido a usar anotaciones integradas:
@Deprecated,@Suppress,@Throws- Interoperabilidad con la JVM:
@JvmStatic,@JvmName - Objetivos de uso como
@get:y@field: - Aceptación explícita para APIs experimentales
A continuación definirá sus propias anotaciones.
Preguntas frecuentes
¿La lección «Uso de anotaciones» es gratis?
Sí — el texto completo de «Uso de anotaciones» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Kotlin Academy, actualiza a CoddyKit PRO. El curso de Kotlin Academy incluye 4 lecciones en total.
¿Qué aprenderé en «Uso de anotaciones»?
Anote el código Practicas Kotlin Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar Kotlin Academy?
No se requiere experiencia previa. Kotlin Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.
¿Cuánto tiempo toma la lección «Uso de anotaciones»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de Kotlin Academy?
Sí. Cada lección de Kotlin Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.