Verstehen Sie im Detail, was Java-Generika sind? Wie verwende ich Generika?
青灯夜游
Freigeben： 2018-10-19 17:38:29
nach vorne
4462 Leute haben es durchsucht
Dieser Artikel vermittelt Ihnen ein tiefgreifendes Verständnis darüber, was Java-Generika sind? Wie verwende ich Generika? Es hat einen gewissen Referenzwert. Freunde in Not können sich darauf beziehen. Ich hoffe, es wird Ihnen hilfreich sein.
1. Was sind Generika?
„Generika“ bedeutet, dass der geschriebene Code von verschiedenen Objekttypen wiederverwendet werden kann . Generics wurden vorgeschlagen, um mehr wiederverwendbaren Code zu schreiben. Die Essenz von Generika ist der parametrisierte Typ, d. h. der operierte Datentyp wird als -Parameter angegeben.
Zum Beispiel die gemeinsame Sammlungsklasse LinkedList:
public class LinkedList<e> extends AbstractSequentialList<e> implements List<e>,Deque<e>,Cloneable,Serializable{
//.....
transient Link<e> voidLink;
//.....
}</e></e></e></e></e>
Nach dem Login kopieren
Wie Sie sehen können, LinkedList Nach dem Klassennamen und dem Schnittstellennamen steht ein besonderer Teil es implementiert, und sein Mitgliedstyp Link enthält auch ein , Dieses Symbol ist ein Typparameter, der die Übergabe verschiedener Typen beim Erstellen einer LinkedList zur Laufzeit ermöglicht.
2. Warum Generika einführen
Vor Generika, Um eine allgemeine Methode zu implementieren, die verschiedene Typen verarbeiten kann, müssen Sie Object als Attribute und Methodenparameter verwenden, wie zum Beispiel diesen:
public class Generic{
private Object[] mData;
public Generic(int capacity){
mData = new Object[capacity];
}
public Object getData(int index){
//.....
return mData[index];
}
public void add(int index,Object item){
//.....
mData[index] = item;
}
}
Nach dem Login kopieren
Es verwendet ein Object-Array, um die Daten zu speichern Sie können bei der Verwendung verschiedene Objekttypen hinzufügen:
Generic generic = new Generic(10);
generic.add(0,"fangxing");
generic.add(1,23);
Nach dem Login kopieren
Object ist die übergeordnete Klasse aller Klassen, und alle Klassen können bei Bedarf als Mitglieder zu den oben genannten Klassen hinzugefügt werden Um verwendet zu werden, muss eine erzwungene Konvertierung durchgeführt werden, und diese erzwungene Konvertierung führt wahrscheinlich zu Konvertierungsausnahmen:
Die zweite Codezeile erzwingt eine Ganzzahl in einen String, und während der Laufzeit wird ein Fehler gemeldet:
Wie Sie sehen können, hat die Verwendung von Object zur Implementierung allgemeiner und unterschiedlicher Verarbeitungsarten die folgenden zwei Nachteile:
Sie müssen es jedes Mal, wenn Sie es verwenden, in den gewünschten Typ umwandeln
Der Compiler weiß nicht, ob die Typkonvertierung zur Kompilierungszeit normal ist, sondern nur zur Laufzeit, was unsicher ist
Gemäß der Beschreibung in „Java Programming Thoughts“ ist die Motivation für die Entstehung von Generika:
Es gibt Es gibt viele Gründe, die zur Entstehung von Generika beigetragen haben, und der faszinierendste Grund, auf den man achten sollte, ist die Erstellung von Containerklassen.
Nach dem Aufkommen von Generika in JDK 1.5 verwenden viele Sammlungsklassen Generika, um verschiedene Arten von Elementen zu speichern, wie z. B. Sammlung:
wurde tatsächlich eingeführt Die Hauptziele von Generika sind wie folgt:
Typensicherheit
Das Hauptziel von Generika ist die Verbesserung von Java Die Typsicherheit des Programms
ClassCastException-Ausnahmen, die durch falsche Java-Typen verursacht werden, können während der Kompilierung überprüft werden
Je früher sie erfüllt werden, desto kleiner die Kosten von Fehlern. Prinzip
Erzwungene Typkonvertierung eliminieren
Ein Nebenvorteil von Generika ist, dass Sie dies direkt tun können Holen Sie sich den Zieltyp, wenn Sie ihn verwenden. Eliminiert viele Umwandlungen
Was Sie erhalten, ist das, was Sie brauchen, was den Code besser lesbar macht und die Fehlerwahrscheinlichkeit verringert
potenziell Leistungssteigerungen
Aufgrund der Art und Weise, wie Generika implementiert werden, erfordert die Unterstützung von Generika (fast) keine JVM- oder Klassendateiänderungen
Die gesamte Arbeit wird im Compiler erledigt
Der vom Compiler generierte Code ist fast derselbe wie der Code, der ohne Verwendung von Generika (und Umwandlungen) geschrieben wurde. , einfach typsicherer Das ist alles
3. Wie man Generika verwendet
Das Wesentliche an Generika ist der parametrisierte Typ, was bedeutet, dass der Datentyp, mit dem gearbeitet wird, als Parameter angegeben wird. Die Bedeutung der Typparameter
besteht darin, dem Compiler den Typ der Instanz mitzuteilen, der in dieser Sammlung gespeichert werden soll, um beim Hinzufügen anderer Typen eine Aufforderung zu erhalten und die Typsicherheit zur Kompilierungszeit sicherzustellen.
Parametertypen können bei der Erstellung von Klassen, Schnittstellen und Methoden verwendet werden, die als generische Klassen, generische Schnittstellen bzw. generische Methoden bezeichnet werden.
public class GenericClass<f>{
private F mContent;
public GenericClass(F content){
mContent = content;
}
/*
泛型方法
*/
public F getContent(){
return mContent;
}
public void setContent(F content){
mcontent = content;
}
/*
泛型接口
*/
public interface GenericInterface<t>{
void doSomething(T t);
}
}</t></f>
Nach dem Login kopieren
泛型类
泛型类和普通类的区别就是类名后有类型参数列表 ，既然叫“列表”了，当然这里的类型参数可以有多个，比如 public class HashMap，参数名称由开发者决定。
类名中声明参数类型后，内部成员、方法就可以使用这个参数类型，比如上面的 GenericClass 就是一个泛型类，它在类名后声明了类型 F，它的成员、方法就可以使用 F 表示成员类型、方法参数/返回值都是 F 类型。
public class Generic implements GenericInterface{
@Override
public void doSomething(Object o){
//...
}
}
Nach dem Login kopieren
指明了类型的实现：
public class Generic implements GericInterface<string>{
@Override
public void doSomething(String s){
//.....
}
}</string>
Nach dem Login kopieren
泛型接口比较实用的使用场景就是用作策略模式的公共策略， Comparator就是一个泛型接口：
public interface Comparator<t>{
public int compare(T lhs, Trhs);
public bollean equals(Object object);
}</t>
Nach dem Login kopieren
泛型接口定义基本的规则，然后作为引用传递给客户端，这样在运行时就能传入不同的策略实现类。
泛型方法
泛型方法是指使用泛型的方法，如果它虽在的类是一个泛型类，那就很简单了，直接使用类声明的参数。
如果一个方法所在的类不是泛型类，或者他想要处理不同于泛型类声明类型的数据，那它就需要自己声明类型。
/*
传统的方法，会有unchecked ... raw type 的警告
*/
public Set union(Set s1, Set s2){
Set result = new HashSet(s1);
result.addAll(s2);
return result;
}
/*
泛型方法，介于方法修饰符和返回值之间的称作 类型参数列表<a>（可以有多个）
类型参数列表 指定参数、返回值中泛型的参数类型范围，命名惯例与泛型相同。
*/
public <e> Set<e> union2(Set<e> s1, Set<e> s2){
Set<e> result = new HashSet(s1);
result.addAll(s2);
return result;
}</e></e></e></e></e></a>
你可以把任何带参数的类型传递给原始类型 List，但 却不能把 List 传递给接受 List 的方法，因为泛型的不可变性，会产生编译错误。
九、补充
静态资源不认识泛型
接上一个话题，如果把去掉，那么：
private static T ifThenElse(boolean b, T first, T second){
return b ? first : second;
}
Nach dem Login kopieren
报错，T未定义。但是如果我们再把static去掉：
public class TestMain<t>{
public static void main(String[] args){}
@SuppressWarnings("unused")
private List<t> ifThenElse(boolean b,T first, T second){
return null;
}
}</t></t>
Das obige ist der detaillierte Inhalt vonVerstehen Sie im Detail, was Java-Generika sind? Wie verwende ich Generika?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
Der Inhalt dieses Artikels wird freiwillig von Internetnutzern beigesteuert und das Urheberrecht liegt beim ursprünglichen Autor. Diese Website übernimmt keine entsprechende rechtliche Verantwortung. Wenn Sie Inhalte finden, bei denen der Verdacht eines Plagiats oder einer Rechtsverletzung besteht, wenden Sie sich bitte an admin@php.cn
