Les annotations ne sont pas le programme lui-même et peuvent être lues pendant la compilation du programme, le chargement de la classe et l'exécution. Obtenez-le et effectuez les tâches correspondantes. traitement. Le format de l'annotation est "@annotation name (valeur du paramètre)", qui peut être attaché aux packages, classes, méthodes et champs, et l'annotation est accessible via le mécanisme de réflexion.
1.2 Annotation intégrée
@Override : Restreindre la méthode de remplacement de sous-classe
Cette annotation indique que le remplacement is Méthodes de sa classe parent Lorsqu'une sous-classe remplace une méthode de la classe parent, assurez-vous que la sous-classe remplace réellement la méthode de la classe parent pour éviter les erreurs de bas niveau
Cette annotation indique qu'une propriété, une méthode ou une classe est obsolète (un élément de programme qu'il est déconseillé aux programmeurs d'utiliser, généralement parce qu'il est dangereux ou parce qu'il est meilleur existe une méthode alternative), le compilateur donnera un avertissement (barré) lorsque d'autres programmes utilisent des propriétés, des méthodes ou des classes obsolètes.
@SuppressWarnings(parameter): Supprimer les avertissements du compilateur
Les classes, méthodes et propriétés affectées par cette annotation supprimeront l'affichage du compilateur avertissements , ses paramètres sont principalement destinés aux instructions d'avertissement et à l'annulation (non cochée), etc.
@SuppressWarnings("取消此类的所有警告")
public class BuiltAnnotation {
@SuppressWarnings("取消此属性的警告")
private String username;
@SuppressWarnings("取消此方法的警告")
public static void main(String[] args) {
// ...
}
}
Copier après la connexion
1.3 Méta-annotation
Le rôle de la méta-annotation est d'annoter d'autres annotations Java définit 4 types de méta-annotations standard, qui sont utilisés. Fournit des descriptions de la portée. et les types d'autres annotations, et d'autres annotations peuvent être personnalisées via des méta-annotations.
@Target : Décrire le champ d'utilisation des annotations
Par exemple, @Target(ElementType.METHOD) signifie agir sur une méthode, @Target(ElementType .TYPE) indique qu'il agit sur une classe ou une interface, etc.
@Rétention : Indique à quel niveau les informations d'annotation doivent être enregistrées, utilisées pour décrire le cycle de vie de l'annotation#🎜 🎜#
Habituellement, les annotations personnalisées utilisent @Retention(RetentionPolicy.RUNTIME), qui est l'effet d'exécution.
@Document : Indique que cette note sera incluse dans le javadoc
@Iherited : Définit si les sous-classes sont héritables Annotations définies par la classe parent.
@Inherited n'est utile que pour les annotations de type @Target(ElementType.TYPE), et ne peut être qu'un héritage de classe, pas un héritage d'interface : 1.4 Annotation personnalisée
@Report(type = 1, value = "test")
public class CustomerAnnotation {
@Report(type = 1, value = "test")
public void testCustomerAnnotation() {
System.out.println("测试自定义注解");
}
}
Copier après la connexion
2. Réflexion2.1 Réflexion et mécanisme de réflexion
Réflexion
Réflexion (réflexion) fait référence au programme peut obtenir tout informations sur un objet pendant l'exécution.
Mécanisme de réflexion
Le mécanisme de réflexion signifie que lorsque le programme est en cours d'exécution, il obtient les informations de contenu de n'importe quelle classe via l'API Reflection, et peut exploiter directement toutes les propriétés et méthodes internes de l'objet. 2.2 Comment obtenir la classe Class et les méthodes communes java.lang.Class class, la classe principale qui implémente la réflexion, une fois le chargement de la classe terminé, dans la méthode zone de la mémoire tas Un objet Class sera généré (une classe n'a qu'un seul objet Class). Cet objet contient les informations structurelles complètes de la classe. Vous pouvez voir la structure de la classe à travers cet objet.
public class ClassOperateGenerics {
public Map<String, String> list() {
System.out.println("返回值是泛型");
return new HashMap<>();
}
public void test(Map<String, User> map, List<Integer> list) {
System.out.println("参数是泛型");
}
public static void main(String[] args) throws NoSuchMethodException {
/**
* 获取方法参数的泛型
*/
Method method = ClassOperateGenerics.class.getMethod("test", Map.class, List.class);
// 获取所有方法参数的泛型
Type[] genericParameterTypes = method.getGenericParameterTypes();
for (Type genericParameterType : genericParameterTypes) {
// java.util.Map<java.lang.String, com.loner.mj.reflection.User>
System.out.println(genericParameterType);
if (genericParameterType instanceof ParameterizedType) {
// 获取所有泛型的真实参数
Type[] actualTypeArguments = ((ParameterizedType) genericParameterType).getActualTypeArguments();
for (Type actualTypeArgument : actualTypeArguments) {
// String, User, Integer
System.out.println(actualTypeArgument);
}
}
}
/**
* 获取方法返回值的泛型
*/
Method list = ClassOperateGenerics.class.getMethod("list", null);
// 获取方法返回值的泛型
Type genericReturnType = list.getGenericReturnType();
if (genericReturnType instanceof ParameterizedType) {
// 获取所有泛型的真实参数
Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments();
for (Type actualTypeArgument : actualTypeArguments) {
System.out.println(actualTypeArgument);
}
}
}
}
Copier après la connexion
反射操作注解
public class ClassOperateAnnotation {
public static void main(String[] args) throws NoSuchFieldException {
Class<People> peopleClass = People.class;
// 获取类的所有注解
Annotation[] declaredAnnotations = peopleClass.getDeclaredAnnotations();
for (Annotation declaredAnnotation : declaredAnnotations) {
System.out.println(declaredAnnotation);
}
// 获取类的注解的值
Table declaredAnnotation = peopleClass.getDeclaredAnnotation(Table.class);
System.out.println(declaredAnnotation.value());
// 获取属性的注解
Field name = peopleClass.getDeclaredField("name");
Fields annotation = name.getAnnotation(Fields.class);
System.out.println(annotation.name());
}
}
Copier après la connexion
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
Déclaration de ce site Web
Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn
Guide de la racine carrée en Java. Nous discutons ici du fonctionnement de Square Root en Java avec un exemple et son implémentation de code respectivement.
Guide du nombre parfait en Java. Nous discutons ici de la définition, comment vérifier le nombre parfait en Java ?, des exemples d'implémentation de code.
Guide du générateur de nombres aléatoires en Java. Nous discutons ici des fonctions en Java avec des exemples et de deux générateurs différents avec d'autres exemples.
Guide de Weka en Java. Nous discutons ici de l'introduction, de la façon d'utiliser Weka Java, du type de plate-forme et des avantages avec des exemples.
Dans cet article, nous avons conservé les questions d'entretien Java Spring les plus posées avec leurs réponses détaillées. Pour que vous puissiez réussir l'interview.
Java 8 présente l'API Stream, fournissant un moyen puissant et expressif de traiter les collections de données. Cependant, une question courante lors de l'utilisation du flux est: comment se casser ou revenir d'une opération FOREAK?
Les boucles traditionnelles permettent une interruption ou un retour précoce, mais la méthode Foreach de Stream ne prend pas directement en charge cette méthode. Cet article expliquera les raisons et explorera des méthodes alternatives pour la mise en œuvre de terminaison prématurée dans les systèmes de traitement de flux.
Lire plus approfondie: Améliorations de l'API Java Stream
Comprendre le flux Forach
La méthode foreach est une opération terminale qui effectue une opération sur chaque élément du flux. Son intention de conception est
