Tipos de Anotação em Java: Guia Completo de Predefinidas, Customizadas e Meta-Anotações

Tipos de Anotação em Java

Este tutorial cobre anotações Java — predefinidas, customizadas e meta-anotações — com exemplos claros.

Anotações Java são metadados que descrevem elementos no seu código fonte. A plataforma Java SE fornece conjunto de anotações padrão, e desenvolvedores podem criar customizadas adaptadas a seus projetos. Anotações também podem ser anotadas elas mesmas, formando o que são conhecidas como meta-anotações.

Anotações caem em três categorias:

1. Anotações predefinidas — built-in na plataforma Java.
2. Anotações customizadas — definidas pelo usuário para necessidades específicas.
3. Meta-anotações — anotações aplicadas a outras anotações.

---

Tipos de Anotação Predefinidas

1. @Deprecated

A anotação @Deprecated sinaliza que classe, método, campo ou outro elemento está obsoleto e tem alternativa mais nova. O compilador emite warning sempre que elemento depreciado é usado.

Sintaxe:

@Deprecated public void metodoAntigo() { ... }

Javadoc fornece tag @deprecated para documentação:

/** * @deprecated * Use {@link #novoMetodo()} em vez disso. */ @Deprecated public void metodoAntigo() { ... }

Exemplo

class Main { /** * @deprecated * Este método está depreciado e foi substituído por novoMetodo() */ @Deprecated public static void metodoDepreciado() { System.out.println("Método depreciado"); } public static void main(String[] args) { metodoDepreciado(); } }

Saída

Método depreciado

---

2. @Override

A anotação @Override indica que método tem intenção de sobrescrever método de superclasse ou interface. Embora não obrigatória, captura erros como assinaturas incompatíveis em tempo de compilação.

Exemplo

class Animal { public void exibir() { System.out.println("Sou um animal"); } } class Cachorro extends Animal { @Override public void exibir() { System.out.println("Sou um cachorro"); } public void imprimirMensagem() { exibir(); } } class Main { public static void main(String[] args) { Cachorro cachorro1 = new Cachorro(); cachorro1.imprimirMensagem(); } }

Saída

Sou um cachorro

---

3. @SuppressWarnings

Esta anotação instrui o compilador a ignorar categorias específicas de warning. Categorias comuns incluem deprecation e unchecked.

Uso:

@SuppressWarnings("deprecation")

Múltiplas categorias:

@SuppressWarnings({"deprecation", "unchecked"})

Exemplo

class Main { @Deprecated public static void metodoDepreciado() { System.out.println("Método depreciado"); } @SuppressWarnings("deprecation") public static void main(String[] args) { Main objDep = new Main(); objDep.metodoDepreciado(); } }

Saída

Método depreciado

---

4. @SafeVarargs

Aplicada a métodos e construtores final, static ou private, @SafeVarargs afirma que o método não realiza operações inseguras em seu parâmetro varargs. Isso remove warnings unchecked relacionados a varargs.

Exemplo

import java.util.*; class Main { @SafeVarargs private static void exibirLista(List<String>... listas) { for (List<String> lista : listas) { System.out.println(lista); } } public static void main(String[] args) { List<String> listaUniversidades = Arrays.asList("Universidade Tribhuvan", "Universidade Kathmandu"); List<String> linguagensProgramacao = Arrays.asList("Java", "C"); exibirLista(listaUniversidades, linguagensProgramacao); } }

Saída

[Universidade Tribhuvan, Universidade Kathmandu] [Java, C]

---

5. @FunctionalInterface

Introduzida no Java 8, esta anotação designa interface como interface funcional — interface com único método abstrato. O compilador verifica esta restrição.

Exemplo

@FunctionalInterface public interface MinhaFuncInterface { void primeiroMetodo(); // abstrato }

Adicionar segundo método abstrato dispara erro de compilação:

@FunctionalInterface public interface MinhaFuncInterface { void primeiroMetodo(); void segundoMetodo(); // erro de compilação }

Múltiplos métodos default ou static são permitidos.

@FunctionalInterface public interface MinhaFuncInterface { void primeiroMetodo(); default void segundoMetodo() { /* ... */ } default void terceiroMetodo() { /* ... */ } }

---

Anotações Customizadas

Desenvolvedores podem criar anotações que atendam requisitos específicos de aplicação. A sintaxe usa @interface e pode incluir métodos de elemento com valores default opcionais.

Sintaxe

@interface NomeAnotacao { TipoElemento nomeElemento() default valorDefault; }

Exemplo

@interface MinhaAnotacaoCustom { String value() default "valor default"; } class Main { @MinhaAnotacaoCustom(value = "programiz") public void metodo1() { System.out.println("Método de teste 1"); } public static void main(String[] args) { new Main().metodo1(); } }

Saída

Método de teste 1

---

Meta-Anotações

Meta-anotações configuram como outras anotações se comportam.

1. @Retention

Define escopo de visibilidade de uma anotação: SOURCE, CLASS ou RUNTIME.

@Retention(RetentionPolicy.RUNTIME) public @interface MinhaAnotacao { }

2. @Documented

Garante que anotação apareça no Javadoc gerado.

@Documented public @interface MinhaAnotacao { }

3. @Target

Restringe anotação a elementos de programa específicos.

@Target(ElementType.METHOD) public @interface MinhaAnotacao { }

Tipos de elemento incluem ANNOTATION_TYPE, CONSTRUCTOR, FIELD, LOCAL_VARIABLE, METHOD, PACKAGE, PARAMETER, TYPE.

4. @Inherited

Permite que subclasse herde anotação presente em superclasse.

@Inherited public @interface MinhaAnotacao { }

5. @Repeatable

Permite anotação ser aplicada múltiplas vezes ao mesmo elemento. Requer anotação container.

@Repeatable(Universidades.class) public @interface Universidade { String name(); } public @interface Universities { Universidade[] value(); }

Uso:

@Universidade(name = "TU") @Universidade(name = "KU") private String nomeUni;

---

Para acessar dados de anotação em runtime, use getAnnotationsByType() ou getAnnotations() da API de Reflection.