Java泛型Generic机制实例详解

public class Pair<T, U> {
  public T first;
  public U second;
  public Pair(T first, U second) {
    this.first = first;
    this.second = second;
  }
}

Pair<Integer, String> pair = new Pair<>(1, "A");

public static <T> T getMiddle(T... a) {
  return a[a.length / 2];
}

public interface Animal {
  String getName();
}
public static class Printer<T extends Animal> {
  public void print(T t) {
    System.out.println(t.getName());
  }
}
public static class Dog implements Animal {
  @Override
  public String getName() {
    return "Woof";
  }
}
public static class Cat implements Animal {
  @Override
  public String getName() {
    return "Meow";
  }
}
public static void main(String[] args) {
  Printer<Animal> animalPrinter = new Printer<>();
  animalPrinter.print(new Dog());
  animalPrinter.print(new Cat());
  animalPrinter.print(new People("Abc")); // 如果试图传入一个其他类型，则会编译失败
}

public class Printer<T extends Dog & Animal> {
  ...
}

public class Printer<T> {
  ...
}

public class Printer<T extends Animal> {
  ...
}

public class Printer<T extends Dog & Animal> {
  ...
}

List<Dog> dogs = new ArrayList<>();
List<Animal> animals = dogs; // 编译报错

List<? extends Animal> animals = new ArrayList<Dog>(); // 可以正确赋值了
animals.add(new Dog()); // 编译错误，类型不匹配，无法写入，除非写入 null（也就是参数类型无法作为入参的类型）
Animal animal = animals.get(0); // 可以获取（也就是参数类型可作为返回值类型）

List<Animal> animals = new ArrayList<>();
List<? super Dog> dogs = animals; // 可以正确赋值！

dogs.add(new Dog()); // 可以写入
Dog dog = dogs.get(0); // 编译报错，类型不匹配： Required type: Dog  Provided: capture of ? super Dog

public static boolean hasNull(Pair<?> p) {
  return p.first != null && p.second != null;
}

public static <T extends Comparable<? super T>> T min(T[] a)

public static Comparable min(Comparable[] a)

public class GenericReflectionTest {
  public static void main(String[] args) {
    String className;
    try (Scanner scanner = new Scanner(System.in)) {
      System.out.println("Enter class name (e.g., java.util.Collections): ");
      className = scanner.next();
    }
    try {
      Class<?> cl = Class.forName(className);
      ClassPrinter.print(cl);
    } catch (ClassNotFoundException e) {
      e.printStackTrace();
    }
  }
  public static class ClassPrinter {
    public static void print(Class<?> cl) {
      System.out.print(cl);
      printTypes(cl.getTypeParameters(), "<", ", ", ">", true);
      final Type sc = cl.getGenericSuperclass();
      if (sc != null) {
        System.out.print(" extends ");
        printType(sc, false);
      }
      printTypes(cl.getGenericInterfaces(), " implements ", ", ", "", false);
      System.out.print(" {");
      System.out.println();
      final Method[] methods = cl.getDeclaredMethods();
      for (int i = 0; i < methods.length; i++) {
        final Method method = methods[i];
        printMethod(method);
        if (i < methods.length - 1) {
          System.out.println();
        }
      }
      System.out.println();
      System.out.print("}");
    }
    private static void printTypes(Type[] types, String pre, String sep, String suf, boolean isDefinition) {
      if (pre.equals(" extends ") && Arrays.equals(types, new Type[]{Object.class})) {
        return;
      }
      if (types.length > 0) {
        System.out.print(pre);
      }
      for (int i = 0; i < types.length; i++) {
        if (i > 0) {
          System.out.print(sep);
        }
        printType(types[i], isDefinition);
      }
      if (types.length > 0) {
        System.out.print(suf);
      }
    }
    private static void printType(Type type, boolean isDefinition) {
      if (type instanceof Class) { // 具体类型
        Class<?> cl = (Class<?>) type;
        System.out.print(cl.getName());
      } else if (type instanceof TypeVariable) { // 类型变量
        TypeVariable<?> tv = (TypeVariable<?>) type;
        System.out.print(tv.getName());
        if (isDefinition) {
          printTypes(tv.getBounds(), " extends ", " & ", "", false);
        }
      } else if (type instanceof WildcardType) { // 通配符
        WildcardType wt = (WildcardType) type;
        System.out.print("?");
        printTypes(wt.getUpperBounds(), " extends ", " & ", "", false);
        printTypes(wt.getLowerBounds(), " super ", " & ", "", false);
      } else if (type instanceof ParameterizedType) { // 泛型类或接口类型
        ParameterizedType pt = (ParameterizedType) type;
        Type ownerType = pt.getOwnerType();
        if (ownerType != null) {
          printType(ownerType, false);
        }
        printType(pt.getRawType(), false);
        printTypes(pt.getActualTypeArguments(), "<", ", ", ">", false);
      } else if (type instanceof GenericArrayType) { // 泛型数组
        GenericArrayType gat = (GenericArrayType) type;
        printType(gat.getGenericComponentType(), isDefinition);
        System.out.print("[]");
      } else {
        System.out.print("unknown type: " + type);
      }
    }
    private static void printMethod(Method m) {
      final String name = m.getName();
      System.out.print("  ");
      System.out.print(Modifier.toString(m.getModifiers()));
      System.out.print(" ");
      printTypes(m.getTypeParameters(), "<", ", ", ">", true);
      printType(m.getGenericReturnType(), false);
      System.out.print(" ");
      System.out.print(name);
      System.out.print("(");
      printTypes(m.getGenericParameterTypes(), "", ", ", "", false);
      System.out.print(")");
    }
  }
}

public class TestClass<T extends Comparable<? super T>> implements Cloneable {
  public void test(T t) {
    System.out.println(t);
  }
}

class com.airsaid.java.samples.generic.TestClass<T extends java.lang.Comparable<? super T>> extends java.lang.Object implements java.lang.Cloneable {
  public void test(T)
}

Foo<DataBean> foo = new Foo<DataBean>();
gson.fromJson(json, foo.getClass());

Foo<DataBean> foo = new Foo<DataBean>();
gson.fromJson(json, new TypeToken<Foo<DataBean>>(){});

public class TypeToken<T> {
  private final Type type;
  protected TypeToken() {
    this.type = getTypeTokenTypeArgument();
  }
  public Type getType() {
    return type;
  }
  private Type getTypeTokenTypeArgument() {
    final Type superclass = getClass().getGenericSuperclass();
    if (superclass instanceof ParameterizedType) {
      ParameterizedType parameterized = (ParameterizedType) superclass;
      if (parameterized.getRawType() == TypeToken.class) {
        return parameterized.getActualTypeArguments()[0];
      }
    } else if (superclass == TypeToken.class) {
      throw new IllegalStateException("TypeToken must be created with a type argument: new TypeToken<...>() {}; "
                                      + "When using code shrinkers (ProGuard, R8, ...) make sure that generic signatures are preserved.");
    }
    throw new IllegalStateException("Must only create direct subclasses of TypeToken");
  }
}

public class TypeTokenTest {
  public static void main(String[] args) {
    TypeToken<?> typeToken = new TypeToken<List<String>>() {};
    System.out.println(typeToken.getType()); // java.util.List<java.lang.String>
  }
}

if (a instanceof Pair<String>) // 错误

Pair<String>[] table = new Pair<String>[10]; // 错误

class Generic<T> extends Exception {
}

try {
    ...
} catch (Generic<String> e) {
} catch (Generic<Integer> e) {
}