从应用角度细说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());
 }
}