Summary of Java Generics (1) - Detailed explanation of basic usage and type erasure

This article mainly introduces the use of Java generics and issues related to type erasure. Has very good reference value. Let’s take a look at it with the editor

Introduction

Java introduced the generic mechanism in 1.5. The essence of generics is parameterized types, that is to sayThe type of variable is a parameter, which is specified as a specific type when used. Generics can be used for classes, interfaces, and methods. By using generics, the code can be made simpler and safer. However, generics in Java use type erasure, so they are just pseudo-generics. This article summarizes the use of generics and existing problems, mainly referring to "Java Programming Thoughts".

The other two articles in this series:

• Summary of Java Generics (2): Generics and Arrays

• Summary of Java Generics (3): The use of wildcards

Basic usage

Generic classes

If there is a class Holder used to wrap a variable, the type of this variable may be arbitrary. How to write the Holder? Before there were generics, you could do this:

public class Holder1 {
 private Object a;
 public Holder1(Object a) {
 this.a = a;
 }
 public void set(Object a) {
 this.a = a;
 }
 public Object get(){
 return a;
 }
 public static void main(String[] args) {
 Holder1 holder1 = new Holder1("not Generic");
 String s = (String) holder1.get();
 holder1.set(1);
 Integer x = (Integer) holder1.get();
 }
}

In Holder1, there is a variable referenced by Object. Because any type can be upcast to Object, this Holder can accept any type. When taking it out, Holder only knows that it saves an Object Object, so it must be forced to the corresponding type. In the main method, holder1 first saves a string, which is a String object, and then changes to save an Integer object (parameter 1 will be automatically boxed). Casting when taking variables out of the Holder is already troublesome. You also have to remember different types here. If you make the wrong conversion, a runtime exception will occur.

Let’s take a look at the generic version of Holder:

public class Holder2<T> {
 private T a;
 public Holder2(T a) {
 this.a = a;
 }
 public T get() {
 return a;
 }
 public void set(T a) {
 this.a = a;
 }
 public static void main(String[] args) {
 Holder2<String> holder2 = new Holder2<>("Generic");
 String s = holder2.get();
 holder2.set("test");
 holder2.set(1);//无法编译 参数 1 不是 String 类型
 }
}

In Holder2, variable a is a parameterized type T. T is just an identifier, and other letters can also be used. When creating the Holder2 object, the type of parameter T is passed in angle brackets, then in this object, all occurrences of T are equivalent to being replaced with String. What get now takes out is not Object, but String object, so type conversion is not needed. In addition, when calling set, only the String type can be passed in, otherwise the compilation will not pass. This ensures type safety in holder2 and avoids accidentally passing in the wrong type.

Through the above example, we can see that pan makes the code simpler and safer. After the introduction of generics, some classes in the Java library, such as commonly used container classes, have also been rewritten to support generics. When we use them, we will pass in parameter types, such as: ArrayList list = ArrayList<>();.

Generic methods

Generics can not only target classes, but can also make a method generic individually. For example:

public class GenericMethod {
 public <K,V> void f(K k,V v) {
 System.out.println(k.getClass().getSimpleName());
 System.out.println(v.getClass().getSimpleName());
 }
 public static void main(String[] args) {
 GenericMethod gm = new GenericMethod();
 gm.f(new Integer(0),new String("generic"));
 }
}

代码输出：
 Integer
 String

public class ErasedTypeEquivalence {
 public static void main(String[] args) {
 Class c1 = new ArrayList<String>().getClass();
 Class c2 = new ArrayList<Integer>().getClass();
 System.out.println(c1 == c2);
 }
}

class HasF {
 public void f() {
 System.out.println("HasF.f()");
 }
}
public class Manipulator<T> {
 private T obj;
 public Manipulator(T obj) {
 this.obj = obj;
 }
 public void manipulate() {
 obj.f(); //无法编译 找不到符号 f()
 }
 public static void main(String[] args) {
 HasF hasF = new HasF();
 Manipulator<HasF> manipulator = new Manipulator<>(hasF);
 manipulator.manipulate();
 }
}

class Manipulator2<T extends HasF> {
 private T obj;
 public Manipulator2(T x) { obj = x; }
 public void manipulate() { obj.f(); }
}

class Manipulator3 {
 private HasF obj;
 public Manipulator3(HasF x) { obj = x; }
 public void manipulate() { obj.f(); }
}

class ReturnGenericType<T extends HasF> {
 private T obj;
 public ReturnGenericType(T x) { obj = x; }
 public T get() { return obj; }
}

public class Erased<T> {
 private final int SIZE = 100;
 public static void f(Object arg) {
 if(arg instanceof T) {} // Error
 T var = new T(); // Error
 T[] array = new T[SIZE]; // Error
 T[] array = (T)new Object[SIZE]; // Unchecked warning
 }
}

interface FactoryI<T> {
 T create();
}
class Foo2<T> {
 private T x;
 public <F extends FactoryI<T>> Foo2(F factory) {
 x = factory.create();
 }
 // ...
}
class IntegerFactory implements FactoryI<Integer> {
 public Integer create() {
 return new Integer(0);
 }
}
class Widget {
 public static class Factory implements FactoryI<Widget> {
 public Widget create() {
 return new Widget();
 }
 }
}
public class FactoryConstraint {
 public static void main(String[] args) {
 new Foo2<Integer>(new IntegerFactory());
 new Foo2<Widget>(new Widget.Factory());
 }
}

abstract class GenericWithCreate<T> {
 final T element;
 GenericWithCreate() { element = create(); }
 abstract T create();
}
class X {}
class Creator extends GenericWithCreate<X> {
 X create() { return new X(); }
 void f() {
 System.out.println(element.getClass().getSimpleName());
 }
}
public class CreatorGeneric {
 public static void main(String[] args) {
 Creator c = new Creator();
 c.f();
 }
}