Java泛型中＜?＞和＜T＞的区别

太过爱你忘了你带给我的痛 2024-03-31 17:50 107阅读 0赞

### 一、定义 ###

#### 1、T 代表一种类型 ####

可以加在类上，也可以加在方法上  
**1）T 加在类上**

class SuperClass<A>{
        
    	//todo
    }

**2）T 加在方法上**

public <T>void fromArrayToList(T[] arr, List<T> list){
        
     	//todo
    }

说明：

> 上面方法上的<T>代表括号里面要用到泛型参数，若类中传了泛型，此处可以不传，
    > 调用类型上面的泛型参数，前提是方法中使用的泛型与类中传来的泛型一致, 
      如下所示：
      /**
     * 类上的 泛型T 和 方法中的参数相同，
     * 所以方法的返回值处 可以 不加<T>
     */
    class SuperClass<T>{
        
    
      public void fromArrayToList(T[] arr, List<T> list){
        
        //todo
      }
      
    }

扩展：  
如果有泛型方法和非泛型方法，都满足条件，会执行非泛型方法

//非泛型方法
    	public void show(String s){
        
    
          System.out.println("1");
    
       }
    	
    	//泛型方法
       @Override
       public void show(T a) {
        
    
          System.out.println("2");
    
       }

如上示例，调用show方法时，因为非泛型方法存在，会优先执行show(String s)方法

#### 2、?是通配符，泛指所有类型 ####

一般用于定义一个引用变量

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>;
    
    SuperClass<Animal> sup3 = new SuperClass<Animal>;

这就是 ? 通配符的好处：定义一个sup的引用变量，就可以指向多个对象。

### 二、使用 ###

#### 1、T 一般有两种用途 ####

###### 1) 定义一个通用的泛型方法 ######

// 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) 限制方法的参数之间或参数和返回结果之间的关系 ######

// 限制参数 param1、param2、返回值都是T类型
    List<T> getList<T param1,T param2>

这样可以限制返回结果的类型以及两个参数的类型一致

#### 2、<?> 的限制用途 ####

<?> 一般就是在泛型起一个限制作用，如下示例：

// 定义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、三种泛型限定 ####

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>”主要用于第一种，声明泛型类或泛型方法**  
**无界通配符“<?>”主要用于第二种，使用泛型类或泛型方法**