communauté Apprendre Bibliothèque d'outils Loisirs
recherche
Français
Maison > Java > JavaQuestions d'entretien > le corps du texte

Questions d'entretien sur les génériques Java

(*-*)浩
Libérer： 2019-12-12 15:21:52
original
3193 Les gens l'ont consulté

Questions d'entretien sur les génériques Java

Que sont les génériques en Java ?

Les types génériques sont une nouvelle fonctionnalité de Java SE 1.5. L'essence des génériques réside dans les types paramétrés, ce qui signifie que le type de données sur lequel l'opération est effectuée est spécifié en tant que paramètre.

Avantages :                                                                                                                                                                                                                        >2. Compatibilité ascendante et descendante3. Code généralisé, le code peut être réutilisé davantage

4. écrit avec GJ (JAVA générique) peut être compilé pour java. Le serveur et la machine virtuelle apportent plus d'informations de type, ce qui fournit les conditions d'une optimisation ultérieure des programmes Java.

Comment fonctionnent les génériques en Java ? Qu'est-ce que l'effacement de type ? Comment ça marche ?

1. Vérification de type : effectuer une vérification de type avant de générer du bytecode

2. Effacement de type : tous les paramètres de type sont remplacés par leurs types qualifiés, y compris les classes, les variables et les méthodes (effacement de type. ) 3. Si l'effacement de type et le polymorphisme sont en conflit, une méthode de pont est générée dans la sous-classe pour résoudre le problème

4. Si une méthode générique est appelée, le type de retour est effacé, un cast. est inséré lors de l'appel de la méthode

Effacement du type :

Tous les paramètres de type sont remplacés par leurs types qualifiés :

Par exemple, T-> Object ? extends BaseClass->BaseClass

Comment ça marche :

Les génériques sont implémentés via l'effacement de type, le compilateur efface toutes les informations liées au type au moment de la compilation, donc il n'y a aucune information relative au type au moment de l'exécution. Par exemple, List est représenté par une seule liste au moment de l'exécution.

Le but de ceci est d'assurer la compatibilité avec les bibliothèques de classes binaires développées dans les versions antérieures à Java 5. Vous ne pouvez pas accéder aux paramètres de type au moment de l'exécution car le compilateur a converti le type générique en type primitif. En fonction de votre réponse à cette question générique, vous recevrez des questions complémentaires, telles que pourquoi les génériques sont implémentés par effacement de type ou des génériques incorrects qui provoqueront des erreurs de code du compilateur.

Pouvez-vous transmettre un List à une méthode qui accepte un paramètre List

Pour tous ceux qui ne sont pas familiers avec les génériques, cette question sur les génériques Java semble déroutante, car à première vue, String est une sorte d'objet, donc List est attendu, mais ce n'est pas le cas. Cela entraînerait des erreurs de compilation.

Si vous y réfléchissez davantage, vous constaterez qu'il est logique que Java fasse cela, car List peut stocker tout type d'objet, y compris String, Integer, etc., tandis que List ne peut être utilisé que pour stocker des String . 
List<Object> objectList;
List<String> stringList;
objectList = stringList; //compilation error incompatible types
Copier après la connexion

Comment empêcher les avertissements de type non vérifiés en Java ?

Si vous mélangez des types génériques et des types primitifs, comme le code suivant, javac dans java 5 Le compilateur générera avertissements de type non vérifiés, tels que 

List<String> rawList = newArrayList()
Copier après la connexion

Remarque : Hello.java utilise des opérations non vérifiées ou non sécurisées Ce type d'avertissement peut être utilisé avec l'annotation @SuppressWarnings(" unchecked") pour bloquer.

Quelle est la différence entre List et List de type primitif en Java ?

La principale différence entre le type primitif et le type paramétré La différence est que le compilateur n'effectuera pas de contrôles de sécurité des types sur les types primitifs au moment de la compilation, mais vérifiera les types avec des paramètres. En utilisant Object comme type, vous pouvez indiquer au compilateur que la méthode peut accepter n'importe quel type d'objet, tel que. Chaîne ou entier.

Le point test de cette question réside dans la compréhension correcte des types primitifs dans les génériques. La deuxième différence entre eux est que vous pouvez transmettre n'importe quel type avec des paramètres au type primitif List, mais vous ne pouvez pas transmettre List à une méthode qui accepte List, car une erreur de compilation se produira.

Écrire un programme générique pour implémenter le cache LRU ?

Pour ceux qui aiment la programmation Java, cela équivaut à un exercice. Pour vous donner un indice, LinkedHashMap peut être utilisé pour implémenter un cache LRU de taille fixe. Lorsque le cache LRU est plein, il déplacera la paire clé-valeur la plus ancienne hors du cache.

LinkedHashMap fournit une méthode appelée removeEldestEntry(), qui sera appelée par put() et putAll() pour supprimer la paire clé-valeur la plus ancienne. Bien sûr, si vous avez déjà écrit un test JUnit en cours d'exécution, vous êtes libre d'écrire votre propre code d'implémentation.

Les génériques peuvent-ils être utilisés dans Array ?

这可能是Java泛型面试题中最简单的一个了，当然前提是你要知道Array事实上并不支持泛型，这也是为什么Joshua Bloch在Effective Java一书中建议使用List来代替Array，因为List可以提供编译期的类型安全保证，而Array却不能。

如何编写一个泛型方法，让它能接受泛型参数并返回泛型类型?

编写泛型方法并不困难，你需要用泛型类型来替代原始类型，比如使用T, E or K,V等被广泛认可的类型占位符。最简单的情况下，一个泛型方法可能会像这样：

public V put(K key, V value) {
return cahe.put(key,value);
}
Copier après la connexion

C++模板和java泛型之间有何不同？

java泛型实现根植于“类型消除”这一概念。当源代码被转换为Java虚拟机字节码时，这种技术会消除参数化类型。有了Java泛型，我们可以做的事情也并没有真正改变多少；他只是让代码变得漂亮些。鉴于此，Java泛型有时也被称为“语法糖”。

这和 C++模板截然不同。在 C++中，模板本质上就是一套宏指令集，只是换了个名头，编译器会针对每种类型创建一份模板代码的副本。

由于架构设计上的差异，Java泛型和C++模板有很多不同点：

C++模板可以使用int等基本数据类型。Java则不行，必须转而使用Integer。

在Java中，可以将模板的参数类型限定为某种特定类型。

在C++中，类型参数可以实例化，但java不支持。

在Java中，类型参数不能用于静态方法(?)和变量，因为它们会被不同类型参数指定的实例共享。在C++，这些类时不同的，因此类型参数可以用于静态方法和静态变量。

在Java中，不管类型参数是什么，所有的实例变量都是同一类型。类型参数会在运行时被抹去。在C++中，类型参数不同，实例变量也不同。

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!

Étiquettes associées：
java
source：php.cn
Article précédent：Questions d'entrevue multithread Java Article suivant：questions d'entretien javaweb (3)
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
Derniers articles par auteur
Derniers numéros
Comment convertir une chaîne en un nombre à 19 chiffres en javaScript sans arrondi automatique ? Nous avons une entrée de chaîne number input="6145390195186705543" si nous voulo...
Depuis 2024-03-30 14:42:35
0
1
367
Rubriques connexes
Plus>
Recommandations populaires
Tutoriels populaires
Plus>
Tutoriels associés
Recommandations populaires
Derniers cours
Derniers téléchargements
Plus>
effets Web
Code source du site Web
Matériel du site Web
Modèle frontal