之前对java泛型这个知识点，都是一知半解，经过朋友推荐的文章和网上一些比较知名的博客的学习，终于有了一定的了解，今天简单写写一些自己的见解，借鉴一些前辈的文章，如果有错误，请及时指出，希望自己的文章对你们有所帮助。
理解最重要！！！
1.什么是泛型
Java泛型编程是JDK1.5版本后引入的。泛型让编程人员能够使用类型抽象，通常用于集合里面。
泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。
在使用泛型前，存入集合中的元素可以是任何类型的，当从集合中取出时，所有的元素都是Object类型，需要进行向下的强制类型转换，转换到特定的类型。而强制类型转换容易引起运行时错误。
泛型类型参数只能被类或接口类型赋值，不能被原生数据类型赋值，原生数据类型需要使用对应的包装类。
在Java 5之前，为了让类有通用性，往往将参数类型、返回类型设置为Object类型，当获取这些返回类型来使用时候，必须将其“强制”转换为原有的类型或者接口，然后才可以调用对象上的方法。
我们来通过对比来看看使用泛型和不使用泛型的区别
例子：
不使用泛型
public class Test2{
privateObjectob;// 定义一个通用类型成员
publicTest2(Objectob) {
this.ob=ob;
}
publicObjectgetOb() {
returnob;
}
public voidsetOb(Objectob) {
this.ob=ob;
}
public voidshowTyep() {
System.out.println("T的实际类型是: "+ob.getClass().getName());
}
}
public class TestDemo2 {
public static void main(String[] args) {
// 定义类Gen2的一个Integer版本
Test2 intOb = new Test2(new Integer(88));
intOb.showTyep();
int i = (Integer) intOb.getOb();
System.out.println("value= " + i);
System.out.println("---------------------------------");
// 定义类Gen2的一个String版本
Test2 strOb = new Test2("Hello Gen!");
strOb.showTyep();
String s = (String) strOb.getOb();
System.out.println("value= " + s);
}
}
运行结果
T的实际类型是: java.lang.Integer
value= 88
---------------------------------
T的实际类型是: java.lang.String
value= Hello Gen!
强制转换类型缺点
需要事先知道各个Object具体类型是什么，才能做出正确转换。
如果改用 Java5泛型来实现会更加简便。
接下来 让我们重构一下（使用泛型）
public class Test<T> {
private T ob; // 定义泛型成员变量
public Test(T ob) {
this.ob = ob;
}
public T getOb() {
return ob;
}
public void setOb(T ob) {
this.ob = ob;
}
public void showType() {
System.out.println("T的实际类型是: " + ob.getClass().getName());
}
}
public class TestDemo {
public static void main(String[] args) {
// 定义泛型类Gen的一个Integer版本
Test<Integer> intOb = new Test<>(88) ;
intOb.showType();
int i = intOb.getOb();
System.out.println("value= " + i);
System.out.println("----------------------------------");
// 定义泛型类Gen的一个String版本
Test<String> strOb = new Test<>("hello world");
strOb.showType();
String s = strOb.getOb();
System.out.println("value= " + s);
}
}
运行结果
T的实际类型是: java.lang.Integer
value= 88
---------------------------------
T的实际类型是: java.lang.String
value= Hello Gen!
运行的结果相同 但是泛型避免了强制转换类型，语法相对也更加简便
2.泛型类
不使用泛型
public class DoubleDemo {
private Double x;
public DoubleDemo(Double x) {
this.x = x;
}
public Double getX() {
return x;
}
public void setX(Double x) {
this.x = x;
}
}
public class StringDemo {
private String x;
public StringDemo(String x) {
this.x = x;
}
public String getX() {
return x;
}
public void setX(String x) {
this.x = x;
}
}
/**
* Created by 10051 on 2017/9/21.
* 因为上面的类中，成员和方法的逻辑都一样，就是类型不一样，因此考虑重构。
* Object是所有类的父类，因此可以考虑用Object做为成员类型，这样就可以实现通用了，
* 实际上就是“Object泛型”
*/
public class ObjectDemo {
private Object x;
public ObjectDemo(Object x) {
this.x = x;
}
public Object getX() {
return x;
}
public void setX(Object x) {
this.x = x;
}
}
/**
* Created by 10051 on 2017/9/21.
*
* 解说：在Java 5之前，为了让类有通用性，往往将参数类型、返回类型设置为Object类型，
* 当获取这些返回类型来使用时候，必须将其“强制”转换为原有的类型或者接口，然后才可以调用对象上的方法。
*/
public class ObjectDemoDemo {
public static void main(String args[]) {
ObjectDemo strDemo = new ObjectDemo(new StringDemo("Hello Generics!"));
ObjectDemo douDemo = new ObjectDemo(new DoubleDemo(new Double("33")));
ObjectDemo objDemo = new ObjectDemo(new Object());
// PS :必须将其“强制”转换为原有的类型或者接口，然后才可以调用对象上的方法
System.out.println("strFoo.getX=" + (StringDemo) strDemo.getX());
System.out.println("douFoo.getX=" + (DoubleDemo) douDemo.getX());
System.out.println("objFoo.getX=" + objDemo.getX());
}
}
使用了泛型
public class GenericsTest<T> {
private T x;
public GenericsTest(T x) {
this.x = x;
}
public T getX() {
return x;
}
public void setX(T x) {
this.x = x;
}
}
public class GenericsTestDemo {
public static void main(String[] args) {
GenericsTest<String> strfoo = new GenericsTest<>("Hello Generics!");
GenericsTest<Double> douFoo = new GenericsTest<>(new Double("33"));
GenericsTest<Object> objFoo = new GenericsTest<Object>(new Object());
System.out.println("strTest.getX=" + strfoo.getX());
System.out.println("douTest.getX=" + douFoo.getX());
System.out.println("objTest.getX=" + objFoo.getX());
}
}
运行结果
strTest.getX=Hello Generics!
douTest.getX=33.0
objTest.getX=java.lang.Object@28d93b30
解释泛型类的语法：
使用来声明一个类型持有者名称，然后就可以把T当作一个类型代表来声明成员、参数和返回值类型。
当然T仅仅是个名字，这个名字可以自行定义。
class GenericsTest 声明了一个泛型类，这个T没有任何限制，实际上相当于Object类型，实际上相当于 class GenericsTest。
与Object泛型类相比，使用泛型所定义的类在声明和构造实例的时候，可以使用“<实际类型>”来一并指定泛型类型持有者的真实类型。类如
GenericsTest douTest=new GenericsTest(new Double("33"));
当然，也可以在构造对象的时候不使用尖括号指定泛型类型的真实类型，但是你在使用该对象的时候，就需要强制转换了。
实际上，当构造对象时不指定类型信息的时候，默认会使用Object类型，这也是要强制转换的原因.
3.泛型方法
public class Demo{
public static <T> T test(T a){
return a;
}
}
/**
* Created by 10051 on 2017/9/21.
*
* 是否拥有泛型方法，与其所在的类是否泛型没有关系。要定义泛型方法，只需将泛型参数列表置于返回值前
* 使用泛型方法时，不必指明参数类型，编译器会自己找出具体的类型。泛型方法除了定义不同，调用就像普通方法一样。
*
*/
public class ExampleA {
public <T> void f(T x) {
System.out.println(x.getClass().getName());
}
public static void main(String[] args) {
ExampleA ea = new ExampleA();
ea.f(" ");
ea.f(10);
ea.f('a');
ea.f(ea);
}
}
是否拥有泛型方法，与其所在的类是否泛型没有关系。要定义泛型方法，只需将泛型参数列表置于返回值前
- 使用泛型方法时，不必指明参数类型，编译器会自己找出具体的类型。泛型方法除了定义不同，调用就像普通方法一样。
需要注意
一个static方法，无法访问泛型类的类型参数，所以，若要static方法需要使用泛型能力，必须使其成为泛型方法。
4.规则限定
1、泛型的类型参数只能是类类型（包括自定义类），不能是简单类型。
2、同一种泛型可以对应多个版本（因为参数类型是不确定的），不同版本的泛型类实例是不兼容的。
3、泛型的类型参数可以有多个。
4、泛型的参数类型可以使用extends语句，例如。习惯上称为“有界类型”。
5、泛型的参数类型还可以是通配符类型。例如Class classType = Class.forName("java.lang.String");
5.高级应用
5.1限制泛型
/**
* Created by 10051 on 2017/9/21.
* 在上面的例子中，由于没有限制class GenericsTest<T>类型持有者T的范围，实际上这里的限定类型相当于Object，这和“Object泛型”实质是一样的
* 限制比如我们要限制T为集合接口类型。只需要这么做：
* 1 class GenericsTest<T extends Collection>，这样类中的泛型T只能是Collection接口的实现类，传入非Collection接口编译会出错。
* 2 注意：<T extends Collection>这里的限定使用关键字extends，后面可以是类也可以是接口。
* 但这里的extends已经不是继承的含义了，应该理解为T类型是实现Collection接口的类型，或者T是继承了XX类的类型。
*/
public class CollectionGenTest<T extends Collection> {
private T x;
public CollectionGenTest(T x) {
this.x = x;
}
public T getX() {
return x;
}
public void setX(T x) {
this.x = x;
}
}
/**
* Created by 10051 on 2017/9/21.
* 当前看到的这个写法是可以编译通过，并运行成功。
* 可是注释掉的两行加上就出错了，
* 因为<T extends Collection>这么定义类型的时候，就限定了构造此类实例的时候T是确定的一个类型，
* 这个类型实现了Collection接口，但是实现 Collection接口的类很多很多，如果针对每一种都要写出具体的子类类型，
* 那也太麻烦了，我干脆还不如用Object通用一下。别急，泛型针对这种情况还有更好的解决方案，那就是“通配符泛型”。
*/
public class CollectionGenTestDemo {
public static void main(String[] args) {
CollectionGenTest<ArrayList> listTest= null;
listTest = new CollectionGenTest<ArrayList>(new ArrayList());
// 需要将CollectionGenTest<Collection>改为CollectionGenTest<ArrayList>
// CollectionGenTest<Collection> listTest = null;
// listTest=new CollectionGenTest<ArrayList>(new ArrayList());
System.out.println("实例化成功!");
}
}
5.2 多接口限制
/**
* 虽然Java泛型简单的用 extends 统一的表示了原有的 extends 和 implements 的概念，
* 但仍要遵循应用的体系，Java 只能继承一个类，但可以实现多个接口，
* 所以你的某个类型需要用 extends 限定，且有多种类型的时候，
* 只能存在一个是类，并且类写在第一位，接口列在后面，也就是：
* <T extends SomeClass & interface1 & interface2 & interface3>
*这里的例子仅演示了泛型方法的类型限定，对于泛型类中类型参数的限制用完全一样的规则，只是加在类声明的头部，如：
*/
public class Demo<T extends Comparable & Serializable> {
// T类型就可以用Comparable声明的方法和Seriablizable所拥有的特性了
}
5.3 通配符泛型
为了解决类型被限制死了不能动态根据实例来确定的缺点，引入了“通配符泛型”，
针对上面的例子，使用通配泛型格式为<? extends Collection>，“？”代表未知类型，这个类型是实现Collection接口。那么上面实现的方式可以写为：
public class CollectionGenTestDemo {
public static void main(String args[]) {
CollectionGenTest<ArrayList> listTest = null;
listTest= new CollectionGenTest<ArrayList>(new ArrayList());
// CollectionGenTest<Collection> listTest = null;
// listTest=new CollectionGenTest<ArrayList>(new ArrayList());
System.out.println("实例化成功!");
}
}
注意：
1、如果只指定了<?>，而没有extends，则默认是允许Object及其下的任何Java类了。也就是任意类。
2、通配符泛型不单可以向下限制，如<? extends Collection>，还可以向上限制，如<? super Double>，表示类型只能接受Double及其上层父类类型，如Number、Object类型的实例。
3、泛型类定义可以有多个泛型参数，中间用逗号隔开，还可以定义泛型接口，泛型方法。这些都与泛型类中泛型的使用规则类似。
