Fragen zu Java-Generika-Interviews

Was sind Generika in Java? Welche Vorteile bietet die Verwendung von Generika?

Generikatypen sind Eine neue Funktion von Java SE 1.5. Der Kern von Generics sind parametrisierte Typen, was bedeutet, dass der Datentyp, mit dem gearbeitet wird, als Parameter angegeben wird.

Vorteile:                                                                                                                                                                                                                                             >2. Abwärts- und Abwärtskompatibilität3. Hohe Leistung, Code In GJ (generisches JAVA) geschrieben, kann es für Java kompiliert werden. Der Server und die virtuelle Maschine bringen mehr Typinformationen mit, was Bedingungen für die weitere Optimierung von Java-Programmen bietet.

Wie funktionieren Generika in Java? Was ist Typlöschung?

1. Typprüfung: Typprüfung vor der Generierung von Bytecode durchführen

2. Typlöschung: Alle Typparameter werden durch ihre qualifizierten Typen ersetzt, einschließlich Klassen, Variablen und Methoden (Typlöschung). )

3. Wenn Typlöschung und Polymorphismus in Konflikt stehen, wird in der Unterklasse eine Brückenmethode generiert, um das Problem zu lösen 4. Wenn eine generische Methode aufgerufen wird, wird eine Umwandlung durchgeführt wird beim Aufruf der Methode eingefügt

Typlöschung:

Alle Typparameter werden durch ihre qualifizierten Typen ersetzt:

Zum Beispiel T-> Objekt? Zur Laufzeit liegen keine typbezogenen Informationen vor. Beispielsweise wird Listf7e83be87db5cd2d9a8a0b8117b38cd4 zur Laufzeit nur durch eine Liste dargestellt.

Der Zweck besteht darin, die Kompatibilität mit binären Klassenbibliotheken sicherzustellen, die in Versionen vor Java 5 entwickelt wurden. Sie können zur Laufzeit nicht auf die Typparameter zugreifen, da der Compiler den generischen Typ in einen primitiven Typ konvertiert hat. Abhängig von Ihrer Antwort auf diese generische Frage erhalten Sie einige Folgefragen, z. B. warum Generika durch Typlöschung implementiert werden, oder es werden Ihnen einige falsche Generika angezeigt, die Compiler-Fehler verursachen.

Können Sie eine Listf7e83be87db5cd2d9a8a0b8117b38cd4 an eine Methode übergeben, die einen Lista87fdacec66f0909fc0757c19f2d2b1d akzeptiert?

Für alle, die sich mit Generika nicht auskennen, sieht diese Frage zu Java-Generika verwirrend aus, denn auf den ersten Blick ist String eine Art Objekt, also sollte List58709d3cf0aeaa51ac7bfcab7db27ec4 wird erwartet, ist es aber nicht. Dies führt zu Kompilierungsfehlern.

Wenn Sie weiter darüber nachdenken, werden Sie feststellen, dass dies für Java sinnvoll ist, da Lista87fdacec66f0909fc0757c19f2d2b1d jede Art von Objekt speichern kann, einschließlich String, Integer usw., während Listf7e83be87db5cd2d9a8a0b8117b38cd4 kann nur zum Speichern von Strings verwendet werden.

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

Wie verhindere ich ungeprüfte Typwarnungen in Java?

Wenn Sie generische und primitive Typen mischen, wie den folgenden Code, javac in Java 5 Der Compiler generiert Warnungen vom Typ ungeprüft, wie z. B.

List<String> rawList = newArrayList()

Hinweis: Hello.java verwendet ungeprüfte oder unsichere Vorgänge;
Diese Art von Warnung kann mit der Annotation @SuppressWarnings("unchecked") blockiert werden.

Was ist der Unterschied zwischen Lista87fdacec66f0909fc0757c19f2d2b1d und dem primitiven Typ List in Java?

Der Hauptunterschied zwischen dem primitiven Typ und dem parametrisierten Typ a87fdacec66f0909fc0757c19f2d2b1d Der Unterschied besteht darin, dass der Compiler zur Kompilierungszeit keine Typsicherheitsprüfungen für primitive Typen durchführt, sondern Typen mit Parametern überprüft. Durch die Verwendung von Object als Typ können Sie dem Compiler mitteilen, dass die Methode jeden Objekttyp akzeptieren kann, z String oder Integer.

Der Testpunkt dieser Frage liegt im richtigen Verständnis primitiver Typen in Generika. Der zweite Unterschied besteht darin, dass Sie jeden Typ mit Parametern an den primitiven Typ List übergeben können, Listf7e83be87db5cd2d9a8a0b8117b38cd4 jedoch nicht an eine Methode übergeben können, die Lista87fdacec66f0909fc0757c19f2d2b1d akzeptiert, da sonst ein Kompilierungsfehler auftritt.

Ein generisches Programm schreiben, um den LRU-Cache zu implementieren?

Für diejenigen, die Java-Programmierung mögen, entspricht dies einer Übung. Um Ihnen einen Hinweis zu geben: LinkedHashMap kann zum Implementieren eines LRU-Cache mit fester Größe verwendet werden. Wenn der LRU-Cache voll ist, wird das älteste Schlüssel-Wert-Paar aus dem Cache verschoben. LinkedHashMap bietet eine Methode namens „removeEldestEntry()“, die von put() und putAll() aufgerufen wird, um das älteste Schlüssel-Wert-Paar zu löschen. Wenn Sie bereits einen laufenden JUnit-Test geschrieben haben, steht es Ihnen natürlich frei, Ihren eigenen Implementierungscode zu schreiben.

Können Generika in Array verwendet werden?

这可能是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++中，类型参数不同，实例变量也不同。

Das obige ist der detaillierte Inhalt vonFragen zu Java-Generika-Interviews. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!