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];