Uso de Anotações
Anote o código
Uso de Anotações é uma aula grátis de Kotlin Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Kotlin Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Kotlin Academy inclui 4 aulas no total.
O que são anotações
As anotações associam metadados ao código. Elas não alteram o comportamento por si só, mas ferramentas, compiladores e bibliotecas as leem para tomar decisões.
Você escreve uma anotação com @ seguida do nome, posicionada imediatamente antes do elemento ao qual se aplica.
Uma primeira anotação
A biblioteca padrão oferece várias anotações úteis. @Deprecated marca o código que não deve mais ser usado e exibe um aviso no local da chamada.
@Deprecated("Use newGreet() instead")
fun greet() = "Hi"
fun newGreet() = "Hello"
fun main() {
println(newGreet())
}Anotações com argumentos
As anotações podem receber argumentos, escritos como parâmetros de construtor. @Deprecated aceita uma mensagem e, opcionalmente, uma sugestão 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))
}Suprimindo avisos
@Suppress informa ao compilador que deve silenciar avisos específicos para o elemento anotado. Você passa os nomes dos avisos como strings.
@Suppress("UNUSED_VARIABLE")
fun main() {
val unused = 42
println("Runs without the unused-variable warning")
}JvmStatic e recursos relacionados
Algumas anotações afetam a forma como Kotlin é compilado para a JVM. @JvmStatic, @JvmField e @JvmName controlam o código de bytes para que o código Java que as utiliza tenha APIs mais amigáveis.
Elas não fazem nada no código exclusivamente Kotlin, mas são importantes para a interoperabilidade.
class Math {
companion object {
@JvmStatic
fun square(x: Int) = x * x
}
}
fun main() {
println(Math.square(5))
}Alvos de aplicação de anotações
Uma propriedade pode gerar vários elementos da JVM: um campo, um getter, um setter e parâmetros do construtor. Alvos de aplicação indicam onde uma anotação deve ser aplicada.
Sintaxe: @get:, @set:, @field:, @param:.
class User(@get:JvmName("fetchName") val name: String)
fun main() {
val u = User("Ada")
println(u.name)
}Throws para interoperabilidade com Java
Kotlin não tem exceções verificadas, portanto quem chama pelo Java nunca vê cláusulas throws, a menos que você adicione @Throws. Isso registra o tipo da exceção na assinatura do código de bytes.
import java.io.IOException
@Throws(IOException::class)
fun readData(): String {
return "data"
}
fun main() {
println(readData())
}Várias anotações
Você pode empilhar várias anotações em um único elemento. Cada uma fica em sua própria linha (ou separada por espaços). A ordem não importa.
@Deprecated("old")
@Suppress("DEPRECATION")
fun legacy() = "still here"
fun main() {
println(legacy())
}Anotações em expressões
As anotações também podem ser aplicadas a expressões e declarações locais, não apenas a funções ou classes de nível superior. Isso é comum com @Suppress dentro do corpo de uma função.
fun main() {
@Suppress("UNUSED_VARIABLE")
val temp = computeOnce()
println("Done")
}
fun computeOnce() = 99OptIn e APIs experimentais
As bibliotecas marcam APIs instáveis com anotações personalizadas de adesão. Para usá-las, você reconhece o risco com @OptIn(SomeApi::class) ou propagando a anotação.
Isso mantém os recursos experimentais explícitos, em vez de acidentais.
fun main() {
// @OptIn would appear here when calling an experimental function
println("Opt-in keeps unstable APIs visible")
}Por que usar anotações
As anotações permitem comunicar a intenção a ferramentas: os compiladores emitem avisos sobre chamadas obsoletas, as bibliotecas de serialização mapeiam campos, as estruturas de teste encontram métodos de teste e as estruturas de DI conectam dependências.
- Metadados, não lógica
- Lidos em tempo de compilação ou de execução
- Mantêm a configuração próxima do código
Verificação rápida
Teste sua compreensão sobre o uso de anotações.
Recapitulação
Você aprendeu a usar anotações integradas:
@Deprecated,@Suppress,@Throws- Interoperabilidade com a JVM:
@JvmStatic,@JvmName - Alvos de aplicação, como
@get:e@field: - Adesão para APIs experimentais
Em seguida, você definirá suas próprias anotações.
Perguntas Frequentes
A aula “Uso de Anotações” é grátis?
Sim — o texto completo de “Uso de Anotações” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Kotlin Academy, atualize para CoddyKit PRO. O curso de Kotlin Academy inclui 4 aulas no total.
O que vou aprender em “Uso de Anotações”?
Anote o código Você pratica Kotlin Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar Kotlin Academy?
Nenhuma experiência prévia é necessária. Kotlin Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.
Quanto tempo leva a aula “Uso de Anotações”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de Kotlin Academy?
Sim. Cada aula de Kotlin Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.