目录
1. java 方法返回值中使用泛型
public class FooService<T> {
// 使用泛型返回
public <T> T getFoo() {
Foo foo = new Foo();
foo.setId(1);
foo.setName("1");
return (T) foo;
}
// 使用Object 直接返回
public Object getFoObject() {
Foo foo = new Foo();
foo.setId(2);
foo.setName("2");
return foo;
}
public static void main(String[] args) {
FooService<Foo> my = new FooService<Foo>();
Foo foo1 = my.getFoo();
System.out.println(foo1.getName());
Foo foo2 = (Foo) my.getFoObject();
System.out.println(foo2.getName());
}
}
使用泛型后 getFoo 方法的返回值不需要强制类型转换，避免了发生
ClassCastException
异常，编译时更安全，因为泛型是再运行时才确定类型，而并非再编译时确定。
所以再使用泛型后，可以再同一方法灵活的实现返回值类型。
2. 定义泛型类、接口
定义任意泛型的类、接口，只要在定义它们时用<>来指定类型参数即可。
例如：public class Fruit<T> { … }，其中<T>指定了该泛型的类型参数，这个T是一个类型参数名，用户可以任意命名（就像方法参数的形参名一样），只有在使用该泛型的对象时将T替换成指定的具体类型从而产生一个实例化的泛型对象，例如：Fruit<String> fruit = new Fruit<>(…);
类型形参可以在整个接口、类体内当成普通类型使用，集合所有可使用普通类型的地方都可以使用类型形参，例如
public interface MyGneric<E> {
E add(E val);
Set<E> makeSet();
...
} 定义在<> 中的泛型的类型参数在定义他的类、接口里面就可以像普通类一样使用。
定义泛型构造器：泛型的构造器还是类名本身，不用使用菱形语法，定义构造器无需MyGeneric<T>(…) { … }了，只有在new的时候需要用到菱形语法；
public class MyGenric<T> {
MyGeneric(...) { ... }
...
} 实现/继承泛型接口/泛型类：
泛型也是在定义的时候必须使用形参（虚拟参数，用户自己随意命名），但是在使用泛型的时候（比如定义泛型引用、继承泛型）就必须使用实参，而泛型的实参就是具体的类型，像String、Integer等具体的类型（当然也可以是自定义类型）。Java还支持一种特殊的语法，可以让你从泛型继续派生出泛型，而泛型的类型参数可以继续传承下去；
class Father<T> { ... }
class Son<T> extends Father<T> { ... } 这个具体可以看 JDK 的 List 类，Collection 相关接口都是这么设计的。 在编译器中，是无法知道K和V具体是什么类型，只有在运行时才会真正根据类型来构造和分配内存。具体可以参考Map 接口的设计。
public class Container <K, V>{
private K key;
private V value;
public Container(K key, V value) {
this.key = key;
this.value = value;
}
public K getKey() {
return key;
}
public void setKey(K key) {
this.key = key;
}
public V getValue() {
return value;
}
public void setValue(V value) {
this.value = value;
}
public static void main(String[] args) {
Container<String, String> container = new Container<String, String>("1", "2");
System.out.println(container.getKey());
}
3. 定义泛型方法
定义泛型方法需要在返回值前加入 <T> 来声明这是一个泛型方法。当然返回值也可以不是T。如果在类名旁已经定义了<T>， 也可以直接在方法里返回 T ，不需要再方法的返回值前加入<T> 也可以使用。
public class FooService {
public <T> T getFoo() {
Foo foo = new Foo();
foo.setId(1);
foo.setName("1");
return (T) foo;
}
}
public class FooService<T> {
public T getFoo() {
Foo foo = new Foo();
foo.setId(1);
foo.setName("1");
return (T) foo;
}
}Class<T>的作用就是指明泛型的具体类型，而Class<T>类型的变量c，作为Class 类型的对象，c 就可以拥有Class 对象的方法，可以根据反射来创建泛型类的对象。
public class FooService<T> {
public T getT(Class<T> t) throws InstantiationException, IllegalAccessException {
T a= t.newInstance();
return a;
}
}
4. 泛型字母规范
- E — Element，常用在java Collection里，如：List<E>,Iterator<E>,Set<E>
- K,V — Key，Value，代表Map的键值对
- N — Number，数字
- T — Type，类型，如String，Integer等等
字母是没有特定意义的！只是为了提高可读性
5. Class<T>、T 、T.class 的区别
单独的T 代表一个类型 ，而 Class<T>代表这个类型所对应的类， Class<？>表示类型不确定的类。
6. 如何创建一个 Class<T> 类型的实例，
可以通过 Class.forName() 或者使用类常量 X.class 。 Class.forName() 被定义为返回 Class<?> 。 另一方面，类常量 X.class 被定义为具有类型 Class<X> , 所以 String.class 是 Class<String> 类型的。
7. 方法中为什么需要 <T> T 修饰
泛型的声明，必须在方法的修饰符（public,static,final,abstract等）之后，返回值声明之前。其中第一个<T>是与传入的参数Class<T>相对应的，相当于返回值的一个泛型，后面的T是返回值类型，代表方法必须返回T类型的（由传入的Class<T>决定）