Java泛型

标签：

前言：

　　“大道若简，万物归一”。

• 为什么泛型？

　　Java中的泛型是由单词“Generic”翻译过来的，“Generic”即表示“一般、通用”的意思。而sun在JDK1.5之后引入的泛型的目的就在于此，将“特殊的，专属的”类型参数化。

• 泛型的优点：

1）让泛型类和泛型方法具备可重用性；
2）在编译时而非运行时提前报错，实现类型安全。

• 定义泛型类

   1 package com.gdufe.thread.generic;
   2 
   3 import java.util.ArrayList;
   4 
   5 /*
   6  * 基于数组链表构造泛型类型的栈（stack）
   7  */
   8 public class GenericStack<T>{
   9     
  10     ArrayList<T> list = new ArrayList<T>();
  11     
  12     public int getSize(){
  13         return list.size();
  14     }
  15     public T get(int index){
  16         return list.get(index);
  17     }
  18     public T peek(){
  19         return list.get(getSize()-1);
  20     }
  21     public void push(T t){
  22         list.add(t);
  23     }
  24     public boolean isEmpty(){
  25         return list.size()==0;
  26     }
  27     public T pop(){
  28         T t = list.get(getSize()-1);
  29         list.remove(getSize()-1);
  30         return t;
  31     }
  32 }

  泛型类测试1：

   1 package com.gdufe.thread.generic;
   2 
   3 public class Demo1 {
   4 
   5     public static void main(String[] args) {
   6         GenericStack<Integer> stack = new GenericStack<Integer>();
   7         stack.push(1);
   8         stack.push(3);
   9         stack.push(2);
  10         System.out.println(stack.list);
  11     }
  12 
  13 }

  输出结果：

  [1, 3, 2]

  假如例子中没有按照统一的“Integer”类型，编译报错！

• 泛型方法

   1 package com.gdufe.thread.generic;
   2 
   3 public class Demo2 {
   4     public static void main(String[] args) {
   5         Integer[] integer = new Integer[]{1,2,3};
   6         String[] string = new String[]{"Jack","John","Tom"};
   7         Demo2.print(integer);
   8         Demo2.print(string);
   9     }
  10     //泛型方法：打印数组中的每一个元素
  11     public static <E> void print(E[] array){
  12         for(E t:array){
  13             System.out.println(t);
  14         }
  15     }
  16 }

  输出结果：

  1
  2
  3
  Jack
  John
  Tom

  1）定义泛型方法时，除了在参数里面需要指明泛型的类型之外，方法本身也应该指明泛型的类型

　　  2）外界访问泛型方法，一般通过“类.<泛型类型>方法”进行调用，其中的<泛型类型>可省略。

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

•  

   1 package com.gdufe.thread.generic;
   2 
   3 
   4 public class Demo3 {
   5     public static void main(String[] args) {
   6         
   7         GenericStack<Integer> stack1 = new GenericStack<Integer>();
   8         stack1.push(1);
   9         stack1.push(12);
  10         stack1.push(123);
  11         Demo3.print(stack1);
  12         
  13     }
  14     //受限制的通配，调用时‘？’必须是Number子类型，否则编译报错
  15     public static void print(GenericStack<? extends Number> stack){
  16         for(int i=0;i<stack.getSize();i++){
  17             System.out.println(stack.get(i));
  18         }
  19     }
  20 }

  输出结果：

  1
  12
  123

   

 1 package com.gdufe.thread.generic;
 2 
 3 
 4 public class Demo4 {
 5     public static void main(String[] args) {
 6         GenericStack<Integer> stack1 = new GenericStack<Integer>();
 7         stack1.push(1);
 8         stack1.push(12);
 9         stack1.push(123);
10         
11         //stack2中元素默认是‘Object’类型
12         GenericStack stack2 = new GenericStack();
13         stack2.push("Jack");        //String类型
14         stack2.push("Ammy");
15         stack2.push(1.1);            //Double类型
16         
17         Demo4.add(stack1, stack2);
18         
19         while(!stack2.isEmpty()){
20             System.out.println(stack2.pop());
21         }
22     }
23     //泛型方法：把stack1里面的元素压入到stack2中，其中stack2中的元素类型应“>=”stack1中元素类型，否则编译报错
24     public static <T> void add(GenericStack<T> stack1,GenericStack<? super T> stack2){
25         while(!stack1.isEmpty()){
26             stack2.push(stack1.pop());
27         }
28     }
29 }

　　输出结果：

1
12
123
1.1
Ammy
Jack

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

注意事项：

1）泛型仅存在于编译时，程序运行之前所有泛型已被自动转化

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

3) 不能使用泛型直接创建数组 ，比如：T[] t = new T[N];

Java泛型

标签：

原文地址：http://www.cnblogs.com/SeaSky0606/p/4729131.html