- 浏览: 241907 次
- 性别:
- 来自: 杭州
文章分类
最新评论
-
huangtut:
popdyc 写道请问作者有没有遇到过Intellij 插件开 ...
IntelliJ 9 插件开发 -
popdyc:
请问作者有没有遇到过Intellij 插件开发中用Runtim ...
IntelliJ 9 插件开发 -
ggd543:
好文,收藏
IntelliJ 9 插件开发 -
fengwei199181:
不错哦。
Groovy 学习 (整理修改自精通Groovy) -- Groovy 介绍与插件的安装 -
zhengweisincere:
我的评论呢?
通过分析SQL语句的执行计划优化SQL(总结)
JDK1.5 令我们期待很久,可是当他发布的时候却更换版本号为5.0。这说明Java已经有大幅度的变化。本文将讲解JDK5.0支持的新功能-----Java的泛型.
目录
1. 介绍
2. 定义简单Java泛型
3. 泛型通配符
3.1有限制的通配符
4.泛型与数据类型转换
4.1.消除类型转换
4.2 自动解包装与自动包装的功能
4.3 限制泛型中类型参数的范围
5.泛型方法
6. 和遗留代码的交互
6.1 在泛型代码中使用遗留代码
6.2 檫除和转换
6.3 在遗留代码中使用泛型
7 完美的打印
7.1 泛型类被所有的它的调用所共享
7.2 转型和InstanceOf
7.3 数组
8 在运行时类型拖肯的类的表面
9 非常有趣的通配符
9.1 通配符捕捉
10 使用泛型转换遗留代码
1. 介绍
2.定义简单Java泛型
其实Java的泛型就是创建一个用类型作为参数的类。就象我们写类的方法一样,方法是这样的method(String str1,String str2 ),方法中参数str1、str2的值是可变的。而泛型也是一样的,这样写class Java_Generics,这里边的K和V就象方法中的参数str1和str2,也是可变。下面看看例子:
import Java.util.Hashtable;
class TestGen0{
public Hashtable h=new Hashtable();
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 t=new TestGen0();
t.put("key", "value");
String s=t.get("key");
System.out.println(s);
}
}
正确输出:value
这只是个例子,不过看看是不是创建一个用类型作为参数的类,参数是K,V,传入的“值”是String类型。这个类他没有特定的待处理型别,以前我们定义好了一个类,在输入参数有所固定,是什么型别的有要求,但是现在编写程序,完全可以不制定参数的类型,具体用的时候来确定,增加了程序的通用性,像是一个模板。
3. 泛型通配符
首先,下面是一个例子,作用是打印出一个集合中的所有元素,我们首先用老版本jdk1.4的编码规则,代码如下:
void printColleciton(Collection c){
iterator i = c.iterator();
for (k = 0; k < c.size();k++){
System.out.pritnln(i.next();
}
然后,我们用jdk5.0泛型来重写上面这段代码(循环的语法是新版本的语法):
void printCollection(Colleciton< Object > c) {
for (Object e : c) {
System.out.print(e);
}
}
这个新版本并不比老版本的好多少,老版本可以用任意一种集合类型作为参数来调用,而新版本仅仅持有Collection< Object >类型,Colleciton< Object >并不是任意类型的Collection的超类。
那么什么是所有Colleciton类型的超类型呢?它是Collection< ?> 这样一个类型,读作“未知Colleciton”。它的意思是说Colleciton的元素类型可以匹配任意类型,我们把它称作通配符类型,我们这样写:
void printCollection(Colleciton c){
for (Object e: c){
System.out.println(e);
}
}
现在我们用任意类型的集合来调用它了,需要注意的是内部方法printColleciton(),我们任可以从c中来读出元素,并且这些元素是Object类型,而且是安全的,因为无论集合中是什么类型,它总包括Object,但是将任意对象加到集合中是不安全的:
Colleciton c = new ArrayList<string></string>();
c.add(new Object());//编译时错误
由于我们不知道c持有的是什么类型的元素,我们不能加object到集合中去。add()方法用类型E作为参数,(集合的元素类型)当真正的参数类型是?的时候,它代表的是一些未知类型。任何传递给add()方法的参数必须是这个未知类型的子类型。由于我们不知道未知类型,所以我们传递给它任何东西。主要的例外是null,它是每一个类型的成员。
另一方面,假定给一个List,我们调用get()并且充分利用结果。结果类型是未知类型。但是我总是知道它是一个Object,因此分配一个从get()取出来的结果到一个object的变量是安全的,或者作为一个参数传递到一个需要object类型的地方。
3.1有限制的通配符
考虑一个画图的应用程序,这个程序能够画长方形、圆等类型,为了在程序中表示这样的图形,你可以定义一个类型的层次结构:
public abstract class Shape{
public abstract void draw(Canvas c);
}
public class Circle extends Shape{
private int x,y,radius;
public void draw(Canvas c){}
}
public class Rectangle extends Shape{
private int x,y,width,height;
public void draw(Canvas c){
}
}
//这些类能被画在画布上:
public class Canvas{
public void draw(Shape s){
s.draw(this);
}
}
任何画图的动作的都包含一些图形,假设他们被表示在一个list中,在Canvas中它将会有一个很方便的方法来画他们:
public void drawAll(List<shape></shape> shapes){
for(Shape s :shapes){
s.draw(this);
}
}
现在类型规则说,方法drawAll()只能在真正的Shape类型的List上被调用,而它的子类无法调用,例如List< Circle >上被调用。这是很不幸的。由于所有的方法确实从List中读出Shape,所以它仅能在List< Object >上被调用,下面我们改后的代码可以在任意类型的Shape上被调用:
public void drawAll(List< ? extends Shape>{ }
这里有一个很小的不同是,我们已经用List<!---->替换了List< Object >,现在drawAll()方法可以接受任意的Shape的子类了,我们当然可以在List< Circle >上调用。
<!---->是一种限制通配符类型,它可以接受所有< Class >以及Class的子类型。然而调用代价是,只读访问,无法向shapes中添加元素。像通常一样,使用通配符带来的灵活性将付出代价,例如,下面是不允许的:
public void addRectangle(List<!----> shapes){
shapes.add(0,new Rectangle());//编译时错误
}
限制性通配符的一个例子是,是一个人口普查的例子,我们假设数据是由一个名字映射一个人,名字是字符串,人(可以是Person,或是它的子类Driver),Map是一个泛型的例子,它拥有两个参数,表示为一个KEY和value的映射MAP
再次注意正规参数的命名规则,K代表key,V代表value
public class Census{
public static void addRegistry(Map<string extends="" person=""></string> Registry){ }
}
Map allDrivers =;
census.addResigtry(allDrivers);
编写泛型类要注意:
1) 在定义一个泛型类的时候,在 “<>”之间定义形式类型参数,例如:“class TestGen”,其中“K” , “V”不代表值,而是表示类型。
2) 实例化泛型对象的时候,一定要在类名后面指定类型参数的值(类型),一共要有两次书写。例如:
TestGen t=new TestGen();
3) 泛型中<k object="" extends=""></k>,extends并不代表继承,它是类型范围限制。
4.泛型与数据类型转换
4.1. 消除类型转换
上面的例子大家看到什么了,数据类型转换的代码不见了。在以前我们经常要书写以下代码,如:
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中我们完全可以这么做,如:
import Java.util.Hashtable;
class Test {
public static void main(String[] args) {
Hashtable h = new Hashtable ();
h.put("key", new Integer(123));
int s = h.get("key").intValue();
System.out.println(s);
}
}
这里我们使用泛化版本的HashMap,这样就不用我们来编写类型转换的代码了,类型转换的过程交给编译器来处理,是不是很方便,而且很安全。上面是String映射到String,也可以将Integer映射为String,只要写成HashTable h=new HashTable();h.get(new Integer(0))返回value。果然很方便。
4.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给我们带来更多方便与安全。
public void autoBoxingUnboxing(int i) {
ArrayList<integer></integer> L= new ArrayList<integer></integer>();
L.add(i);
int a = L.get(0);
System.out.println("The value of i is " + a);
}
4.3 限制泛型中类型参数的范围
也许你已经发现在TestGen这个泛型类,其中K,V可以是任意的型别。也许你有时候呢想限定一下K和V当然范围,怎么做呢?看看如下的代码:
class TestGen2<k extends="" extents="" number=""></k>
{
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 t2=new TestGen2();
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=""></e>,这个泛型的范围就是上图中兰色部分。
这个是单一的限制,你也可以对型别多重限制,如下:
class C<t extends="" super="" t=""></t> & Serializable>
我们来分析以下这句,T extends Comparable这个是对上限的限制,Comparable< super T>这个是下限的限制,Serializable是第2个上限。一个指定的类型参数可以具有一个或多个上限。具有多重限制的类型参数可以用于访问它的每个限制的方法和域。
5.泛型方法
考虑写一个持有数组类型对象和一个集合对象的方法,把数组里的所有对象都放到
集合里。第一个程序为:
static void fromArrayToColleciton(Object[]a,Collection c){
for (Object o : a){
c.add(o);//编译时错误
}
}
到现在为止,你可能学会避免开始的错误而去使用Collection< Object >作为集合参数的类型,你可能会意识到使用Colleciton< ? >将不会工作。
解决这个问题的方法是使用泛型方法,GENERIC METHODS,就像类型声明、方法声明一样,就是被一个或更多的类型参数参数化。
static <t></t>void fromArrayToCollection(T[]a,Collection<t></t> c){
for(T o :a){
c.add(o);//正确
}
}
我们可以用任意类型的集合调用这个方法,他的元素类型是数组元素类型的超类型。
Object[] oa = new Object[100];
Collection < Object > co = new ArrayList< Object >();
fromArrayToCollection(oa,co);//T 被认为是Object类型
String[] sa = new String[100];
Colleciton< String > cs = new ArrayList< String >();
fromArrayToCollection(sa,cs);//T被认为是String类型
fromArrayToCollection(sa,co);//T 被认为是Object类型
Integer[] is = new Integer[100];
Float[] fa = new Float[100];
Number[] na = new Number[100];
Collection< Number > cn = new ArrayList< Number >();
fromArrayToCollection(is,cn);//Number
fromArrayToCollection(fa,cn);//Number
fromArrayToCollection(na,cn);//Number
fromArrayToCollection(na,co);//Object
fromArrayToCollection(na,cs);//编译时错误
我们不必给一个泛型方法传递一个真正的类型参数,编译器会推断类型参数.一个问题出现了,什么时候使用泛型方法,什么时候使通配符类型,为了回答这些问题,我们从Colleciton库中看一下几个方法:
interface Collection<e></e>{
public boolean containsAll(Collection c);
public boolean addAll(Collection<!----> c);
}
使用泛型方法的形式为:
interface Collection<e></e>{
public <t></t>boolean containsAll(Collection<t></t> c);
public <t extends="" e=""></t>boolean addAll(Collection<t></t> c);
}
无论如何,在ContainAll和addAll中,类型参数T仅被使用一次。返回类型不依赖于类型参数,也不依赖方法中的任何参数。这告诉我类型参数正被用于多态,它的影响仅仅是允许不同的实参在不同的调用点被使用。
泛型方法允许类型参数被用于表达在一个或更多参数之间或者方法中的参数、返回类型的依赖。如果没有如此依赖,泛型方法就不能被使用。可能一前一后来联合使用泛型和通配符,这里有个例子:
class Collections{
public static <t></t>void copy(List<t></t> dest,List<!----> src){
}
}
注意两个参数之间的依赖,任何从原list的对象复制,必须分配一个目标LIST元素的类型T,于是Src的元素类型可能是任何T的子类型。我们不必在意在COPY的表达中,表示依赖使用一个类型参数,但是是使用一个通配符。
下面我们不使用通配符来重写上面的方法:
class Collections{
public static < T,S extends T >
void copy(List< T > dest,List< S > src){
}
}
这非常好,但是第一个类型参数既在dst中使用,也在第二个类型参数中使用,S本身就被使用了一次。在类型src中,没有什么类型依赖它。这是一个标志我们可以用通配符来替换它。使用通配符比显示的声明类型参数更加清楚和精确。所以有可能推荐使用通配符。
通配符也有优势,可以在方法之外来使用,作为字段类型、局部变量和数组。
这里有一个例子。
返回到我们画图的例子,假设我们要保持一个画图请求的历史,我们可以在Shape类内部用一个静态变量来保持历史。用drawAll()存储它到来的参数到历史字段。
static List< List < ? extends Shape > > history =
new ArrayList < List < ? extends Shape > >();
public void drawAll(List<!----> shapes){
history.addLast(shapes
发表评论
-
spring
2011-07-11 13:49 784SPRING 2.5 API 中文在线 备忘 http://a ... -
转:Tomcat免重启随意更改java代码 提高开发效率
2011-05-19 17:31 1308原文地址:http://blog.chinaacc.com/w ... -
转:Java远程通讯可选技术及原理
2011-05-10 17:33 1184原文地址:http://java.chinai ... -
转:Hessian 原理分析
2011-05-10 17:01 4184原文:http://blog.csdn.net/zhtang0 ... -
转:Java 字符串编码
2010-09-09 16:40 1666出处:http://blog.sina.com.c ... -
另一种遍历Map的方式: Map.Entry 和 Map.entrySet() (转)
2010-06-11 17:13 2431今天看Think in java 的GUI这一章的时候,里面的 ... -
(转载)什么是线程?
2010-03-18 14:56 1023什么是线程?2007年06月01日 星期五 09:19线程是程 ... -
Java 内存机制
2009-07-08 12:50 919java中内存分配策略及堆 ... -
JAVA中多种计时器的比较与分析
2009-06-09 14:57 4150介绍 计时器可以提供运行基于时间的工作任务的功能,在计时器 ... -
正确使用 Volatile 变量
2009-05-19 09:31 814Java™ 语言包含两种内 ... -
servlet2.5/jsp2.1的新特征(转载)
2009-04-23 15:03 1037005年9月26日,Sun公司和JSR154的专家组发布Ser ... -
ThreadLocal的设计与使用(原理篇
2009-04-22 10:57 773ThreadLocal的设计与使用(原理篇) ... -
企业系统管理体系 用J2EE架构企业级应用(3)
2009-04-09 21:39 995J2EE的各种组件 我们就J2EE的各种组件、服务和AP ... -
企业系统管理体系 用J2EE架构企业级应用(2)
2009-04-09 21:34 1347企业级资源连接 ... -
企业系统管理体系 用J2EE架构企业级应用(1)
2009-04-09 21:27 1064企业级应用是指那些 ... -
对比XStream和JSON
2009-03-30 20:04 1295XStream是thoughtworks开发的开源产品,采用的 ... -
Java 设计原则
2009-03-29 13:13 12691. ”开-闭”原则 (Open-Close Principl ... -
Martin Fowler:持续集成
2008-12-04 16:17 1002本文原文链接:http://martinfowler.com/ ... -
十个最好的Java性能故障排除工具
2008-12-01 16:09 1250推荐十个最好的Java性能故障排除工具:1.jconsole是 ... -
转:Eclipse快捷键 Template用法探讨
2007-07-23 13:34 2740Eclipse Template用法探讨 在编码的过程中,对 ...
相关推荐
总结来说,JDK5.0是Java发展中的关键版本,引入了泛型、枚举、自动装箱/拆箱等新特性,极大地简化了编码。正确下载、安装并配置JDK5.0后,就可以开始愉快的Java编程之旅,而"HelloWorld"则是学习任何编程语言的第一...
2. **泛型(Generics)**:泛型是JDK 5.0最重要的特性之一,允许在类、接口和集合中定义类型参数,提高了代码的重用性,减少了类型转换的错误,增强了编译时的类型检查。 3. **自动装箱与拆箱**:JDK 5.0中,原始...
通过深入学习《良葛格JDK5.0学习笔记》,开发者能够全面了解并熟练运用这些新特性,提升代码质量和效率,更好地适应Java编程的新时代。这份笔记对于Java初学者和有一定经验的开发者来说都是一份宝贵的参考资料。
4. **增强的for循环(Enhanced For Loop)**:也称为foreach循环,是JDK 5.0引入的新特性,简化了遍历数组和集合的操作。如`for (Type item : arrayOrCollection) { ... }`。 5. **变量注解(Variable Annotations...
Java JDK 5.0是Java发展历程中的一个重要里程碑,它的发布带来了许多创新特性和改进,显著提升了开发效率和代码质量。以下是对"良葛格Java JDK 5.0学习笔记fuluB"中可能涵盖的关键知识点的详细解释: 1. **泛型**:...
### JDK 5.0 新特性详解 #### 一、增强的 for 循环(ForEach Loop) JDK 5.0 引入了增强的 `for` 循环,也称为 foreach 循环,用于简化对集合和数组的操作。这种循环语法更加简洁,易于阅读。 **示例代码:** ``...
Java JDK 5.0,又称为JDK 1.5,是Java开发工具包的一个重要升级,它引入了大量的新特性和改进,极大地提升了Java编程的...而"jdk5.0新特征.txt"则可能包含了对所有新特性的详细描述和使用示例,是深入学习的好资源。
Java JDK 5.0是Java开发工具包的一个重要版本,它的发布标志着Java语言的重大进步,引入了许多新特性,为开发者提供了更高效、更简洁的编程体验。以下是对这个主题的详细解析: 1. **自动装箱与拆箱**:在JDK 5.0...
以上就是JDK 5.0中的一些重要新特性,这些特性极大地推动了Java语言的发展,使其在软件开发领域保持了强大的竞争力。通过学习和掌握这些特性,开发者可以编写出更加高效、健壮和易于维护的代码。
在这个名为“JDK5.0新特性源代码”的压缩包中,我们可以期待找到与这些关键特性相关的源代码示例。以下是JDK 5.0引入的一些核心新特性及其详细解释: 1. **泛型(Generics)**:泛型允许在类、接口和方法中声明类型...
泛型是JDK 5.0引入的一项重大新特性,极大地提高了Java编程的类型安全性和效率。泛型允许我们在定义类、接口和方法时使用类型参数,而不是具体的类型,这样在编译期间就能进行类型检查,防止了运行时可能出现的...
Java JDK 5.0是Java开发工具包的一个重要版本...通过深入学习,不仅可以理解JDK 5.0的新特性,还能为后续的J2EE开发打下坚实基础。对于初学者来说,这是一份极好的入门资源,能够帮助他们快速掌握Java编程的关键技能。
泛型是JDK 5.0中最关键的特性之一,它允许我们在类、接口和方法中使用类型参数,从而在编译时就能检查类型安全。泛型帮助我们避免了运行时的`ClassCastException`,因为它们确保了集合和容器中存储的数据类型与预期...
6. **泛型**:泛型是JDK 5.0引入的重要特性,用于在编译时检查类型安全,并且允许创建可重用的类型安全代码。泛型可以应用于类、接口和方法,提供了一种更强大的类型系统。 7. **类型推断**:JDK 5.0开始,Java...
JDK5.0是Java开发的一个重要里程碑,它引入了11个主要的新特性,极大地提升了编程效率和代码安全性。以下是对这些特性的详细说明: 1. 泛型(Generic) 泛型的引入是为了解决类型安全问题,避免在运行时进行不必要...
JDK 5.0,也被称为Java SE 5.0,是Java发展历程中的一次重大更新,引入了许多关键性的新特性,对Java编程语言产生了深远影响。以下是对这个版本中核心知识点的详细解释: 1. **泛型(Generics)**:泛型是JDK 5.0...
总结,JDK5.0是Java发展的重要里程碑,它的新特性显著提高了编程的效率和代码质量。通过配置并使用JDK5.0,开发者能够更好地理解和掌握Java编程,从而积累丰富的学习经验。同时,了解和熟练使用bin目录下的各种工具...
JDK 5.0提供了新的jstack工具,可以帮助开发者检测和诊断多线程程序中的死锁问题。 十、NIO.2(New I/O 2) 虽然NIO.2是在JDK 7中引入的,但它是对JDK 5.0中NIO的扩展,增加了对文件系统操作的全面支持,如异步I/O...