Kotlin Academy · Aula

Definição de Anotações

Crie anotações personalizadas

Definição de Anotações é uma aula grátis de Kotlin Academy no CoddyKit. Esta é a aula 2 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.

Declarando uma anotação

Você define uma anotação com as palavras-chave annotation class. A mais simples não contém dados e funciona como um marcador.

annotation class Beta

@Beta
fun newFeature() = "experimental"

fun main() {
    println(newFeature())
}

Parâmetros de anotação

As anotações podem armazenar dados por meio de parâmetros do construtor. Os tipos permitidos são limitados: primitivos, String, enumerações, outras anotações, KClass e matrizes desses tipos.

annotation class ApiVersion(val value: Int)

@ApiVersion(2)
fun endpoint() = "v2"

fun main() {
    println(endpoint())
}

@Target

@Target restringe onde sua anotação pode ser aplicada. Você passa um ou mais valores de AnnotationTarget, como CLASS, FUNCTION ou PROPERTY.

@Target(AnnotationTarget.FUNCTION)
annotation class Loggable

@Loggable
fun process() = "processing"

fun main() {
    println(process())
}

@Retention

@Retention controla por quanto tempo a anotação é preservada:

SOURCE — descartada pelo compilador
BINARY — mantida no arquivo da classe, mas não visível à reflexão
RUNTIME — mantida e visível à reflexão (o padrão)

@Retention(AnnotationRetention.RUNTIME)
annotation class Important

@Important
class Order

fun main() {
    println("Important is readable at runtime")
}

Vários alvos

Liste vários alvos para permitir uma anotação em mais de um local. Aqui, a anotação funciona tanto em classes quanto em funções.

@Target(AnnotationTarget.CLASS, AnnotationTarget.FUNCTION)
annotation class Audited

@Audited
class Account {
    @Audited
    fun withdraw() = "ok"
}

fun main() {
    println(Account().withdraw())
}

Valores padrão de parâmetros

Os parâmetros de anotações podem ter valores padrão, permitindo que quem chama omita esses valores. Isso mantém os casos comuns concisos.

annotation class Cache(val seconds: Int = 60)

@Cache
fun cheap() = 1

@Cache(seconds = 300)
fun expensive() = 2

fun main() {
    println("" + cheap() + " " + expensive())
}

Parâmetros de matriz

Você pode usar tipos de matriz. Forneça os valores com a sintaxe de literal de matriz [ ... ] no uso da anotação.

annotation class Roles(val names: Array<String>)

@Roles(["admin", "editor"])
fun restricted() = "secret"

fun main() {
    println(restricted())
}

@Repeatable

Por padrão, uma anotação pode aparecer apenas uma vez por elemento. Marque-a com @Repeatable para aplicá-la várias vezes.

@Repeatable
annotation class Tag(val value: String)

@Tag("db")
@Tag("cache")
fun layered() = "ok"

fun main() {
    println(layered())
}

Parâmetros de anotação aninhados

Um parâmetro de anotação pode ser, por si só, outra anotação, permitindo que você crie metadados estruturados.

annotation class Author(val name: String)
annotation class Module(val owner: Author)

@Module(Author("Grace"))
class Payments

fun main() {
    println("Nested annotation metadata defined")
}

Projetando boas anotações

Uma anotação bem projetada:

Tem uma finalidade clara e única
Define @Target para que o uso indevido seja um erro de compilação
Usa retenção RUNTIME somente quando a reflexão precisa dela
Fornece valores padrão sensatos

Da definição ao uso

Definir uma anotação é apenas metade da história. Sozinha, ela é um metadado inerte. Algo precisa lê-la — normalmente a reflexão em tempo de execução ou um processador de anotações em tempo de compilação. Em breve, você usará reflexão.

Verificação rápida

Teste sua compreensão sobre a definição de anotações.

Recapitulação

Você aprendeu a definir anotações:

annotation class com parâmetros
@Target para restringir a aplicação
@Retention para controlar o tempo de vida
@Repeatable e valores padrão

Em seguida: inspecionar tipos com reflexão.

Perguntas Frequentes

A aula “Definição de Anotações” é grátis?

Sim — o texto completo de “Definição 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 “Definição de Anotações”?

Crie anotações personalizadas 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 2 de 4.

Quanto tempo leva a aula “Definição 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.

Todas as aulas deste curso

← Voltar para Kotlin Academy