Questions d'entretien de base Java - génériques

139. Que sont les génériques en Java ? Quels sont les avantages de l'utilisation des génériques

(Questions d'entretien plus connexes recommandées : questions d'entretien Java et réponse ? 🎜>)

Les génériques sont une nouvelle fonctionnalité de Java SE 1.5. L'essence des génériques est un type paramétré, 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 :

1. Sécurité de type, fournissant une détection de type lors de la compilation

2. Compatibilité ascendante et descendante

3. être mis à jour Plus de réutilisation

4. Le code haute performance écrit en GJ (JAVA générique) peut apporter plus d'informations de type au compilateur Java et à la machine virtuelle. Ces informations peuvent optimiser davantage le programme Java.

140, Comment fonctionnent les génériques 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, variables et méthodes (effacement de type)

3. Si l'effacement de type entre en conflit avec le polymorphisme, générez une méthode de pont dans la sous-classe pour le résoudre

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

Effacement de 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, il n'y a donc 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 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 à la question sur les génériques, des questions de suivi vous seront posées sur les raisons pour lesquelles les génériques sont implémentés par effacement de type ou un code générique incorrect vous sera présenté qui entraînera une erreur du compilateur.

141, pouvez-vous transmettre Listf7e83be87db5cd2d9a8a0b8117b38cd4 à une méthode qui accepte le paramètre Lista87fdacec66f0909fc0757c19f2d2b1d

Pour tous ceux qui ne sont pas familiers avec les génériques, cette question sur les génériques Java peut sembler déroutante, car à première vue, String est un type d'objet, donc Listf7e83be87db5cd2d9a8a0b8117b38cd4 ;, 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 Chaîne s.

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

142, 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, le compilateur javac de Java 5 générera des avertissements de type non vérifiés, tels que

List<String> rawList = newArrayList()

Remarque : Hello.java utilise des opérations non contrôlées ou non sécurisées ;

Ce type d'avertissement peut être annoté avec @SuppressWarnings ("non vérifié") pour protéger.

143, 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 time Le compilateur n'effectuera pas de contrôles de sécurité de type sur les types primitifs, 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 String ou Integer.

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.

144, é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.

(Tutoriel recommandé :

cours Java )

145, les génériques peuvent-ils être utilisés dans Array

Il peut s'agir de génériques Java. la question d'entretien la plus simple.Bien sûr, le principe est que vous devez savoir qu'Array ne prend pas réellement en charge les génériques. C'est pourquoi Joshua Bloch recommande d'utiliser List au lieu de Array dans le livre Effective Java, car List peut fournir des types au moment de la compilation. La sécurité est garantie, contrairement à Array.

146, comment écrire une méthode générique pour qu'elle puisse accepter des paramètres génériques et renvoyer un type générique ?

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

public V put(K key, V value) {
return cahe.put(key,value);
}

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

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

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

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

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

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

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

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

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

相关推荐：java入门

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!