https://www.jb51.net/article/270336.htm
一、定义
1、T 代表一种类型
可以加在类上，也可以加在方法上
1）T 加在类上
| 1 2 3 |
class SuperClass<A>{
//todo
}
|
2）T 加在方法上
| 1 2 3 |
public <T>void fromArrayToList(T[] arr, List<T> list){
//todo
}
|
说明：
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
> 上面方法上的<T>代表括号里面要用到泛型参数，若类中传了泛型，此处可以不传，
> 调用类型上面的泛型参数，前提是方法中使用的泛型与类中传来的泛型一致,
如下所示：
/**
* 类上的 泛型T 和 方法中的参数相同，
* 所以方法的返回值处 可以 不加<T>
*/
class SuperClass<T>{
public void fromArrayToList(T[] arr, List<T> list){
//todo
}
}
|
扩展：
如果有泛型方法和非泛型方法，都满足条件，会执行非泛型方法
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
//非泛型方法
public void show(String s){
System.out.println("1");
}
//泛型方法
@Override
public void show(T a) {
System.out.println("2");
}
|
如上示例，调用show方法时，因为非泛型方法存在，会优先执行show(String s)方法
2、?是通配符，泛指所有类型
一般用于定义一个引用变量
| 1 2 3 4 5 |
SuperClass<?> sup = new SuperClass<String>("lisi");
sup = new SuperClass<People>(new People());
sup = new SuperClass<Animal>(new Animal());
|
若不用?，用固定的类型的话，则：
| 1 2 3 4 5 |
SuperClass<String> sup1 = new SuperClass<String>("lisi");
SuperClass<People> sup2 = new SuperClass<People>;
SuperClass<Animal> sup3 = new SuperClass<Animal>;
|
这就是 ? 通配符的好处：定义一个sup的引用变量，就可以指向多个对象。
二、使用
1、T 一般有两种用途
1) 定义一个通用的泛型方法
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
// Dao 定义1个通用的泛型方法getList
public interface Dao{
List<T> getList(){};
}
// 使用 Dao的泛型方法getList 返回String类型
List<String> getStringList(){
return dao.getList();//dao是一个实现类实例
}
// 使用 Dao的泛型方法getList 返回Integer类型
List<Integer> getIntList(){
return dao.getList();
}
|
PS：上面接口的getList方法如果定义成List<?> ，后面就会报错。
2) 限制方法的参数之间或参数和返回结果之间的关系
| 1 2 |
// 限制参数 param1、param2、返回值都是T类型
List<T> getList<T param1,T param2>
|
这样可以限制返回结果的类型以及两个参数的类型一致
2、<?> 的限制用途
<?> 一般就是在泛型起一个限制作用，如下示例：
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
// 定义1个父类Fruit
public Class Fruit(){}
// 定义1个子类Apple,继承Fruit
public Class Apple extends Fruit(){}
// 定义1个方法test，限制参数类型只能是 Fruit 或 Fruit的子类
public void test(? extends Fruit){
//todo
};
/** 以下是调用 */
test(new Fruit()); // 传参为 父类Fruit
test(new Apple()); // 传参为 父类Fruit的子类Apple
test(new String()); //这个会报错, 因为定义方法的传参，限制死了
|
3、三种泛型限定
| 1 2 3 |
ArrayList<T> al=new ArrayList<T>(); //指定集合元素只能是T类型
ArrayList<? extends E> al=new ArrayList<? extends E>(); //指定集合元素只能是E类型或者E的子类型
ArrayList<? super E> al=new ArrayList<? super E>(); //指定集合元素只能是E类型或者E的父类型
|
三、总结
1、从定义上看
T和？定义的地方有点不同，?是定义在引用变量上，T是类上或方法上
2、从用途上看
“T>“和”<?>”，首先要区分开两种不同的场景：
第一，声明一个泛型类或泛型方法；
第二，使用泛型类或泛型方法。
类型参数“T>”主要用于第一种，声明泛型类或泛型方法
无界通配符“<?>”主要用于第二种，使用泛型类或泛型方法
补充：场景
| 1 2 3 |
ArrayList al=new ArrayList();指定集合元素只能是T类型
ArrayList<?> al=new ArrayList<?>();集合元素可以是任意类型，这种没有意义，一般是方法中，只是为了说明用法
ArrayList<? extends E> al=new ArrayList<? extends E>();
|
泛型的限定：
- ? extends E:接收E类型或者E的子类型。
- ？super E:接收E类型或者E的父类型。
到此这篇关于Java泛型中＜?＞和＜T＞区别的文章就介绍到这了,更多相关Java泛型<?>和<T>区别内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！
标签：Java,类型,Fruit,SuperClass,泛型,new,方法,浅析 From： https://www.cnblogs.com/bxf0011/p/17097215.html