The most complete summary of Java generic programming

1 Introduction

Java generic programming was introduced after JDK1.5 version. Generics allow programmers to use type abstractions, often within collections. The following is an example of not using generics:

List myIntList=new LinkedList(); //1  
myIntList.add(newInteger(0)); //2  
Integer x=(Integer)myIntList.iterator().next(); //3

Pay attention to the third line of code, but this is a very uncomfortable point, because the programmer must know that the object type stored in the List is Integer, but when returning the elements in the list , or the type must be cast, why is this? The reason is that the compiler can only ensure that the next() method of the iterator returns an object of type Object. In order to ensure the type safety of the Integer variable, it must be forced to convert.

This kind of conversion is not only confusing, but may also lead to type conversion exception ClassCastException. Runtime exceptions are often difficult to detect. Ensure that the elements in the list are of a specific data type, so that type conversion can be cancelled, reducing the chance of errors. This is also the original intention of generic design. The following is an example of using generics:

List<Integer> myIntList=newLinkedList<Integer>(); //1’  
myIntList.add(newInteger(0)); //2’  
Integerx=myIntList.iterator().next(); //3’

In the first line of code, specify that the object type stored in the List is Integer, so that there is no need to cast the type when obtaining the objects in the list.

2 Define simple generics

The following is a definition quoted from the interface List and Iterator in the java.util package, which uses generic technology.

public interface List<E> {  
<span style="white-space: pre;">    </span>void add(E x);  
<span style="white-space: pre;">    </span>Iterator<E> iterator();  
}  
public interface Iterator<E> {  
<span style="white-space: pre;">    </span>E next();  
<span style="white-space: pre;">    </span>boolean hasNext();  
}

This is no different from the native type, except that an angle bracket is added after the interface, and inside the angle bracket is a type parameter (it is a formatted type parameter when defined, and will be replaced by a specific type when calling type).

It may be thought that List means that the type parameter E in the List will be replaced with Integer.

public interface IntegerList {  
<span style="white-space: pre;">    </span>void add(Integer x)  
<span style="white-space: pre;">    </span>Iterator<Integer> iterator();  
}

Type erasure refers to associating generic type instances to the same bytecode through type parameter merging. The compiler only generates one bytecode for the generic type and associates its instances with this bytecode, so static variables in the generic type are shared by all instances. In addition, it should be noted that a static method cannot access the type parameters of a generic class because the class has not been instantiated. Therefore, if the static method needs to use generic capabilities, it must be made a generic method. The key to type erasure is to clear information about type parameters from generic types, and to add type checking and type conversion methods when necessary. When using generics, any concrete type is erased and the only thing you know is that you are using an object. For example: List and List are actually the same type in operation. They are all erased to their native type, which is List. Because there will be type erasure during compilation, methods cannot be distinguished by instances of the same generic class. For example, an error will occur during compilation in the following example, because after type erasure, both methods are parameters of the List type, so Methods cannot be distinguished based on the type of a generic class.

 public class Erasure{  
            public void test(List<String> ls){  
                System.out.println("Sting");  
            }  
            public void test(List<Integer> li){  
                System.out.println("Integer");  
            }  
  }

So there is a problem. Since the actual type information will be erased in methods and classes during compilation, how do you know the specific type when returning an object? For example, the String information of List will be erased after compilation. So when the objects in the List are returned through the iterator at runtime, how do we know that the objects stored in the List are String type objects?中 Remove the type information in the method body, so the problem at runtime is the boundary: that is, the place where the object enters and leave methods, which is exactly the place where the compiler executes the type check and inserts the transition code. All action in generics happens at boundaries: additional compile-time checks are performed on the values ​​passed in, and casts on the values ​​passed out are inserted.

3. Generics and subtypes

In order to fully understand generics, here is an example: (Apple is a subclass of Fruit

List<Apple> apples = new ArrayList<Apple>(); //1  
List<Fruit> fruits = apples; //2

第1行代码显然是对的，但是第2行是否对呢？我们知道Fruit fruit = new Apple()，这样肯定是对的，即苹果肯定是水果，但是第2行在编译的时候会出错。这会让人比较纳闷的是一个苹果是水果，为什么一箱苹果就不是一箱水果了呢？可以这样考虑，我们假定第2行代码没有问题，那么我们可以使用语句fruits.add(new Strawberry())（Strawberry为Fruit的子类）在fruits中加入草莓了，但是这样的话，一个List中装入了各种不同类型的子类水果，这显然是不可以的，因为我们在取出List中的水果对象时，就分不清楚到底该转型为苹果还是草莓了。

通常来说，如果Foo是Bar的子类型，G是一种带泛型的类型，则G不是G的子类型。这也许是泛型学习里面最让人容易混淆的一点。

4.通配符

4.1通配符？

先看一个打印集合中所有元素的代码。

void printCollection(Collection c) {                  
<span style="white-space: pre;">    </span>Iterator i=c.iterator();  
<span style="white-space: pre;">    </span>for (k=0;k < c.size();k++) {  
<span style="white-space: pre;">        </span>System.out.println(i.next());  
<span style="white-space: pre;">    </span>}  
}

void printCollection(Collection<Object> c) {  
for (Object e:c) {  
System.out.println(e);  
}  
}

很容易发现，使用泛型的版本只能接受元素类型为Object类型的集合如ArrayList