java：泛型 & 通配泛型之区别、详解

港控/mmm° 2022-02-23 06:44 264阅读 0赞

### 文章目录 ###

*  1.泛型
 *   *  1.1泛型类
     *   *  （1）不使用泛型类
         *  （2）使用泛型类
     *  1.2泛型方法
 *  2. 通配泛型
 *   *   *  （1）？extends T
         *  （2）？super T
 *  3. T，Object，?的区别

<table> 
 <tbody> 
  <tr> 
   <th colspan="2"> 常用符号</th> 
  </tr> 
  <tr> 
   <td>?</td> 
   <td>表示不确定的java类型</td> 
  </tr> 
  <tr> 
   <td>T - Type</td> 
   <td>表示具体的一个java类型</td> 
  </tr> 
  <tr> 
   <td>K - Key（键） V - Value（值）</td> 
   <td>分别代表java键值中的Key Value</td> 
  </tr> 
  <tr> 
   <td>E - Element</td> 
   <td>在集合中使用，因为集合中存放的是元素</td> 
  </tr> 
  <tr> 
   <td>N - Number</td> 
   <td>数值类型</td> 
  </tr> 
 </tbody> 
</table>

--------------------

# 1.泛型 #

<table> 
 <tbody> 
  <tr> 
   <th colspan="4"> 泛型</th> 
  </tr> 
  <tr> 
   <td>概念</td> 
   <td colspan="3">即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢? 就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）</td> 
  </tr> 
  <tr> 
   <td>使用方式</td> 
   <td colspan="3">泛型类</td> 
  </tr> 
  <tr> 
   <td colspan="3">泛型方法</td> 
  </tr> 
  <tr> 
   <td colspan="3">泛型接口</td> 
  </tr> 
  <tr> 
   <td>泛型通配</td> 
   <td>非限定通配</td> 
   <td>?</td> 
   <td>等价于： ？extends Object，可用任何类型替代</td> 
  </tr> 
  <tr> 
   <td>限定通配</td> 
   <td>? extends T</td> 
   <td>T 或 T 的一个子类型</td> 
  </tr> 
  <tr> 
   <td>? super T</td> 
   <td>T 或 T 的一个父类型</td> 
  </tr> 
 </tbody> 
</table>

## 1.1泛型类 ##

问题：为什么要使用泛型类？

### （1）不使用泛型类 ###

public class TestClass {
    	Object obj;
    
    	public TestClass(Object obj) {
    		this.obj = obj;
    	}
    	public void setObj(Object obj) {
    		this.obj = obj;
    	}
    	public Object getObj() {
    		return obj;
    	}
    	public void showObj() {
    		System.out.println("T的实际类型为：" + obj.getClass());
    	}
    	
    	public static void main(String[] args) {
    	//Java中，Object类是所有类的父类。可以将一个普通类对象作为参数传递给Object类对象。这在继承中叫做“上转型对象”（将子类对象的引用赋值给父类对象）
    		TestClass intObj = new TestClass(new Integer(33));
    		intObj.showObj();
    		int i = (Integer)intObj.getObj();
    		System.out.println(i);
    		
    		TestClass StringObj = new TestClass(new String("This is a string"));
    		StringObj.showObj();
    		String s = (String)StringObj.getObj();
    		System.out.println(s);
    	}
    }

int i = (Integer)intObj.getObj();  
Q：类的对象和基本数据类型可以互相赋值吗？  
A：可以。这种操作在JDK 5之后的版本允许使用

<table> 
 <tbody> 
  <tr> 
   <th>概念 </th> 
   <th>举例（以 Integer 类为例） </th> 
   <th> 转换过程</th> 
  </tr> 
  <tr> 
   <td>自动拆箱（autounboxing）</td> 
   <td>Integer obj = new Integer(10);<br>int i = obj</td> 
   <td>i = obj.intValue()</td> 
  </tr> 
  <tr> 
   <td>自动装箱（autoboxing）</td> 
   <td>Integer obj = 10</td> 
   <td>10---&gt; Integer.valueof（10）；<br>obj = Integer.valueof（10）</td> 
  </tr> 
 </tbody> 
</table>

private final int value;
     public Integer(int value) {
        this.value = value;
     }
    
     public Integer(String string) throws NumberFormatException {
         this(parseInt(string));
     }
    
    public static Integer valueOf(int i) {
        return  i >= 128 || i < -128 ? new Integer(i) : SMALL_VALUES[i + 128];
    }//如果i小于-128或者大于等于128，就创建一个Integer对象，否则执行SMALL_VALUES[i + 128]```

### （2）使用泛型类 ###

public class GenericClass<T> {
    	T obj;
    	
    	public GenericClass(T obj) {
    		this.obj = obj;
    	}
    	public void setObj(T obj) {
    		this.obj = obj;
    	}
    	public T getObj() {
    		return obj;
    	}
    	public void showObj() {
    		System.out.println("T的实际类型为：" + obj.getClass());
    	}
    
    	public static void main(String[] args) {
    		GenericClass<Integer> intObj = new GenericClass<Integer>(33);
    		intObj.showObj();
    		int i = intObj.getObj();
    		System.out.println(i);
    		
    		GenericClass<String> StringObj = new GenericClass<String>("This is a string");
    		StringObj.showObj();
    		String s = StringObj.getObj();
    		System.out.println(s);
    	}
    }

可以看出，不使用泛型类需要使用强制类型转换，比泛型类麻烦  
以上两段代码的输出结果相同。  
![在这里插入图片描述][20190407111133657.PNG]

## 1.2泛型方法 ##

public class GenericMethodDemo {
      public static void main(String[] args ) {
        Integer[] integers = {1, 2, 3, 4, 5};
        String[] strings = {"London", "Paris", "New York", "Austin"};
    
        GenericMethodDemo.<Integer>print(integers);
        GenericMethodDemo.<String>print(strings);
      }
    
      public static <E> void print(E[] list) {
        for (int i = 0; i < list.length; i++)
          System.out.print(list[i] + " ");
        System.out.println();
      }
    }

--------------------

# 2. 通配泛型 #

<table> 
 <tbody> 
  <tr> 
   <th colspan="4">三个符号</th> 
  </tr> 
  <tr> 
   <td>非限定通配</td> 
   <td>?</td> 
   <td>不对传入的泛型实参进行边界限制（实际上限制参数上界为Object）</td> 
   <td>等价于： ？extends Object，可用任何类型替代</td> 
  </tr> 
  <tr> 
   <td>限定通配</td> 
   <td>? extends T</td> 
   <td>为传入的泛型类型实参进行上下边界的限制，如：类型实参只准传入某种类型的父类或某种类型的子类</td> 
   <td>T 或 T 的一个子类型</td> 
  </tr> 
  <tr> 
   <td>? super T</td> 
   <td>T 或 T 的一个父类型</td> 
  </tr> 
 </tbody> 
</table>

### （1）？extends T ###

//输出栈中最大元素
    public class WildCardNeedDemo {
      public static void main(String[] args ) {
         GenericStack<Integer> intStack = new GenericStack<>();
         intStack.push(1); // 1 is autoboxed into new Integer(1)
         intStack.push(2);
         intStack.push(-2);
    
    // Error:     System.out.print("The max number is " + max(intStack));
      }
    
      /** Find the maximum in a stack of numbers */
      public static double max(GenericStack<Number> stack) {
         double max = stack.pop().doubleValue(); // initialize max
    
         while (!stack.isEmpty()) {
           double value = stack.pop().doubleValue();
           if (value > max)
             max = value;
         }
    
         return max;
      }
    }

上例9行将出现编译错误，虽然Integer是Number的 子类，但GenericStack<Integer> 并不是GenericStack<Number>的子类型。  
正解：public static double max(GenericStack stack)改为  
public static double max(GenericStack<？ extends Number> stack)

### （2）？super T ###

//将字符串栈 stack1 中的 字符串 添加到对象栈 stack2
    public class SuperWildCardDemo {
      public static void main(String[] args) {
        GenericStack<String> stack1 = new GenericStack<String>();
        GenericStack<Object> stack2 = new GenericStack<Object>();
        stack2.push("Java");
        stack2.push(2);
        stack1.push("Sun");
        add(stack1, stack2);
        AnyWildCardDemo.print(stack2);
      }
    
      public static <T> void add(GenericStack<T> stack1,
          GenericStack<? super T> stack2) {
        while (!stack1.isEmpty())
          stack2.push(stack1.pop());
      }
    }

此例public static void add(GenericStack<T> stack1,                                              GenericStack<? super T> stack2)   
用法1。  
改为public static void add(GenericStack<? extends T> stack1,                                              GenericStack<T> stack2)  
用法2。也是正确的。  
？？？怎么确定是用 ? extends T  还是  ? super T ???

<table> 
 <tbody> 
  <tr> 
   <th colspan="2">上表中所说的受限通配和下限通配，这个界限其实是以 T 为界限的，以<br>例2.（2）代码为例 </th> 
  </tr> 
  <tr> 
   <th>用法1</th> 
   <th>用法2</th> 
  </tr> 
  <tr> 
   <td>传入stack1、stack2，此时T代表stack1，？super T代表stack2</td> 
   <td>传入stack1、stack2，此时? extends T代表stack1，T代表stack2</td> 
  </tr> 
  <tr> 
   <td>以T（stack1）为界</td> 
   <td>以T（stack2）为界</td> 
  </tr> 
  <tr> 
   <td>？super T表示T 或 T的父类，<br>stack1是String类对象，<br>stack2是Object类对象，<br>Object是String的父类</td> 
   <td>? extends T表示T 或 T的子类，<br>stack1是String类对象，<br>stack2是Object类对象，<br>String是Object的子类</td> 
  </tr> 
 </tbody> 
</table>

--------------------

# 3. T，Object，?的区别 #

< T > 等同于 < T extends Object>  
< ? > 等同于 < ? extends Object>

<table> 
 <thead> 
  <tr> 
   <th>Object和T区别</th> 
   <th>?和T区别</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Object是一个实打实的类,并没有泛指谁，而T可以泛指Object，比方public void printList(List&lt;T&gt; list){}方法中可以传入List&lt;Object&gt; list类型参数，也可以传入List&lt;String&gt; list类型参数，但是public void printList(List&lt;Object&gt; list){}就只可以传入List&lt;Object&gt; list类型参数，因为Object类型并没有泛指谁，是一个确定的类型</td> 
   <td>？是一个不确定类，？和T都表示不确定的类型 ，但如果是T的话，函数里面可以对T进行操作，比方 T car = getCar()，而不能用？ car = getCar()</td> 
  </tr> 
 </tbody> 
</table>

[20190407111133657.PNG]: /images/20220223/3cb6ad40c5274b37aa87117e5861425d.png