public @interface MonAnnotation {
}

@MonAnnotation
public class MaClasse {
	/* ... */
}

public class Maclasse {

	/**
	 * Retourne l'année en cours.
	 * @return L'année en cours.
	 */
	 @Deprecated
	public int getYear () {
		return year;
	}

}

public class Maclasse {

	/**
	 * Retourne l'année en cours.
	 * @return L'année en cours.
	 * @deprecated Retourne en réalité le nombre d'années depuis 1900. Remplacée par getFullYear().
	 */
	 @Deprecated
	public int getYear () {
		return year;
	}

}

	@Override
	public String toString() {
		return "Texte";
	}

@SuppressWarnings("deprecation")
public class OldClass {
	/* ... */
}

	@SuppressWarnings({"deprecation","unckeked"})
	public int m () {
		/* ... */
	}

public @interface SimpleAnnotation {
}


import java.lang.annotation.Documented;

@Documented
public @interface DocAnnotation {
}

public class Exemple {

	/**
	 * Commentaire de la méthode 1.
	 */
	 @SimpleAnnotation
	public void method1 () {
		/* ... */
	}
	
	/**
	 * Commentaire de la méthode 2.
	 */
	@DocAnnotation
	public void method2 () {
		/* ... */
	}
}

  public void method1()
  
		Commentaire de la méthode 1.
______________________________________________

  @DocAnnotation
  public void method2()
  
		Commentaire de la méthode 2.
		

public @interface SimpleAnnotation {
}


import java.lang.annotation.Inherit;

@Inherit
public @interface InheritAnnotation {
}

@SimpleAnnotation
@InheritAnnotation
public class ExempleInherited {
}

import java.lang.annotation.Annotation;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;


@Retention(RetentionPolicy.SOURCE)
@interface SourceAnnotation { }

@Retention(RetentionPolicy.CLASS)
@interface ClassAnnotation { }

@Retention(RetentionPolicy.RUNTIME)
@interface RuntimeAnnotation {}

@SourceAnnotation
@ClassAnnotation
@RuntimeAnnotation
public class Main {

	public static void main(String[] args) {
		
		System.out.println ("Liste des annotations de la classe 'Main' :");
		System.out.println ();
		for (Annotation a : Main.class.getAnnotations() ) {
			System.out.println ("\t * Annotation : " + a.annotationType().getSimpleName());
		}
	}
}

Liste des annotations de la classe 'Main' :

	 * Annotation : RuntimeAnnotation

@Target(ElementType.CONSTRUCTOR)
public @interface ConstructorAnnotation {
}

@Target( {ElementType.CONSTRUCTOR, ElementType.METHOD} )
public @interface ConstructorAnnotation {
}

public @interface TODO {
}

import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import static java.lang.annotation.RetentionPolicy.SOURCE;

@Documented
@Retention(SOURCE)
public @interface TODO {
}

	@TODO
	public void doSometing () {
		/* ... */
	}

import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import static java.lang.annotation.RetentionPolicy.SOURCE;

@Documented
@Retention(SOURCE)
public @interface TODO {
	/** Message décrivant la tâche à effectuer. */
	String value();
}

	/**
	 * Commentaire de la méthode...
	 */
	@TODO(value="La gestion des exceptions est incorrecte...")
	public void doSometing () {
		/* ... */
	}

	/**
	 * Commentaire de la méthode...
	 */
	@TODO("La gestion des exceptions est incorrecte...")
	public void doSometing () {
		/* ... */
	}

  @TODO(value="La gestion des exceptions est incorrecte...")
  public void doSometing()
  
		Commentaire de la méthode...
		

	@MonAnnotation (tab={1,2,3,4,5})
	public clas MaClasse {
	}

	@MonAnnotation (tab=1)
	public clas MaClasse {
	}

@Documented
@Retention(SOURCE)
public @interface TODO {
	
	/** Message décrivant la tâche à effectuer. */
	String value();
	/** Niveau de criticité de la tâche. */
	Level  level();
	
	/** Enumération des différents niveaux de criticités. */
	public static enum Level { MINEUR, NORMAL, IMPORTANT };
	
}

	@TODO(value="La gestion des exceptions est incorrecte...", level=TODO.Level.NORMAL)
	public void doSometing () {
		/* ... */
	}

import static com.developpez.adiguba.annotation.TODO.Level.*;

/* ... */

	@TODO(value="La gestion des exceptions est incorrecte...", level=NORMAL)
	public void doSometing () {
		/* ... */
	}

@Documented
@Retention(SOURCE)
public @interface TODO {
	
	/** Message décrivant la tâche à effectuer. */
	String value();
	/** Niveau de criticité de la tâche (défaut : NORMAL). */
	Level  level() default Level.NORMAL;
	
	/** Enumération des différents niveaux de criticités. */
	public static enum Level { MINEUR, NORMAL, IMPORTANT };
	
}

	@TODO("La gestion des exceptions est incorrecte...")
	public void doSometing () {
		/* ... */
	}
	
	@TODO(value="La gestion des exceptions est incorrecte...")
	public void doSometing () {
		/* ... */
	}
	
	@TODO(value="La gestion des exceptions est incorrecte...", level=NORMAL)
	public void doSometing () {
		/* ... */
	}

	@TODO(level=NORMAL, value="La gestion des exceptions est incorrecte...")
	public void doSometing () {
		/* ... */
	}

@Documented
@Retention(SOURCE)
public @interface TODOs {
	/** Le Tableau des différentes annotations TODO. */
	TODO[] value();
}

	@TODOs({
		@TODO("La gestion des exceptions est incorrecte..."),
		@TODO(value="NullPointerException possible dans certain cas.",level=IMPORTANT)
	})
	public void doSometing () {
		/* ... */
	}

public class SimpleAnnotationProcessorFactory implements AnnotationProcessorFactory {
	
	/** Collection contenant le nom des Annotations supportées. */
	protected Collection<String> supportedAnnotationTypes =
		Arrays.asList( TODO.class.getName(), TODOs.class.getName() );
	
	/** Collection des options supportées. */
	protected Collection<String> supportedOptions =
		Collections.emptyList();

	/**
	 * Retourne la liste des annotations supportées par cette Factory.
	 */
	public Collection<String> supportedAnnotationTypes() {
		return supportedAnnotationTypes;
	}

	/**
	 * Retourne la liste des options supportées par cette Factory.
	 */
	public Collection<String> supportedOptions() {
		return supportedOptions;
	}
	
	/**
	 * Retourne l'AnnotationProcessor associé avec cette Factory...
	 */
	public AnnotationProcessor getProcessorFor(Set<AnnotationTypeDeclaration> atds,
			AnnotationProcessorEnvironment env) {
		// Si aucune annotation n'est présente on retourne un processeur "vide"
		if (atds.isEmpty())
			return AnnotationProcessors.NO_OP;
		return new SimpleAnnotationProcessor(env);
	}

}

public class SimpleAnnotationProcessor implements AnnotationProcessor {
	
	/** L'environnement du processeur d'annotation. */
	protected final AnnotationProcessorEnvironment env;
	
	/**
	 * Constructeur.
	 * @param env L'environnement du processeur d'annotation.
	 */
	public SimpleAnnotationProcessor (AnnotationProcessorEnvironment env) {
		this.env = env;
	}

	/**
	 * Traitement des fichiers sources.
	 */
	public void process() {
		// Instanciation du Visitor
		TODOVisitor todoVisitor = new TODOVisitor(env);
		
		// On boucle sur toutes les Annotations :
		for ( Declaration d : env.getTypeDeclarations()) {

			// On "visite" chacune des déclarations trouvées :
			d.accept( DeclarationVisitors.getSourceOrderDeclarationScanner(
					todoVisitor, DeclarationVisitors.NO_OP) );
		}
	}
}

public class TODOVisitor extends SimpleDeclarationVisitor{

	protected final AnnotationProcessorEnvironment env;
	
	public TODOVisitor (AnnotationProcessorEnvironment env) {
		this.env = env;
	}

	/**
	 * Pour tout type de déclaration, on affiche un message si
	 * l'Annotation @TODO est présente...
	 * De même, on affiche un message pour tous les @TODO
	 * contenu dans l'annotation @TODOs
	 */
	@Override
	public void visitDeclaration(Declaration decl) {
		
		// On regarde si la déclaration possède une annotation TODO
		TODO todo = decl.getAnnotation(TODO.class);
		// Et on l'affiche eventuellement :
		if (todo!=null)
			printMessage(decl, todo);
		
		// On fait la même chose pour l'annotation TODOs