如何使用Java泛型？相信很多没有经验的人对此束手无策，为此本文总结了问题出现的原因和解决方法，通过这篇文章希望你能解决这个问题。

成都创新互联公司主营麒麟网站建设的网络公司,主营网站建设方案,重庆App定制开发,麒麟h5小程序制作搭建,麒麟网站营销推广欢迎麒麟等地区企业咨询

一、什么是泛型

“泛型” 意味着编写的代码可以被不同类型的对象所重用。泛型的提出是为了编写重用性更好的代码。泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。

比如常见的集合类 LinkedList:

public class LinkedList extends AbstractSequentialList implements List,Deque,Cloneable,Serializable{
 //.....
 transient Link voidLink;
//.....    
}

可以看到，LinkedList 类名及其实现的接口名后有个特殊的部分，而且它的成员的类型 Link 也包含一个，这个符号的就是类型参数，它使得在运行中，创建一个 LinkedList 时可以传入不同的类型。

二、为什么引入泛型

在引入泛型之前，要想实现一个通用的、可以处理不同类型的方法，你需要使用 Object作为属性和方法参数，比如这样：

public class Generic{
    private Object[] mData;

    public Generic(int capacity){
        mData = new Object[capacity];
    }
    
    public Object getData(int index){
       //.....
       return mData[index];
    }
     
    public void add(int index,Object item){
       //.....
       mData[index] = item;
    }   

}

它使用一个 Object 数组来保存数据，这样在使用时可以添加不同类型的对象:

Generic generic = new Generic(10);
generic.add(0,"fangxing");
generic.add(1,23);

Object 是所有类的父类，所有的类都可以作为成员被添加到上述类中；当需要使用的时候，必须进行强制转换，而且这个强转很有可能出现转换异常：

String item1 = (String) generic.getData(0);
String item2 = (String) generic.getData(1);

第二行代码将一个 Integer 强转成 String，运行时会报错 ：

可以看到，使用 Object 来实现通用、不同类型的处理，有这么两个缺点：

1. 每次使用时都需要强制转换成想要的类型

2. 在编译时编译器并不知道类型转换是否正常，运行时才知道，不安全

根据《Java 编程思想》中的描述，泛型出现的动机在于：

有许多原因促成了泛型的出现，而最引人注意的一个原因，就是为了创建容器类。

在 JDK 1.5 出现泛型以后，许多集合类都使用泛型来保存不同类型的元素，比如 Collection:

public interface Collection extends Iterable{
   
     Iterator iterator();
   
     Object[] toArray();
     
      T[] toArray(T[] a);

     boolean add(E e);
     
     boolean remove(Object o);
 
     boolean  containsAll(Collecion c);

     boolean addAll(Collection c);

     boolean removeAll(Collection c);
   
}

实际上引入泛型的主要目标有以下几点：

类型安全

• 泛型的主要目标是提高 Java 程序的类型安全

• 编译时期就可以检查出因 Java 类型不正确导致的 ClassCastException 异常

• 符合越早出错代价越小原则

消除强制类型转换

• 泛型的一个附带好处是，使用时直接得到目标类型，消除许多强制类型转换

• 所得即所需，这使得代码更加可读，并且减少了出错机会

潜在的性能收益

• 由于泛型的实现方式，支持泛型（几乎）不需要 JVM 或类文件更改

• 所有工作都在编译器中完成

• 编译器生成的代码跟不使用泛型（和强制类型转换）时所写的代码几乎一致，只是更能确保类型安全而已

三、泛型的使用方式

泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。

类型参数的意义是告诉编译器这个集合中要存放实例的类型，从而在添加其他类型时做出提示，在编译时就为类型安全做了保证。

参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。

public class GenericClass{
    private F mContent;
    
    public GenericClass(F content){
      mContent = content;
    }
  
    /*
      泛型方法
   */
    public F getContent(){
      return mContent;
    }
    
    public void setContent(F content){
      mcontent = content;
    }
   
    /*
       泛型接口
    */
    public interface GenericInterface{
        void  doSomething(T t);
    }

}

泛型类 

泛型类和普通类的区别就是类名后有类型参数列表 ，既然叫“列表”了，当然这里的类型参数可以有多个，比如 public class HashMap，参数名称由开发者决定。

类名中声明参数类型后，内部成员、方法就可以使用这个参数类型，比如上面的 GenericClass 就是一个泛型类，它在类名后声明了类型 F，它的成员、方法就可以使用 F 表示成员类型、方法参数/返回值都是 F 类型。

泛型类最常见的用途就是作为容纳不同类型数据的容器类，比如 Java 集合容器类。

泛型接口

和泛型类一样，泛型接口在接口名后添加类型参数，比如上面的 GenericInterface，接口声明类型后，接口方法就可以直接使用这个类型。

实现类在实现泛型接口时需要指明具体的参数类型，不然默认类型是 Object，这就失去了泛型接口的意义。

未指明类型的实现类，默认是 Object 类型：

public class Generic implements GenericInterface{
    @Override
    public void doSomething(Object o){
      //...
    }
}

指明了类型的实现：

public class Generic implements GericInterface{
     @Override
     public void doSomething(String s){
       //.....
     }
}

泛型接口比较实用的使用场景就是用作策略模式的公共策略， Comparator就是一个泛型接口：

public interface Comparator{
    public int compare(T lhs, Trhs);
    public bollean equals(Object object);
}

泛型接口定义基本的规则，然后作为引用传递给客户端，这样在运行时就能传入不同的策略实现类。

泛型方法

泛型方法是指使用泛型的方法，如果它虽在的类是一个泛型类，那就很简单了，直接使用类声明的参数。

如果一个方法所在的类不是泛型类，或者他想要处理不同于泛型类声明类型的数据，那它就需要自己声明类型。

/*
    传统的方法，会有unchecked ... raw type 的警告 
*/
public Set union(Set s1, Set s2){
    Set result = new HashSet(s1);
    result.addAll(s2);
    return result;
}

/*
    泛型方法，介于方法修饰符和返回值之间的称作 类型参数列表（可以有多个）
    类型参数列表 指定参数、返回值中泛型的参数类型范围，命名惯例与泛型相同。
*/
public  Set union2(Set s1, Set s2){
    Set result = new HashSet<>(s1);
    result.addAll(s2);
    return result;
}

四、泛型的通配符

通配符：传入的类型有一个指定的范围，从而可以进行一些特定的操作

泛型中有三种通配符形式：

1.无限制通配符

2. extends 关键字声明了类型的上界，表示参数化的类型可能是所指定的类型，或者是此类型的子类。

3. super 关键字声明了类型的下界，表示参数化类型可能是指定类型，或者是此类型的父类。

无限制通配符 < ?>

要使用泛型，但是不确定或者不关心实际要操作的类型，可以使用无限制通配符（尖括号里一个问号，即 ），表示可以持有任何类型。

? 和 Object 不一样，List 表示未知类型的列表，而 List