Comment utiliser la classe en Java?

Il y a une bonne discussion sur les génériques et sur ce qu’ils font vraiment dans les coulisses à cette question , donc nous soaps tous que Vector est un vecteur de tableaux entiers, et HashTable est une table sont des chaînes et des valeurs Person s. Cependant, ce qui me stoppe est l’utilisation de la Class .

La classe java Class est supposée prendre également un nom de template (ou alors le soulignement jaune dans eclipse). Je ne comprends pas ce que je devrais y mettre. L’object de l’object Class est l’intégralité des informations relatives à un object, à la reflection et à d’autres. Pourquoi me fait-il spécifier la classe que l’object Class contiendra? Je ne sais clairement pas, ou je n’utiliserais pas l’object Class , j’utiliserais l’object spécifique.

Utiliser la version généralisée de la classe Class vous permet, entre autres, d’écrire des choses comme

 Class someCollectionClass = someMethod(); 

et puis vous pouvez être sûr que l’object Class que vous recevez étend Collection , et une instance de cette classe sera (au moins) une collection.

Tout ce que nous soaps, c’est ” Toutes les instances d’une classe quelconque partagent le même object java.lang.Class de ce type de classe

par exemple)

 Student a = new Student(); Student b = new Student(); 

Alors a.getClass() == b.getClass() est vrai.

Maintenant supposons

 Teacher t = new Teacher(); 

sans génériques ci-dessous est possible.

 Class studentClassRef = t.getClass(); 

Mais c’est faux maintenant ..?

par exemple) public void printStudentClassInfo(Class studentClassRef) {} peut être appelé avec Teacher.class

Cela peut être évité en utilisant des génériques.

 Class studentClassRef = t.getClass(); //Compilation error. 

Maintenant qu’est ce que T ?? T est des parameters de type (également appelés variables de type); délimité par des crochets (<>), suit le nom de la classe.
T est juste un symbole, comme un nom de variable (peut être n’importe quel nom) déclaré lors de l’écriture du fichier de classe. Plus tard, T sera remplacé par
nom de classe valide lors de l’initialisation ( HashMap map = new HashMap(); )

par exemple) class name

Donc, la Class représente un object de classe de type de classe spécifique ‘ T ‘.

Supposons que vos méthodes de classe doivent fonctionner avec des parameters de type inconnu, comme ci-dessous

 /** * Generic version of the Car class. * @param  the type of the value */ public class Car { // T stands for "Type" private T t; public void set(T t) { this.t = t; } public T get() { return t; } } 

Ici, T peut être utilisé comme type de Ssortingng comme CarName

OR T peut être utilisé comme type Integer comme modelNumber ,

OU T peut être utilisé comme type d’ Object comme instance de voiture valide .

Maintenant, voici ce qui précède est le simple POJO qui peut être utilisé différemment à l’exécution.
Collections, par exemple) List, Set, Hashmap sont les meilleurs exemples qui fonctionneront avec différents objects selon la déclaration de T, mais une fois que nous avons déclaré T comme Ssortingng
par exemple) HashMap map = new HashMap(); Ensuite, il n’acceptera que les objects d’instance Ssortingng Class.

Méthodes Génériques

Les méthodes génériques sont des méthodes qui introduisent leurs propres parameters de type. Ceci est similaire à la déclaration d’un type générique, mais la scope du paramètre type est limitée à la méthode où il est déclaré. Les méthodes génériques statiques et non statiques sont autorisées, ainsi que les constructeurs de classes génériques.

La syntaxe d’une méthode générique inclut un paramètre de type, entre crochets angulars, et apparaît avant le type de retour de la méthode. Pour les méthodes génériques, la section du paramètre type doit apparaître avant le type de retour de la méthode.

  class Util { // Generic static method public static  boolean compare(Pair p1, Pair p2) { return p1.getKey().equals(p2.getKey()) && p1.getValue().equals(p2.getValue()); } } class Pair { private K key; private V value; } 

Ici, est la déclaration des types utilisés dans les arguments de la méthode qui doivent précéder le type de retour qui est boolean ici.

Dans le ci-dessous; La déclaration de type n’est pas requirejse au niveau de la méthode, car elle est déjà déclarée au niveau de la classe.

 class MyClass { private T myMethod(T a){ return a; } } 

Mais ci-dessous est faux car les parameters de type de classe K, V, Z et Y ne peuvent pas être utilisés dans un contexte statique (méthode statique ici).

 class Util { // Generic static method public static boolean compare(Pair p1, Pair p2) { return p1.getKey().equals(p2.getKey()) && p1.getValue().equals(p2.getValue()); } } 

AUTRES SCÉNARIOS VALIDES

 class MyClass { //Type declaration  already done at class level private T myMethod(T a){ return a; } // is overriding the T declared at Class level; //So There is no ClassCastException though a is not the type of T declared at MyClass. private  T myMethod1(Object a){ return (T) a; } //Runtime ClassCastException will be thrown if a is not the type T (MyClass). private T myMethod1(Object a){ return (T) a; } // No ClassCastException // MyClass obj= new MyClass(); // obj.myMethod2(Integer.valueOf("1")); // Since type T is redefined at this method level. private  T myMethod2(T a){ return a; } // No ClassCastException for the below // MyClass o= new MyClass(); // o.myMethod3(Integer.valueOf("1").getClass()) // Since  is undefined within this method; // And MyClass don't have impact here private  T myMethod3(Class a){ return (T) a; } // ClassCastException for o.myMethod3(Integer.valueOf("1").getClass()) // Should be o.myMethod3(Ssortingng.valueOf("1").getClass()) private T myMethod3(Class a){ return (T) a; } // Class a :: a is Class object of type T // is overriding of class level type declaration; private  Class myMethod4(Class a){ return a; } } 

Et enfin, la méthode statique nécessite toujours une déclaration explicite; Il ne dérive pas de la classe de niveau Class . Cela est dû au fait que le niveau de classe T est lié à l’instance.

Lire également les ressortingctions sur les génériques

De la documentation Java:

[…] Plus surprenant, la classe Class a été générée. Les littéraux de classe fonctionnent désormais comme des jetons de type, fournissant à la fois des informations d’exécution et des types de compilation. Cela active un style de fabriques statiques illustré par la méthode getAnnotation dans la nouvelle interface AnnotatedElement:

  T getAnnotation(Class annotationType); 

Ceci est une méthode générique. Il déduit la valeur de son paramètre de type T de son argument et renvoie une instance appropriée de T, comme illustré par l’extrait de code suivant:

 Author a = Othello.class.getAnnotation(Author.class); 

Avant les génériques, vous auriez dû convertir le résultat en auteur. De plus, vous n’auriez eu aucun moyen de faire vérifier par le compilateur que le paramètre réel représentait une sous-classe de Annotation. […]

Eh bien, je n’ai jamais eu à utiliser ce genre de choses. N’importe qui?

J’ai trouvé la class utile lorsque je crée des recherches dans le registre de services. Par exemple

  T getService(Class serviceClass) { ... } 

Comme d’autres réponses l’indiquent, il existe de nombreuses et bonnes raisons pour lesquelles cette class est devenue générique. Cependant, il y a de nombreuses fois où vous n’avez aucun moyen de connaître le type générique à utiliser avec Class . Dans ces cas, vous pouvez simplement ignorer les avertissements d’éclipse jaune ou vous pouvez utiliser Class … C’est comme ça que je le fais;)

Suite à la réponse de @Kire Haglin, un autre exemple de méthodes génériques peut être vu dans la documentation de JAXB unmarshalling :

 public  T unmarshal( Class docClass, InputStream inputStream ) throws JAXBException { Ssortingng packageName = docClass.getPackage().getName(); JAXBContext jc = JAXBContext.newInstance( packageName ); Unmarshaller u = jc.createUnmarshaller(); JAXBElement doc = (JAXBElement)u.unmarshal( inputStream ); return doc.getValue(); } 

Cela permet à unmarshal de renvoyer un document d’un type d’arborescence de contenu JAXB arbitraire.

Vous voulez souvent utiliser des caractères génériques avec Class . Par exemple, Class Class , vous permet de spécifier que la classe est une sous-classe de JComponent . Si vous avez récupéré l’instance de Class partir de Class.forName , vous pouvez utiliser Class.asSubclass pour effectuer le Class.asSubclass avant d’essayer, par exemple, de construire une instance.

Pour ne citer qu’un autre exemple, la version générique de Class ( Class ) permet d’écrire des fonctions génériques telles que celle ci-dessous.

 public static >Optional optionalFromSsortingng( @NotNull Class clazz, Ssortingng name ) { return Optional opt = Optional.ofNullable(name) .map(Ssortingng::sortingm) .filter(SsortingngUtils::isNotBlank) .map(Ssortingng::toUpperCase) .flatMap(n -> { try { return Optional.of(Enum.valueOf(clazz, n)); } catch (Exception e) { return Optional.empty(); } }); } 

C’est déroutant au début. Mais cela aide dans les situations ci-dessous:

 class SomeAction implements Action { } // Later in the code. Class actionClass = Class.forName("SomeAction"); Action action = actionClass.newInstance(); // Notice you get an Action instance, there was no need to cast. 

Utilisez simplement la classe de boeuf:

 public  T beefmarshal( Class beefClass, InputBeef inputBeef ) throws JAXBException { Ssortingng packageName = docClass.getPackage().getBeef(); JAXBContext beef = JAXBContext.newInstance( packageName ); Unmarshaller u = beef.createBeef(); JAXBElement doc = (JAXBElement)u.beefmarshal( inputBeef ); return doc.getBeef(); }