[JAVA] Point 41: Utiliser les interfaces de marqueurs pour définir les types

41. Utilisez l'interface des marqueurs pour la définition du type

[Interface du marqueur](https://ja.wikipedia.org/wiki/%E3%83%9E%E3%83%BC%E3%82%AB%E3%83%BC%E3%82%A4%E3% 83% B3% E3% 82% BF% E3% 83% 95% E3% 82% A7% E3% 83% BC% E3% 82% B9) est une classe qui n'inclut pas de définition de méthode et implémente simplement l'interface. Est de montrer qui a un attribut spécifique. Un exemple est l'interface `` Serializable '' (Chapitre 12). L'implémentation de cette interface montre que les instances de cette classe sont accessibles en écriture sur ObjectOutputStream.

Avec l'avènement des annotations de marqueurs (Item39), l'interface des marqueurs peut sembler obsolète, mais c'est une erreur. L'interface de marqueur présente deux avantages par rapport aux annotations de marqueur. La première est que ** l'interface du marqueur définit le type, mais pas ** l'annotation du marqueur. Cela permet de détecter les erreurs au moment de la compilation qui ne peuvent pas être interceptées par les annotations de marqueur avant l'exécution. La fonction de sérialisation de Java utilise l'interface de marqueur Serializable '' pour indiquer que le type est sérialisable. La méthode ```ObjectOutputStream.writeObject``` sérialise l'objet passé, mais exige que ses arguments soient sérialisables. Si l'argument de cette méthode est Serializable '' (en fait il prend un Object), il peut être détecté par compilation lorsqu'un argument de type inapproprié arrive. La seconde est que l'interface ** des marqueurs est plus concise et ciblée **. Lorsque la cible de l'annotation de marqueur est ElementType.TYPE, toutes les classes et interfaces sont ciblées, mais dans le cas de l'interface de marqueur, elle est limitée à la classe qui l'implémente. setL'interface est une telle interface de marqueur limitant. Set est implémenté uniquement dans les sous-types de Collection, mais n'ajoute rien aux méthodes définies dans Collection. Set redéfinit certaines des méthodes de Collection, il n'est donc généralement pas considéré comme une interface de marqueur. Cependant, il est facile d'imaginer une interface de marqueur qui ne s'applique qu'à un sous-type d'interface particulier et ne redéfinit pas les méthodes de l'interface. Une telle interface de marqueur décrit une valeur immuable (?) Pour l'objet entier, ou indique que son instance est adaptée pour être traitée par une méthode d'une autre classe particulière (en ce sens, `. L'interface `` Serializableindique que l'instance est apte à être traitée parObjectOutputStream```).

** L'avantage des annotations de marqueur est qu'elles font partie d'une fonction d'annotation plus large. ** Par conséquent, les annotations de marqueur sont prises en compte pour la cohérence dans un cadre basé sur les annotations.

Comment utiliser correctement l'annotation des marqueurs et l'interface des marqueurs?

Premièrement, la seule façon d'ajouter des marqueurs à des éléments autres que des classes et des interfaces est d'utiliser des annotations de marqueur. Concernant les marqueurs pour les classes et les interfaces *** Avez-vous déjà écrit une ou plusieurs méthodes qui ne ciblent que les objets avec ce marquage? *** *** Considérer. Si vous avez quelque chose à écrire, vous devez utiliser l'interface des marqueurs. Cela permet de vérifier le type des arguments de méthode au moment de la compilation. Si vous ne l'écrivez pas, vous devez utiliser des annotations de marqueur. Les annotations de marqueur doivent être choisies pour le marquage dans les cadres qui utilisent beaucoup d'annotations.

Recommended Posts

Point 41: Utiliser les interfaces de marqueurs pour définir les types
Point 26: N'utilisez pas de types bruts
Rubrique 65: Préférez les interfaces à la réflexion
Rubrique 64: Se référer aux objets par leurs interfaces
Point 61: Préférez les types primitifs aux primitives encadrées
Point 44: Favoriser l'utilisation d'interfaces fonctionnelles standards
Élément 31: Utilisez des caractères génériques délimités pour augmenter la flexibilité de l'API
Élément 89: Pour le contrôle d'instance, préférez les types enum à readResolve
Comment utiliser Map
Comment utiliser rbenv
Comment utiliser with_option
Comment utiliser fields_for
Comment utiliser java.util.logging
Comment utiliser la carte
Comment utiliser collection_select
Passons en revue le PATH pour utiliser docker-slim
Comment utiliser Twitter4J
Comment utiliser active_hash! !!
Comment utiliser MapStruct
Item 52: Utiliser la surcharge judicieusement
Comment utiliser TreeSet
[Comment utiliser l'étiquette]
Point 53: Utilisez judicieusement les varargs
Comment utiliser l'identité
Comment utiliser le hachage
Point 45: Utilisez judicieusement les flux
Comment utiliser Dozer.mapper
Comment utiliser Gradle
Comment utiliser org.immutables
Comment utiliser java.util.stream.Collector
Comment utiliser VisualVM
Point 29: Favoriser les types génériques
Comment utiliser Map