程序博客网 > excel的数据库管理功能

全面总结Java泛型

来源：互联网 发布：excel的数据库管理功能 编辑：程序博客网 时间：2024/05/21 20:25

本文对Java泛型进行了全面的总结。文章内容包括普通泛型、通配符、受限泛型、泛型接口、泛型方法、返回泛型类型实例等等。

AD：51CTO 网+ 第十二期沙龙：大话数据之美_如何用数据驱动用户体验

虽然Scala创始人Martin Odersky说当年正是因为Java泛型的丑陋，所以才想到要创建一个新的语言，不过这仍然不妨碍我们学习Java泛型。毕竟即使听说Java泛型不好用，但好不好用还是得会用了才知道。下面是一些有关Java泛型的总结：

普通泛型

  1. class Point< T>{  // 此处可以随便写标识符号，T是type的简称  
  2.  private T var ; // var的类型由T指定，即：由外部指定  
  3.  public T getVar(){ // 返回值的类型由外部决定  
  4.   return var ;  
  5.  }  
  6.  public void setVar(T var){ // 设置的类型也由外部决定  
  7.   this.var = var ;  
  8.  }  
  9. };  
  10. public class GenericsDemo06{  
  11.  public static void main(String args[]){  
  12.   Point< String> p = new Point< String>() ; // 里面的var类型为String类型  
  13.   p.setVar("it") ;  // 设置字符串  
  14.   System.out.println(p.getVar().length()) ; // 取得字符串的长度  
  15.  }  
  16. };  

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

  1. class Notepad< K,V>{  // 此处指定了两个泛型类型  
  2.  private K key ;  // 此变量的类型由外部决定  
  3.  private V value ; // 此变量的类型由外部决定  
  4.  public K getKey(){  
  5.   return this.key ;  
  6.  }  
  7.  public V getValue(){  
  8.   return this.value ;  
  9.  }  
  10.  public void setKey(K key){  
  11.   this.key = key ;  
  12.  }  
  13.  public void setValue(V value){  
  14.   this.value = value ;  
  15.  }  
  16. };  
  17. public class GenericsDemo09{  
  18.  public static void main(String args[]){  
  19.   Notepad< String,Integer> t = null ;  // 定义两个泛型类型的对象  
  20.   t = new Notepad< String,Integer>() ;  // 里面的key为String，value为Integer  
  21.   t.setKey("汤姆") ;  // 设置第一个内容  
  22.   t.setValue(20) ;   // 设置第二个内容  
  23.   System.out.print("姓名；" + t.getKey()) ;  // 取得信息  
  24.   System.out.print("，年龄；" + t.getValue()) ;  // 取得信息  
  25.  
  26.  }  
  27. };  
  28.    

通配符

  1. class Info< T>{  
  2.  private T var ;  // 定义泛型变量  
  3.  public void setVar(T var){  
  4.   this.var = var ;  
  5.  }  
  6.  public T getVar(){  
  7.   return this.var ;  
  8.  }  
  9.  public String toString(){ // 直接打印  
  10.   return this.var.toString() ;  
  11.  }  
  12. };  
  13. public class GenericsDemo14{  
  14.  public static void main(String args[]){  
  15.   Info< String> i = new Info< String>() ;  // 使用String为泛型类型  
  16.   i.setVar("it") ;       // 设置内容  
  17.   fun(i) ;  
  18.  }  
  19.  public static void fun(Info< ?> temp){  // 可以接收任意的泛型对象  
  20.   System.out.println("内容：" + temp) ;  
  21.  }  
  22. };  
  23.   

受限泛型

  1. class Info< T>{  
  2.  private T var ;  // 定义泛型变量  
  3.  public void setVar(T var){  
  4.   this.var = var ;  
  5.  }  
  6.  public T getVar(){  
  7.   return this.var ;  
  8.  }  
  9.  public String toString(){ // 直接打印  
  10.   return this.var.toString() ;  
  11.  }  
  12. };  
  13. public class GenericsDemo17{  
  14.  public static void main(String args[]){  
  15.   Info< Integer> i1 = new Info< Integer>() ;  // 声明Integer的泛型对象  
  16.   Info< Float> i2 = new Info< Float>() ;   // 声明Float的泛型对象  
  17.   i1.setVar(30) ;         // 设置整数，自动装箱  
  18.   i2.setVar(30.1f) ;        // 设置小数，自动装箱  
  19.   fun(i1) ;  
  20.   fun(i2) ;  
  21.  }  
  22.  public static void fun(Info< ? extends Number> temp){ // 只能接收Number及其Number的子类  
  23.   System.out.print(temp + "、") ;  
  24.  }  
  25. };  

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

  1.  
  2. class Info< T>{  
  3.  private T var ;  // 定义泛型变量  
  4.  public void setVar(T var){  
  5.   this.var = var ;  
  6.  }  
  7.  public T getVar(){  
  8.   return this.var ;  
  9.  }  
  10.  public String toString(){ // 直接打印  
  11.   return this.var.toString() ;  
  12.  }  
  13. };  
  14. public class GenericsDemo21{  
  15.  public static void main(String args[]){  
  16.   Info< String> i1 = new Info< String>() ;  // 声明String的泛型对象  
  17.   Info< Object> i2 = new Info< Object>() ;  // 声明Object的泛型对象  
  18.   i1.setVar("hello") ;  
  19.   i2.setVar(new Object()) ;  
  20.   fun(i1) ;  
  21.   fun(i2) ;  
  22.  }  
  23.  public static void fun(Info< ? super String> temp){ // 只能接收String或Object类型的泛型  
  24.   System.out.print(temp + "、") ;  
  25.  }  
  26. };  
  27.   

Java泛型无法向上转型

  1. class Info< T>{  
  2.  private T var ;  // 定义泛型变量  
  3.  public void setVar(T var){  
  4.   this.var = var ;  
  5.  }  
  6.  public T getVar(){  
  7.   return this.var ;  
  8.  }  
  9.  public String toString(){ // 直接打印  
  10.   return this.var.toString() ;  
  11.  }  
  12. };  
  13. public class GenericsDemo23{  
  14.  public static void main(String args[]){  
  15.   Info< String> i1 = new Info< String>() ;  // 泛型类型为String  
  16.   Info< Object> i2 = null ;  
  17.   i2 = i1 ;        //这句会出错 incompatible types  
  18.  }  
  19. };  
  20.   

Java泛型接口

  1. interface Info< T>{  // 在接口上定义泛型  
  2.  public T getVar() ; // 定义抽象方法，抽象方法的返回值就是泛型类型  
  3. }  
  4. class InfoImpl< T> implements Info< T>{ // 定义泛型接口的子类  
  5.  private T var ;    // 定义属性  
  6.  public InfoImpl(T var){  // 通过构造方法设置属性内容  
  7.   this.setVar(var) ;   
  8.  }  
  9.  public void setVar(T var){  
  10.   this.var = var ;  
  11.  }  
  12.  public T getVar(){  
  13.   return this.var ;  
  14.  }  
  15. };  
  16. public class GenericsDemo24{  
  17.  public static void main(String arsg[]){  
  18.   Info< String> i = null;  // 声明接口对象  
  19.   i = new InfoImpl< String>("汤姆") ; // 通过子类实例化对象  
  20.   System.out.println("内容：" + i.getVar()) ;  
  21.  }  
  22. };  

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

  1.  
  2. interface Info< T>{  // 在接口上定义泛型  
  3.  public T getVar() ; // 定义抽象方法，抽象方法的返回值就是泛型类型  
  4. }  
  5. class InfoImpl implements Info< String>{ // 定义泛型接口的子类  
  6.  private String var ;    // 定义属性  
  7.  public InfoImpl(String var){  // 通过构造方法设置属性内容  
  8.   this.setVar(var) ;   
  9.  }  
  10.  public void setVar(String var){  
  11.   this.var = var ;  
  12.  }  
  13.  public String getVar(){  
  14.   return this.var ;  
  15.  }  
  16. };  
  17. public class GenericsDemo25{  
  18.  public static void main(String arsg[]){  
  19.   Info i = null;  // 声明接口对象  
  20.   i = new InfoImpl("汤姆") ; // 通过子类实例化对象  
  21.   System.out.println("内容：" + i.getVar()) ;  
  22.  }  
  23. };  
  24.   

Java泛型方法

  1. class Demo{  
  2.  public < T> T fun(T t){   // 可以接收任意类型的数据  
  3.   return t ;     // 直接把参数返回  
  4.  }  
  5. };  
  6. public class GenericsDemo26{  
  7.  public static void main(String args[]){  
  8.   Demo d = new Demo() ; // 实例化Demo对象  
  9.   String str = d.fun("汤姆") ; // 传递字符串  
  10.   int i = d.fun(30) ;  // 传递数字，自动装箱  
  11.   System.out.println(str) ; // 输出内容  
  12.   System.out.println(i) ;  // 输出内容  
  13.  }  
  14. };  
  15.   

通过泛型方法返回泛型类型实例

  1. class Info< T extends Number>{ // 指定上限，只能是数字类型  
  2.  private T var ;  // 此类型由外部决定  
  3.  public T getVar(){  
  4.   return this.var ;   
  5.  }  
  6.  public void setVar(T var){  
  7.   this.var = var ;  
  8.  }  
  9.  public String toString(){  // 覆写Object类中的toString()方法  
  10.   return this.var.toString() ;   
  11.  }  
  12. };  
  13. public class GenericsDemo27{  
  14.  public static void main(String args[]){  
  15.   Info< Integer> i = fun(30) ;  
  16.   System.out.println(i.getVar()) ;  
  17.  }  
  18.  public static < T extends Number> Info< T> fun(T param){//方法中传入或返回的泛型类型由调用方法时所设置的参数类型决定  
  19.   Info< T> temp = new Info< T>() ;  // 根据传入的数据类型实例化Info  
  20.   temp.setVar(param) ;  // 将传递的内容设置到Info对象的var属性之中  
  21.   return temp ; // 返回实例化对象  
  22.  }  
  23. };  
  24.   

使用泛型统一传入的参数类型

  1. class Info< T>{ // 指定上限，只能是数字类型  
  2.  private T var ;  // 此类型由外部决定  
  3.  public T getVar(){  
  4.   return this.var ;   
  5.  }  
  6.  public void setVar(T var){  
  7.   this.var = var ;  
  8.  }  
  9.  public String toString(){  // 覆写Object类中的toString()方法  
  10.   return this.var.toString() ;   
  11.  }  
  12. };  
  13. public class GenericsDemo28{  
  14.  public static void main(String args[]){  
  15.   Info< String> i1 = new Info< String>() ;  
  16.   Info< String> i2 = new Info< String>() ;  
  17.   i1.setVar("HELLO") ;  // 设置内容  
  18.   i2.setVar("汤姆") ;  // 设置内容  
  19.   add(i1,i2) ;  
  20.  }  
  21.  public static < T> void add(Info< T> i1,Info< T> i2){  
  22.   System.out.println(i1.getVar() + " " + i2.getVar()) ;  
  23.  }  
  24. };  
  25.   

Java泛型数组

  1. public class GenericsDemo30{  
  2.  public static void main(String args[]){  
  3.   Integer i[] = fun1(1,2,3,4,5,6) ; // 返回泛型数组  
  4.   fun2(i) ;  
  5.  }  
  6.  public static < T> T[] fun1(T...arg){ // 接收可变参数  
  7.   return arg ;   // 返回泛型数组  
  8.  }  
  9.  public static < T> void fun2(T param[]){ // 输出  
  10.   System.out.print("接收泛型数组：") ;  
  11.   for(T t:param){  
  12.    System.out.print(t + "、") ;  
  13.   }  
  14.  }  
  15. };  
  16.   

Java泛型的嵌套设置

  1. class Info< T,V>{  // 接收两个泛型类型  
  2.  private T var ;  
  3.  private V value ;  
  4.  public Info(T var,V value){  
  5.   this.setVar(var) ;  
  6.   this.setValue(value) ;  
  7.  }  
  8.  public void setVar(T var){  
  9.   this.var = var ;  
  10.  }  
  11.  public void setValue(V value){  
  12.   this.value = value ;  
  13.  }  
  14.  public T getVar(){  
  15.   return this.var ;  
  16.  }  
  17.  public V getValue(){  
  18.   return this.value ;  
  19.  }  
  20. };  
  21. class Demo< S>{  
  22.  private S info ;  
  23.  public Demo(S info){  
  24.   this.setInfo(info) ;  
  25.  }  
  26.  public void setInfo(S info){  
  27.   this.info = info ;  
  28.  }  
  29.  public S getInfo(){  
  30.   return this.info ;  
  31.  }  
  32. };  
  33. public class GenericsDemo31{  
  34.  public static void main(String args[]){  
  35.   Demo< Info< String,Integer>> d = null ;  // 将Info作为Demo的泛型类型  
  36.   Info< String,Integer> i = null ; // Info指定两个泛型类型  
  37.   i = new Info< String,Integer>("汤姆",30) ;  // 实例化Info对象  
  38.   d = new Demo< Info< String,Integer>>(i) ; // 在Demo类中设置Info类的对象  
  39.   System.out.println("内容一：" + d.getInfo().getVar()) ;  
  40.   System.out.println("内容二：" + d.getInfo().getValue()) ;  
  41.  }  
  42. };  

JDK1.5 令我们期待很久,可是当他发布的时候却更换版本号为5.0。这说明Java已经有大幅度的变化。本文将讲解JDK5.0支持的新功能-----Java的泛型. 
1、Java泛型 
其实Java的泛型就是创建一个用类型作为参数的类。就象我们写类的方法一样，方法是这样的method(String str1,String str2 ),方法中参数str1、str2的值是可变的。而泛型也是一样的，这样写class Java_Generics＜K,V＞，这里边的K和V就象方法中的参数str1和str2,也是可变。下面看看例子： 
//code list 1 
import Java.util.Hashtable; 
class TestGen0＜K,V＞{ 
　public Hashtable＜K,V＞ h=new Hashtable＜K,V＞(); 
　public void put(K k, V v) { 
h.put(k,v); 
　} 
　public V get(K k) { 
return h.get(k); 
　} 
　public static void main(String args[]){ 
TestGen0＜String,String＞ t=new TestGen0＜String,String＞(); 
t.put("key", "value"); 
String s=t.get("key"); 
System.out.println(s); 
　} 
} 
正确输出:value 
这只是个例子（Java中集合框架都泛型化了，这里费了2遍事.），不过看看是不是创建一个用类型作为参数的类，参数是K，V，传入的“值”是String类型。这个类他没有特定的待处理型别，以前我们定义好了一个类，在输入输入参数有所固定，是什么型别的有要求，但是现在编写程序，完全可以不制定参数的类型，具体用的时候来确定，增加了程序的通用性，像是一个模板。
呵呵，类似C++的模板（类似）。 
1.1. 泛型通配符 
下面我们先看看这些程序： 
//Code list 2 
void TestGen0Medthod1(List l) { 
　for (Object o : l) 
System.out.println(o); 
} 
看看这个方法有没有异议，这个方法会通过编译的，假如你传入String，就是这样List＜String＞。
接着我们调用它,问题就出现了，我们将一个List＜String＞当作List传给了方法，JVM会给我们一个警告，说这个破坏了类型安全，因为从List中返回的都是Object类型的，而让我们再看看下面的方法。 
//Code list 3 
void TestGen0Medthod1(List＜String＞ l) { 
　for (Object o : l) 
System.out.println(o); 
} 
因为这里的List＜String＞不是List＜Object＞的子类,不是String与Object的关系，就是说List＜String＞不隶属于list＜Object＞,他们不是继承关系，所以是不行的，这里的extends是表示限制的。 
类型通配符是很神奇的，List＜?＞这个你能为他做什么呢?怎么都是“？”，它似乎不确定，他总不能返回一个？作为类型的数据吧，是啊他是不会返回一个“？”来问程序员的？JVM会做简单的思考的，看看代码吧，更直观些。 
//code list 4 
List＜String＞ l1 = new ArrayList＜String＞(); 
li.add(“String”); 
List＜?＞ l2 = l1; 
System.out.println(l1.get(0)); 
这段代码没问题的，l1.get(0)将返回一个Object。 
　　1.2. 编写泛型类要注意： 
1) 在定义一个泛型类的时候，在 “＜＞”之间定义形式类型参数，例如：“class TestGen＜K,V＞”，其中“K” , “V”不代表值，而是表示类型。 
2) 实例化泛型对象的时候，一定要在类名后面指定类型参数的值（类型），一共要有两次书写。例如：
TestGen＜String,String＞ t=new TestGen＜String,String＞()； 
3) 泛型中＜K extends Object＞,extends并不代表继承，它是类型范围限制。 
2、泛型与数据类型转换 
2.1. 消除类型转换 
上面的例子大家看到什么了，数据类型转换的代码不见了。在以前我们经常要书写以下代码，如： 
//code list 5 
import Java.util.Hashtable; 
class Test { 
　public static void main(String[] args) { 
Hashtable h = new Hashtable(); 
h.put("key", "value"); 
String s = (String)h.get("key"); 
System.out.println(s); 
　} 
} 
这个我们做了类型转换，是不是感觉很烦的，并且强制类型转换会带来潜在的危险，系统可能会抛一个ClassCastException异常信息。在JDK5.0中我们完全可以这么做，如： 
//code list 6 
import Java.util.Hashtable; 
class Test { 
　public static void main(String[] args) { 
Hashtable＜String,Integer＞ h = new Hashtable＜String,Integer＞ (); 
h.put("key", new Integer(123)); 
int s = h.get("key").intValue(); 
System.out.println(s); 
　} 
} 
这里我们使用泛化版本的HashMap,这样就不用我们来编写类型转换的代码了，类型转换的过程交给编译器来处理，是不是很方便，而且很安全。上面是String映射到String，也可以将Integer映射为String，只要写成HashTable＜Integer,String＞ h=new HashTable＜Integer,String＞();h.get(new Integer(0))返回value。果然很方便。 
2.2 自动解包装与自动包装的功能 
从上面有没有看到有点别扭啊，h.get(new Integer(123))这里的new Integer(123);好烦的，在JDK5.0之前我们只能忍着了，现在这种问题已经解决了，请看下面这个方法。我们传入一个int这一基本型别，然后再将i的值直接添加到List中，其实List是不能储存基本型别的，List中应该存储对象，这里编译器将int包装成Integer，然后添加到List中去。接着我们用List.get(0);来检索数据，并返回对象再将对象解包装成int。恩，JDK5.0给我们带来更多方便与安全。 
//Code list 7 
public void autoBoxingUnboxing(int i) { 
　ArrayList＜Integer＞ L= new ArrayList＜Integer＞(); 
　L.add(i); 
　int a = L.get(0); 
　System.out.println("The value of i is " + a); 
} 
2.3 限制泛型中类型参数的范围 
也许你已经发现在code list 1中的TestGen＜K,V＞这个泛型类,其中K,V可以是任意的型别。也许你有时候呢想限定一下K和V当然范围，怎么做呢？看看如下的代码： 
//Code list 8 
class TestGen2＜K extents String,V extends Number＞ 
{ 
　private V v=null; 
　private K k=null; 
　public void setV(V v){ 
this.v=v; 
　} 
　public V getV(){ 
return this.v; 
　} 
　public void setK(K k){ 
this.k=k; 
　} 
　public V getK(){ 
return this.k; 
　} 
　public static void main(String[] args) 
　{ 
TestGen2＜String,Integer＞ t2=new TestGen2＜String,Integer＞(); 
t2.setK(new String("String")); 
t2.setV(new Integer(123)); 
System.out.println(t2.getK()); 
System.out.println(t2.getV()); 
　} 
} 
上边K的范围是＜=String ，V的范围是＜=Number，注意是“＜=”,对于K可以是String的，V当然也可以是Number，也可以是Integer,Float,Double,Byte等。看看下图也许能直观些请看上图A是上图类中的基类，A1，A2分别是A的子类，A2有2个子类分别是A2_1，A2_2。 
然后我们定义一个受限的泛型类class MyGen＜E extends A2＞,这个泛型的范围就是上图中兰色部分。 
这个是单一的限制，你也可以对型别多重限制，如下： 
class C＜T extends Comparable＜? super T＞ & Serializable＞ 
我们来分析以下这句，T extends Comparable这个是对上限的限制，Comparable＜ super T＞这个是下限的限制，Serializable是第2个上限。一个指定的类型参数可以具有一个或多个上限。具有多重限制的类型参数可以用于访问它的每个限制的方法和域。 
2.4. 多态方法 
//Code list 9 
class TestGen { 
　＜T extends Object＞ public static List＜T＞ make(T first) { 
return new List＜T＞(first); 
　} 
} 

0 0
excel的数据库管理功能 excel的数据库管理功能
原创粉丝点击
热门IT博客
谱谱风打谱软件谱谱风打谱软件
苏州经济数据苏州经济数据
怎样下载spss软件
freebsd apache
周易取名软件
手机网络精灵
社工库 数据分享
真实大帝 知乎
张家口网络广播电视台
java continue的用法
兄弟连php培训费用
电脑视频播放软件
医药大数据分析
直销软件52loser
win7优化 批处理
nginx 跨域 header
2017淘宝大学开店视频
淘宝折扣 团购
淘宝助理5.0版下载
淘宝企业店铺类目列表
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 奇兔 199几年属兔 今天要来点兔子吗 比得兔 火兔 兔子的种类 为什么叫中国兔子 今日兔价 好兔 兔和兔相配吗 养兔网 玩兔 土吧兔 萌兔 属兔与属鸡 兔毫 宋建窑黑釉兔毫盏 兔毫盏价格 兔吮毫 什么是兔毫盏 建窑兔毫盏的价格 建盏兔毫 兔毫建盏图片 兔毫盏鉴定 建盏兔毫价格多少 兔毫盏怎么养 真品兔毫盏价格多少 建盏兔毫价格 兔毫盏多少钱一个 宋建窑兔毫盏 兔毫盏拍卖 兔毫建盏价格 宋代建窑兔毫盏 建盏 兔毫 建窑兔毫盏 兔毫盏图片 叶礼旺兔毫盏价格 叶礼忠兔毫盏价格 布朗熊可妮兔 可妮兔和布朗熊 可妮兔布朗熊

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里