Bonjour !

Pour mon projet je devais expliquer le @Generated qui est apparu dans la version 6 de java.

Pour le faire j'ai du créer une class public @interface Generated {String value(); String comments();}

et j'ai mit au dessus d'une fonction @Generated(value = "blabla", comments="voiçi un générateur de random")

ma question est : est-ce que j'ai bien fait ça ? Sachant que c'est une annotation standard j'ai l'impression que je me suis trompé en faisant une annotation personnalisée non ? Je m'y suis mal pris ?

Pourquoi créer une annotation quand elle existe déjà?

Car je ne sais pas comment l'appeller, je regarde sur le net j'ai du mal à comprendre s'est pour ça que je vous demande, faut il importer quelque chose ? car quand je fait @Generated ca m'affiche du rouge sans explications

j'ai testé de faire directtement @Generated(value = "voila mon random") ca ne marche pas et la seul solution qu'il me propose s'est de créer cette annotation

Pourquoi tu en as besoin ?
Le @generated n'est utile en soi que pour les IDE et outils d'analyse de code. Il permet de dire au lecteur que le code est généré (et ne doit donc pas être modifié manuellement).

Dans quel cadre en as-tu besoin ?

Pour l'utiliser, il suffit d'importer l'annotation generated en haut du fichier java dans les imports. L'ide doit le faire de façon automatique, sinon c'est que ton build path est mal configuré.

J'ai su le mettre, avec les value et les comments mais ca ne marche pas lorsque je dit "date = "12 avril 2012" par exemple.

Enfaite je doit expliquer ce que sont que les annotations et introspections, et je me base sur un livre "programmez en java" et dedans ils disent que depuis java 6 l'annotation @Generated fait parti des annotations standards. Je pensais que c'était important mais bon... Je voyait cette annotation comme un moyen de dire au programmeur que s'est un code généré automatiquement et non à partir d'une personne.

Du coup je ne vais pas en parler si ca n'en vaut pas vraiment la peine, comme je suis en 1ère année.... Du coup je ne parle que des SuppressWarnings, Deprecated et Override. J'espère que ca suffira pour expliquer les annotations de bases (standards)

Voilà un cours pas mal sur les annotations : https://www.jmdoudoux.fr//java/dej/chap-annotations.htm

Maintenant je ne sais pas ce qu'attends ton prof. S'il veut voir si tu as compris comment utiliser une annotation ou comment ça marche derrière.

Globalement, une annotation se positionne sur certains éléments (voir le @Target) et conserve les informations à un niveau donné (voir le @Retention).

Par exemple pour l'annotation @Deprecated :

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(value={CONSTRUCTOR, FIELD, LOCAL_VARIABLE, METHOD, PACKAGE, PARAMETER, TYPE})
public @interface Deprecated {
}

@Deprecated s'utilise sur les constructeurs, les champs, les variables locales, les méthodes etc..
Les informations sont conservées dans le code source et le bytecode (= code compilé).

Toutes les annotations fonctionnent comme ça. Et tu peux définir tes propres annotations de la même façon

He bien un grand merci tu m'as donné une très bonne explication ! J'avais été voir le site que tu m'a donné déjà, mais au niveau des exemples je n'ai pas trouvé ça très clair.

Donc si j'ai bien compris ce que tu me dit, le Target permet de préçiser sur quoi mon annotation peut être utilisé (méthod, variables, constructeur,...) et le retention permet de préçiser à quel moment il sera utilisé ? (Dans le compilateur, lors de l'execution, lors de l'écriture) ?

C'est ça.
Pour le @Retention qui prend pour valeur une java.lang.annotation.RetentionPolicy, c'est bien expliqué ici : https://stackoverflow.com/a/3108036/7443775.
Ca permet de savoir quand l'annotation reste valable (est-elle présente que dans le code source ou également dans le code compilé ?)

Au niveau des annotations custom, souvent on les utilise dans le cadre d'autres librairies, par exemple pour la validation de bean (c'est ce que fait hibernale validator ou spring validation), ou en combinaison avec du code utilisant l'api réflection (ce que fait jmdoudoux dans le lien que j'ai donné - partie 9.7.3. L'exploitation des annotations par introspection) ou en combinaison avec la programmation AOP.

N'hésite pas si tu as d'autres questions

Merci ! Pour te montré un exemple j'ai écrit ceçi j'espère que c'est correcte

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.SOURCE) // L'annotation ne sera pas exploitée lors de l'execution du program
@Target({ElementType.CONSTRUCTOR, ElementType.METHOD, ElementType.LOCAL_VARIABLE}) // L'annotation sera appliquée sur des constructeurs, methodes et variables.
public @interface AnnotationPerso 
{
	String value();
	String auteur();
	String date();
}

Et j'ai ensuite mit comme explication :

"Vous pouvez ainsi changer les valeurs comme vous le souhaitez pour chaques entité que vous voulez annoté. Le résultat se produira lorsque vous laisserez votre souris sur l’entité instanciée. Cette annotation permettra donc d’afficher les informations concernant la méthode jeMange()."