Umfassende detaillierte Erklärung der Java-Generika

Im täglichen Leben verwenden wir häufig Generika, aber generische Daten melden manchmal unerklärliche Fehler, und einige Syntaxen wie Platzhalter und die tatsächliche Funktionsweise von Generika in der virtuellen Maschine sind ebenfalls eine Untersuchung wert. Heute werden wir Generika gemeinsam besprechen .

(1) Erstellung

Bevor Generika zu Java hinzugefügt wurden, wurde Vererbung verwendet, um Programme zu verwalten, die jetzt mit Generika arbeiten.

ArrayList files = new ArrayList();String filename = (String) files.get(0);

ArrayList<String> files2 = new ArrayList<>();
//后一个尖括号中的内容可以省略，在1.7之后String filename2= files2.get(0);String addname = "addname";

files2.add(addname);
//在add函数调用之时，ArrayList泛型会自动检测add的内容是不是String类型
files2.add(true);
//报错 The method add(String) in the type ArrayList<String> is not applicable for the arguments (boolean)

Zum Beispiel verwaltet die ArrayList-Klasse nur ein Array von Objektreferenzen, wenn der Wert abgerufen wird (die ersten beiden Zeilen oben), und es gibt keine Garantie für die Übergabe von Inhalten. Mit Generika wird diese Datenstruktur bequem, lesbar und sicher. Wir können auf einen Blick erkennen, dass der im ArrayList Andere Wertetypen können der Liste nicht hinzugefügt werden.

Darüber hinaus möchte ich darauf hinweisen, dass die ersten beiden Zeilen des obigen Codes keine Fehler enthalten. Denn in ArrayList ist es in Ordnung, <> nicht zu verwenden. Es gibt immer noch viele Einschränkungen bei generischen Klassen. Bei Bedarf wird auch die ArrayList-Klasse verwendet.

(2) Generische Klasse

Nehmen wir direkt eine einfache generische Klasse:

public class Pair<T> {    
private T first;    
private T second;    
public Pair() {
        first = null;
        second = null;
    }    public Pair(T first, T second) {        
    this.first = first;        
    this.second = second;
    }    
    public T getFirst() {        
    return first;
    }    
    public void setFirst(T first) {        
    this.first = first;
    }    
    public T getSecond() {        
    return second;
    }    
    public void setSecond(T second) {        
    this.second = second;
    }

}

Tatsächlich kann die generische Klasse als angesehen werden Für gewöhnliche Klassenfabriken ersetzen Sie einfach T durch den Typ, den wir benötigen. Dann müssen wir für Situationen, in denen zwei Typen erforderlich sind, nur Pair schreiben. Die beiden Felder T und U verwenden jeweils unterschiedliche Typen.

Das obige Beispiel ist zu einfach und kann keine wesentliche Arbeit leisten. Denken Sie also bitte über diese Frage nach, wenn wir der obigen generischen Klasse eine Funktion hinzufügen:

public T min(T[] array) {...}//返回传入数组中的最小值

Also zu diesem Zeitpunkt Wenn wir diese Funktion implementieren möchten, müssen wir zumindest sicherstellen, dass Objekte vom Typ T in ihrer Größe verglichen werden können. Wie erkennt man diese Situation? Tatsächlich können wir dieses Problem lösen, indem wir Grenzwerte für die Typvariable T festlegen. Sie können die Bedeutung von

public <T extends Comparable>T min(T[] array){...}//T如果没有实现compare方法则报错不执行min函数

<T extends Comparable> fast erraten, nämlich dass die Typvariable T erforderlich ist, um die Comparable-Schnittstelle zu erben. Jetzt kann die generische Min-Methode nur von Arrays von Klassen aufgerufen werden, die die Comparable-Schnittstelle implementieren (z. B. String, Date ...), und andere Klassen erzeugen einen Kompilierungsfehler.
Ebenso kann es auch mehrfache Einschränkungen geben: <T，U extends Comparable&Serializable> ist auch erlaubt. Kommas werden zum Trennen von Typvariablen und & zum Trennen qualifizierter Typen verwendet.

Tatsächlich ist Comparable selbst eine generische Schnittstelle. Damit der obige Inhalt leicht verständlich ist, geben wir vor, verwirrt zu sein und zu denken, dass es sich nicht um eine generische Schnittstelle handelt. Es sollte jedoch beachtet werden, dass die tatsächliche korrekte Schreibweise lautet: > statt

) Generische Methoden

1. Generische Methoden in gewöhnlichen Klassen

Generika, die in einer generischen Klasse definiert sind, sind in der gesamten Klasse gültig. Das heißt, nachdem das Objekt der generischen Klasse den spezifischen zu bedienenden Typ bestimmt hat, sind alle zu bedienenden Typen bereits festgelegt. Beispielsweise ist ArrayList der generische Typ der gesamten ArrayList an den String-Typ gebunden und kann nicht geändert werden. In einigen Fällen benötigen wir jedoch mehr Flexibilität, damit die Methode mit verschiedenen unsicheren Typen arbeiten kann.

    public <T> T getMid(T[] array){        
    return array[array.length/2];
    }

Zum Beispiel wird in der obigen getMid-Funktion das Hinzufügen von <T> vor dem Rückgabewert T zu einer generischen Methode. Bitte beachten Sie, dass es sich um eine gewöhnliche Klasse handelt und generische Methoden nicht unbedingt in generischen Klassen vorhanden sein müssen. Das Folgende ist ein Beispiel für den Aufruf einer generischen Methode. Wenn eine generische Methode aufgerufen wird, leitet der Compiler die aufgerufene Methode basierend auf dem folgenden Typ ab, sodass nicht explizit angegeben werden muss, um welchen Typ T es sich handelt:

String mid = ArrayAlg.getMid("Jone" , "Q" , "Peter");
//okdouble mid2 = ArrayAlg.getMid(3.14 , 25.9 , 20);
//error，编译器会把20自动打包成Integer类型，而其他打包成Double类型，我们尽量不要让这种错误发生

2. Generische Methoden in generischen Klassen

In gewöhnlichen Klassen können wir über die oben genannten generischen Methoden flexibel verschiedene Typparameter aufrufen. Brauchen wir in generischen Klassen solche flexiblen generischen Methoden? Ich denke, es ist nicht nötig. Wir stellen Typparameter für generische Klassen bereit. Wenn wir sie verwenden müssen, verwenden wir im Allgemeinen die Methode mehrerer Typparameter wie Pair Definieren Sie eine generische Klasse, um den Typ zu verwenden.
Was nützen generische Methoden in generischen Klassen? Wir können generische Methoden in generischen Klassen verwenden, um generische Variablen einzuschränken. Die oben erwähnte <T extends Comparable>T-Methode kann beispielsweise nur von T mit der Comparable-Schnittstelle verwendet werden, andernfalls tritt ein Fehler auf.

@SuppressWarnings("hiding")
public static <T extends Comparable<?> & Serializable> T min(T[] array) {...}

（四） 虚拟机中的泛型

1.虚拟机中没有泛型，只有普通的类和方法

java虚拟机中没有泛型类型对象——所有的对象都属于普通类，那么虚拟机是怎么用普通类来模拟出泛型的效果呢？
只要定义了一个泛型类，虚拟机都会自动的提供一个原始类型。原始类型的名字就是删除类型参数的泛型类的名字。擦除类型变量，并替换为第一个限定类型（如果没有限定则用Object来替换）。
比如，我们在一开始给出的简单泛型类Pair<T>在虚拟机中会变成如下的情况：

public class Pair {    
private Object first;    
private Object second;    
public Pair() {
        first = null;
        second = null;
    }    
    public Pair(Object first, Object second) {        
    this.first = first;        
    this.second = second;
    }    
    public Object getFirst() {        
    return first;
    }    
    public void setFirst(Object first) {        
    this.first = first;
    }    
    public Object getSecond() {        
    return second;
    }    
    public void setSecond(Object second) {        
    this.second = second;
    }

}

这就是擦除了类型变量，并且将没有限制的T换成Object之后的情况，如果有限定类型，比如，我们的泛型类是Pair按照替换为第一个限定类型的规定，替换后的情况如下：

public class Pair {    
private Compararble first;    
private Compararble second;    
public Pair() {
        first = null;
        second = null;
    }    
    public Pair(Compararble first, Compararble second) {        
    this.first = first;        
    this.second = second;
    }    
    public Compararble getFirst() {        
    return first;
    }    
    public void setFirst(Compararble first) {        
    this.first = first;
    }    
    public Compararble getSecond() {        
    return second;
    }    
    public void setSecond(Compararble second) {        
    this.second = second;
    }

}

那么既然类型都被擦除了，类型参数也被替换了，怎么起到泛型的效果呢？当程序调用泛型方法时，如果返回值是类型参数（就是返回值是T），那么编译器会插入强制类型转换：

Pair<String> a = ...;
String b = a.getFirst();//编译器强制将a.getFirst()的Object类型的结果转换为String类型

编译器将上述过程翻译位两条虚拟机指令：
- 对原始方法Pair.getFirst的调用。
- 将返回的Object类型强制转换为String类型。

2.翻译泛型方法，桥方法被使用以保持多态性

对于类型擦出也出现在泛型方法中，但是泛型方法中的擦除带来很多问题：

//----------------类A擦除前----------------------class A extends Pair<Date>{
    public void setSecond(Date second){...}
}//----------------类A擦除后----------------------class A extends Pair{
    public void setSecond(Date second){...}
}

从上面的代码中，我们可以看出，类A重写了Pair中的setSecond方法，看似合情合理，但是一旦擦除之后就发生了问题。将Pair擦除后，原函数变为：

public Class Pair{
    public void setSecond(Object second){...}
}

突然发现，父类Pair中的setSecond方法参数变为Object，和子类中的参数不同。擦除之后，父类的setSecond方法和子类的setSecond方法完全变为两个不一样的方法！这就没有了重写之说，那么接着考虑下面的语句：

A a = new A();Pair<Date> pair = a;pair.setSecond(new Date());
//当pair去调用setSecond函数时，有两个不一样的setSecond函数可以被调用，一个是父类中参数为Object的，一个是子类中参数为Date的。

第三行的调用出现了两种情况，这绝对不是我们想要的结果，我们开始的时候只是重写了父类中的setSecond方法，但是现在有两个不同的setSecond方法可以被使用，而且这时编译器不知道要去调用哪个。
为了防止这种情况的发生，编译器会在A类（子类）中生成一个桥方法：

//------------桥方法--------------
public void setSecond(Object second){ setSecond((Date)second); }

这个桥方法，让Object参数的方法去调用Date参数的方法，从而将两个方法合二为一，这个桥方法不是我们自己写的，而是在虚拟机中自动生成的，让代码变得安全，让运行结果变得符合我们的期望。

（五） 通配符 “？”

当两个有关系的类分别作为两个泛型类的类型变量的时候，这两个泛型类是没有关系的。这个时候如果需要涉及到继承规则之类的内容时，那么就需要使用通配符——“？”。

1. 子类型限定和超类型限定（上下界限定）

有的时候两个类间有继承关系，但是分别作为泛型类型变量之后就没了关系，在函数调用和返回值的时候，这种不互通尤为让人头痛。好在通配符的上下界限定类型为我们安全的解决了这个难题。
？ super A的意思是“？是A类型的父类型”，? extends A的意思是“？是A类型的子类型”。
既然知道了意思,我们看一下下面这四种用法：

public static void printA (Pair<? super A> p) {...} //ok
public static void printA (Pair<? extends A> p) {...} //error
public static Pair<? extends A> printA () {...} //ok
public static Pair<? super A> printA () {...} //error

为什么四种中有两种有错误呢？
实际上，要牢记这句话：带有超类型限定的通配符可以向泛型对象写入（做参数），带有子类型限定的通配符可以从泛型对象读取（做返回值）。道理这里就不详细讲了，如果有兴趣研究的话可以思考一下，思考的方向无非是继承关系之间的引用转换，只有上面两行ok的方法才是转换安全的。现在我们可以试着去理解上面的>了。

2. 无限定通配符

无限定通配符的用法其实很单一。无限定通配符修饰的返回值只能为Object，而其做参数是不可以的。那么无限定通配符的用处在哪里呢？源于他的可读性好。

public static boolean hasNulls(Pair<?>){...}

上面的代码的意思是对于任何类型的Pair泛型判断是否为空，这样写比用T来表示可读性确实好的多。

（六） 泛型注意事项

1. 不能用基本类型实例化类型参数

八大基本类型务必要使用包装类来实例化，否则泛型参数一擦除我们就傻眼了，怎么把int的数据放到Object里面呢？

2. 不能创建参数化类型数组

参数化的类型数组是不能被创建的。我们完全可以用多个泛型嵌套来避免这种情况的发生，如果创建了泛型数组，擦除之后类型会变成Object[ ]，如果有一个类型参数不同的泛型存入这个数组时，因为都被擦除成Object，所以不会报错，导致了错误的发生。需要说明的是，只是不允许创建这些数组，而声明类型为Pair[]的变量是合法的，只不过不能用new Pair[10]初始化这个变量。更确切地表达是：数组类型不能是类型变量，采用通配符的方式是可以允许的。

3. 运行时类型查询只适用于原始类型

要记住在虚拟机中，每个对象都有一个特定的非泛型类。所以，所有的类型查询只产生原始类型。比如：

if(a instanceof Pair<String>) //只能测试a是否是任意类型的一个Pair
Pair<String> sp = ...;
sp.getClass(); //获得的也是Pair（原始类型）

4. 不能实例化类型变量

有的时候我们需要将类型变量实例化成它自己本身的类型，但是一定要注意写法，不可以直接实例化类型变量：

public Pair() {    this.first = new T();//错误，类型擦除后T变成Object，new Object()肯定不是想要的
    this.first = T.class.newInstance();//错误，T.class是不合法的写法}

上述的两种写法都是错的，如果一定要这样做的话，也只能在调用泛型类的时候构造出一个方法（构造的方法不在泛型类中，在调用泛型类的普通类中），将你要用的类型作为参数传进去，想办法来实例化。

5. 泛型类的静态上下文中类型变量无效

不能在静态域中引用类型变量，静态方法本来就是和对象无关，他怎么能知道你传进来的是什么类型变量呢？

6. 不能抛出或者捕获泛型类实例

既不能抛出也不能捕获泛型对象。事实上，甚至泛型类扩展Throwable都是不可以的，但是平时我们不去编写泛型类的时候，这一条并不需要注意过多。

7. 继承关系的类分别成为类型参数后无关系

当两个有关系的类分别作为两个泛型类的类型变量的时候，这两个泛型类是没有关系的。这个时候如果需要涉及到继承规则之类的内容时，一定要使用通配符，坚决不要手软。

8. 泛型类的静态方法必须作为泛型方法

泛型类的静态方法因为是静态，所以也不能获得类型变量，在这个时候唯一的解决办法是——所有的静态方法都是泛型方法。

9. 通配符不能作为一种类型使用

? t = p.getA(); //error

所有用“？”来作为类型的写法都是不被允许的，我们需要用T来作为类型参数，有必要的时候可以做一个辅助函数，用T类型来完成工作，用？通配符来做外面的包装，既达到了目的，又提高了可读性。

（七）  总结

泛型为我们提供了许许多多的便利，包装出来的很多泛型类让我们能更快速安全的工作。而泛型的底层实现原理也是很有必要研究一下的，一些需要我们注意的事项和通配符的使用，此类细节也确实有许多值得我们学习之处。

在日常生活中，我们经常用到泛型，但是泛型数据有些时候会报一些莫名其妙的错，而且一些通配符等语法、泛型在虚拟机中的真正操作方式也有我们值得研究之处，今天我们就一起来讨论一下泛型。

 以上就是java泛型综合详解的内容，更多相关内容请关注PHP中文网（www.php.cn）！