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, Listf7e83be87db5cd2d9a8a0b8117b38cd4 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 Listf7e83be87db5cd2d9a8a0b8117b38cd4 à une méthode qui accepte un paramètre Lista87fdacec66f0909fc0757c19f2d2b1d

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 List58709d3cf0aeaa51ac7bfcab7db27ec4 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 Lista87fdacec66f0909fc0757c19f2d2b1d peut stocker tout type d'objet, y compris String, Integer, etc., tandis que Listf7e83be87db5cd2d9a8a0b8117b38cd4 ne peut être utilisé que pour stocker des String .

List<Object> objectList;
List<String> stringList;
objectList = stringList; //compilation error incompatible types

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()

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 Lista87fdacec66f0909fc0757c19f2d2b1d et List de type primitif en Java ?

La principale différence entre le type primitif et le type paramétré a87fdacec66f0909fc0757c19f2d2b1d 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 Listf7e83be87db5cd2d9a8a0b8117b38cd4 à une méthode qui accepte Lista87fdacec66f0909fc0757c19f2d2b1d, 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);
}

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!