從應用角度細說java泛型用法

自jdk1.5之後java中加入了泛型，下面從應用方面做了一下幾個demo，簡單說說泛型的用法

參考：http://www.cnblogs.com/sunwei2012/archive/2010/10/08/1845938.html

1、泛型的基本用法、萬用字元、受限泛型的用法
/**
 * 泛型的基本用法、萬用字元、受限泛型的用法
 * @author
 * @param <T>
 */
public class Point <T>{ //此處可以隨便寫標識，T是type的簡寫
 private T var ; //var 的類型由T指定，即：由外部指定
 public T getVar(){ //傳回值的類型由外部指定
  return var;
 }
 public void setVar(T var) {
  this.var = var;
 }
 
 //萬用字元
 public static void testWildCard(Point<?> p){// 可以接收任意的泛型對象 
  System.out.println("萬用字元 content："+p.getVar());
 }
 //受限泛型
 public static void testLimit(Point<? extends Number> p){// 只能接收Number及其Number的子類 

  System.out.println("受限泛型 content："+p.getVar());
 }
 
 //測試
 public static void main(String args[]){
  //泛型基本用法測試
  Point<String> p = new Point<String>();
  p.setVar("test");
  System.out.println(p.getVar().length());
  
  Point<Long> pLong = new Point<Long>();
  pLong.setVar(1L);
  System.out.println(pLong.getVar());
  
  //泛型的萬用字元
  testWildCard(pLong);
  testWildCard(p);
  
  //受限泛型
  testLimit(pLong);
 }
}

/**
 * 兩個泛型型別
 * @param <K>
 * @param <V>
 */
public class NotePad<K,V> { //此處指定了兩個泛型型別
 private K key; //類型由外部指定
 private V value; //類型由外部指定
 public K getKey() {
  return key;
 }
 public void setKey(K key) {
  this.key = key;
 }
 public V getValue() {
  return value;
 }
 public void setValue(V value) {
  this.value = value;
 }
 
 //測試
 public static void main(String[] args) {
  NotePad<String,Integer> notePad = new NotePad<String,Integer>();
  notePad.setKey("tom");
  notePad.setValue(20);
  
  System.out.println("姓名："+notePad.getKey()+" 年齡："+notePad.getValue());
 }
 
}

2、泛型介面：
/**
 * 泛型介面
 * @param <T>
 */
public interface Info<T> { //在介面上定義泛型
 public T getVar(); //定義抽象方法，抽象方法的傳回值就是泛型
}
//方式一
public class InfoImpl<T> implements Info<T> { //定義泛型介面的子類
 private T var;
 public InfoImpl(T var){
  this.setVar(var);
 }
 @Override
 public T getVar() {
  
  return this.var;
 }
 public void setVar(T var) {
  this.var = var;
 }
}

//方式二
public class InfoImpl2 implements Info<String> { //定義泛型介面的子類
 private String var;
 public InfoImpl2(String var){
  this.setVar(var);
 }
 @Override
 public String getVar() {
  return this.var;
 }
 public void setVar(String var) {
  this.var = var;
 }
}

//測試
public class GenericInfoImpl {
 public static void main(String[] args) {
  //方式一
  Info<String> info = new InfoImpl<String>("Tom");
  System.out.println("content："+info.getVar());
  //方式二
  Info info2 = new InfoImpl("湯姆");
  System.out.println("content2："+info2.getVar());
 }
}

3、泛型方法：
/**
 * 泛型方法
 */
public class GenericMethod {
 public <T> T test(T t){ //可以接收任意類型的資料
  
  return t; 
 }

 //測試
 public static void main(String[] args) {
  GenericMethod t = new GenericMethod();
  System.out.println(t.test("tom"));
  System.out.println(t.test(200));
 }
}

4、通過泛型方法返回泛型型別執行個體
/**
 * 通過泛型方法返回泛型型別執行個體
 * @param <T>
 */
public class ReturnGeneric<T extends Number> {
 private T var;

 public T getVar() {
  return var;
 }
 public void setVar(T var) {
  this.var = var;
 }
 @Override
 public String toString() {
  return var.toString();
 }
 //測試
 public static void main(String[] args) {
 System.out.println(     fun(100)      );
 }
 //方法中傳入或返回的泛型型別由調用方法時所設定的參數類型決定 
 public static <T extends Number> ReturnGeneric<T> fun(T param){
  ReturnGeneric<T> temp = new ReturnGeneric<T>(); //根據傳入的資料類型執行個體化Info 
  temp.setVar(param);
  return temp;
 }
}

5、 泛型數組
/**
 * 泛型數組
 */
public class ArrayGeneric {
 public static void main(String[] args) {
  Integer i[] = fun1(1,2,3,4,5,6,7,8);
  fun2(i);
 }
 public static <T> T[] fun1(T...arg){//接收可變參數
  return arg; //返回泛型數組
 }
 
 //測試
 public static <T> void fun2(T param[]){
  System.out.println("接收泛型數組");
  for(T t:param){
   System.out.println(t + "、");
  }
 }
}

6、泛型的嵌套設定
/**
 * 兩個泛型型別
 * @param <K>
 * @param <V>
 */
public class NotePad<K,V> { //此處指定了兩個泛型型別
 private K key; //類型由外部指定
 private V value; //類型由外部指定
 public K getKey() {
  return key;
 }
 public void setKey(K key) {
  this.key = key;
 }
 public V getValue() {
  return value;
 }
 public void setValue(V value) {
  this.value = value;
 }
}

/**
 * 泛型的嵌套設定
 * @author gongpb
 * @param <S>
 */
public class Nest<S> {
 private S var;
 
 public Nest(S var){
  this.setVar(var);
 }
 
 public S getVar() {
  return var;
 }
 public void setVar(S var) {
  this.var = var;
 }
 
 //測試
 public static void main(String[] args) {
  NotePad<String,Integer> np= new NotePad<String, Integer>();
  np.setKey("tom");
  np.setValue(25);
  
  Nest<NotePad<String, Integer>> nest = new Nest<NotePad<String,Integer>>(np);
  
  System.out.println("name："+nest.getVar().getKey()+" age："+nest.getVar().getValue());
 }
}