Java泛型

前言：

　　“大道若簡，萬物歸一”。

• 為什么泛型？

　　Java中的泛型是由單詞“Generic”翻譯過來的，“Generic”即表示“一般、通用”的意思。而sun在JDK1.5之后引入的泛型的目的就在於此，將“特殊的，專屬的”類型參數化。

• 泛型的優點：

1）讓泛型類和泛型方法具備可重用性；
2）在編譯時而非運行時提前報錯，實現類型安全。

• 定義泛型類

  package com.gdufe.thread.generic;
  
  import java.util.ArrayList;
  
  /*
   * 基於數組鏈表構造泛型類型的棧（stack）
   */
  public class GenericStack<T>{
      
      ArrayList<T> list = new ArrayList<T>();
      
      public int getSize(){
          return list.size();
      }
      public T get(int index){
          return list.get(index);
      }
      public T peek(){
          return list.get(getSize()-1);
      }
      public void push(T t){
          list.add(t);
      }
      public boolean isEmpty(){
          return list.size()==0;
      }
      public T pop(){
          T t = list.get(getSize()-1);
          list.remove(getSize()-1);
          return t;
      }
  }

  泛型類測試1：

  package com.gdufe.thread.generic;
  
  public class Demo1 {
  
      public static void main(String[] args) {
          GenericStack<Integer> stack = new GenericStack<Integer>();
          stack.push(1);
          stack.push(3);
          stack.push(2);
          System.out.println(stack.list);
      }
  
  }

  輸出結果：

  [1, 3, 2]

  假如例子中沒有按照統一的“Integer”類型，編譯報錯！

• 泛型方法

  package com.gdufe.thread.generic;
  
  public class Demo2 {
      public static void main(String[] args) {
          Integer[] integer = new Integer[]{1,2,3};
          String[] string = new String[]{"Jack","John","Tom"};
          Demo2.print(integer);
          Demo2.print(string);
      }
      //泛型方法：打印數組中的每一個元素
      public static <E> void print(E[] array){
          for(E t:array){
              System.out.println(t);
          }
      }
  }

  輸出結果：

  1
  2
  3
  Jack
  John
  Tom

  1）定義泛型方法時，除了在參數里面需要指明泛型的類型之外，方法本身也應該指明泛型的類型

　　  2）外界訪問泛型方法，一般通過“類.<泛型類型>方法”進行調用，其中的<泛型類型>可省略。

• 通配泛型 （受限|非受限）

•  

  package com.gdufe.thread.generic;
  
  
  public class Demo3 {
      public static void main(String[] args) {
          
          GenericStack<Integer> stack1 = new GenericStack<Integer>();
          stack1.push(1);
          stack1.push(12);
          stack1.push(123);
          Demo3.print(stack1);
          
      }
      //受限制的通配，調用時‘？’必須是Number子類型，否則編譯報錯
      public static void print(GenericStack<? extends Number> stack){
          for(int i=0;i<stack.getSize();i++){
              System.out.println(stack.get(i));
          }
      }
  }

  輸出結果：

  1
  12
  123

   

　　　

package com.gdufe.thread.generic;


public class Demo4 {
    public static void main(String[] args) {
        GenericStack<Integer> stack1 = new GenericStack<Integer>();
        stack1.push(1);
        stack1.push(12);
        stack1.push(123);
        
        //stack2中元素默認是‘Object’類型
        GenericStack stack2 = new GenericStack();
        stack2.push("Jack");        //String類型
        stack2.push("Ammy");
        stack2.push(1.1);            //Double類型
        
        Demo4.add(stack1, stack2);
        
        while(!stack2.isEmpty()){
            System.out.println(stack2.pop());
        }
    }
    //泛型方法：把stack1里面的元素壓入到stack2中，其中stack2中的元素類型應“>=”stack1中元素類型，否則編譯報錯
    public static <T> void add(GenericStack<T> stack1,GenericStack<? super T> stack2){
        while(!stack1.isEmpty()){
            stack2.push(stack1.pop());
        }
    }
}

　　輸出結果：

1
12
123
1.1
Ammy
Jack

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

注意事項：

1）泛型僅存在於編譯時，程序運行之前所有泛型已被自動轉化

2）不能使用泛型直接創建實例 ，比如：T t = new T;

3) 不能使用泛型直接創建數組 ，比如：T[] t = new T[N];