java中的泛型T和？的差异性，学习了

java泛型中T和？有什么区别？

T 代表一种类型

加在类上:class SuperClass<A>{}

加在方法上:

public <T>void fromArrayToCollection(T[] a, Collection<T> c){}

方法上的<T>代表括号里面要用到泛型参数，若类中传了泛型，此处可以不传，调用类型上面的泛型参数，前提是方法中使用的泛型与类中传来的泛型一致。

class People<T>{

public void show(T a) {

   }

}

T extends T2 指传的参数为T2或者T2的子类型。

 

?是通配符,泛指所有类型

一般用于定义一个引用变量,这么做的好处是,如下所示,定义一个sup的引用变量，就可以指向多个对象。

SuperClass<?> sup = new SuperClass<String>("lisi");

sup = new SuperClass<People>(new People());

sup = new SuperClass<Animal>(new Animal());

若不用?,用固定的类型的话，则：

SuperClass<String> sup1 = new SuperClass<String>("lisi");

SuperClass<People> sup2 = new SuperClass<People>("lisi");

SuperClass<Animal> sup3 = new SuperClass<Animal>("lisi");

这就是?通配符的好处。

 

? extends T 指T类型或T的子类型

? super T   指T类型或T的父类型

这个两个一般也是和?一样用在定义引用变量中，但是传值范围不一样

T和？运用的地方有点不同,?是定义在引用变量上,T是类上或方法上

如果有泛型方法和非泛型方法,都满足条件,会执行非泛型方法

public void show(String s){

      System.out.println("1");

   }

   @Override

   public void show(T a) {

      System.out.println("2");

   }

1.在整个类中只有一处使用了泛型,使用时注意加了泛型了参数不能调用与参数类型有关的方法比如“+”，比如打印出任意参数化类型集合中的所有内容，就适合用通配符泛型<?>
public static void printCollecton(Collection <?> collection)
{
for(Object obj: collection)
{
System.out.println(obj);
}
}

2. 当一个类型变量用来表达两个参数之间或者参数与返回值之间的关系时，即统一各类型变量在方法签名的两处被使用，或者类型变量在方法体代码中也被使用而不仅仅在签名的时候使用，这是应该用自定义泛型<T>。泛型方可以调用一些时间类型的方法。比如集合的add方法。
public static <T> T autoConvertType(T obj)
{
     return(T)obj;
}

泛型三种：
          [1]ArrayList<T> al=new ArrayList<T>();指定集合元素只能是T类型
          [2]ArrayList<?> al=new ArrayList<?>();集合元素可以是任意类型，这种没有意义，一般是方法中，只是为了说明用法
          [3]ArrayList<? extends E> al=new ArrayList<? extends E>();
            泛型的限定：
               ? extends E:接收E类型或者E的子类型。
               ？super E:接收E类型或者E的父类型。

java泛型的两种用法：List<T>是泛型方法，List<?>是限制通配符

List<T>一般有两种用途：
1、定义一个通用的泛型方法。
public interface Dao{
  List<T> getList(){};
}
 
List<String> getStringList(){
  return dao.getList();//dao是一个实现类实例
}
 
List<Integer> getIntList(){
  return dao.getList();
}
上面接口的getList方法如果定义成List<?> ，后面就会报错。

2、限制方法的参数之间或参数和返回结果之间的关系。
List<T> getList<T param1,T param2>
这样可以限制返回结果的类型以及两个参数的类型一致。

List<?>一般就是在泛型起一个限制作用。
public Class Fruit(){}

public Class Apple extends Fruit(){}

public void test(? extends Fruit){};

test(new Fruit());
test(new Apple());
test(new String()); //这个就会报错,
参数必须是Fruit或其子类。

“<T>"和"<?>"，首先要区分开两种不同的场景：

第一，声明一个泛型类或泛型方法。
第二，使用泛型类或泛型方法。
类型参数“<T>”主要用于第一种，声明泛型类或泛型方法。
无界通配符“<?>”主要用于第二种，使用泛型类或泛型方法

再来看一下具体概念：

java泛型（泛型接口、泛型类、泛型方法）

泛型接口：

定义一个泛型接口：

 

通过类去实现这个泛型接口的时候指定泛型T的具体类型。

指定具体类型为Integer：

指定具体类型为String:

指定具体类型为一个自定义的对象：

泛型类：

在编译器，是无法知道K和V具体是什么类型，只有在运行时才会真正根据类型来构造和分配内存。

泛型方法：

引用其他人写的，觉得不错：

定义泛型方法时，必须在返回值前边加一个<T>，来声明这是一个泛型方法，持有一个泛型T，然后才可以用泛型T作为方法的返回值。

       Class<T>的作用就是指明泛型的具体类型，而Class<T>类型的变量c，可以用来创建泛型类的对象。

       为什么要用变量c来创建对象呢？既然是泛型方法，就代表着我们不知道具体的类型是什么，也不知道构造方法如何，因此没有办法去new一个对象，但可以利用变量c的newInstance方法去创建对象，也就是利用反射创建对象。

       泛型方法要求的参数是Class<T>类型，而Class.forName()方法的返回值也是Class<T>，因此可以用Class.forName()作为参数。其中，forName()方法中的参数是何种类型，返回的Class<T>就是何种类型。在本例中，forName()方法中传入的是User类的完整路径，因此返回的是Class<User>类型的对象，因此调用泛型方法时，变量c的类型就是Class<User>，因此泛型方法中的泛型T就被指明为User，因此变量obj的类型为User。

       当然，泛型方法不是仅仅可以有一个参数Class<T>，可以根据需要添加其他参数。

       为什么要使用泛型方法呢？因为泛型类要在实例化的时候就指明类型，如果想换一种类型，不得不重新new一次，可能不够灵活；而泛型方法可以在调用的时候指明类型，更加灵活。

 

 

总结：泛型的使用使我们的代码更加具有通用性，不会导致定义了一种类型之后其他的类型都无法使用该代码。

　　　通过泛型可以定义类型安全的数据结构（类型安全），而无须使用实际的数据类型（可扩展）。这能够显著提高性能并得到更高质量的代码（高性能），因为您可以重用数据处理算法，而无须复制类型特定的代码（可重用）。