`
taimukang
  • 浏览: 183992 次
  • 性别: Icon_minigender_1
  • 来自: 广州
社区版块
存档分类
最新评论

JDK1.5/1.6新特性总结

阅读更多
一、JDK1.5新特性
1、泛型(Generic)

可以在编译的时候检测出类型错误,编译后和没有使用泛型的效果是相同的,但是使用泛型可以让你在编译时就发现错误,例如:
例1-1代码

   1. import java.util.ArrayList;  
   2. import java.util.Collection;  
   3. import java.util.Iterator;  
   4.  
   5. public class GenericTest {  
   6.     public static void main(String[] args) {  
   7.         Collection c = new ArrayList();  
   8.         c.add(new Integer(1));  
   9.         c.add("123");  
  10.         for(Iterator i=c.iterator();i.hasNext();){  
  11.             String s = (String) i.next();  
  12.             System.out.println(s);  
  13.         }  
  14.     }  
  15. }  
  16.  
  17. 运行结果:  
  18. Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String  
  19.     at GenericTest.main(GenericTest.java:12) 

例1-1代码

   1. import java.util.ArrayList; 
   2. import java.util.Collection; 
   3. import java.util.Iterator; 
   4.  
   5. public class GenericTest { 
   6.     public static void main(String[] args) { 
   7.         Collection c = new ArrayList(); 
   8.         c.add(new Integer(1)); 
   9.         c.add("123"); 
  10.         for(Iterator i=c.iterator();i.hasNext();){ 
  11.             String s = (String) i.next(); 
  12.             System.out.println(s); 
  13.         } 
  14.     } 
  15. } 
  16.  
  17. 运行结果: 
  18. Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String 
  19.     at GenericTest.main(GenericTest.java:12) 

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class GenericTest {
public static void main(String[] args) {
Collection c = new ArrayList();
c.add(new Integer(1));
c.add("123");
for(Iterator i=c.iterator();i.hasNext();){
String s = (String) i.next();
System.out.println(s);
}
}
}

运行结果:
Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
at GenericTest.main(GenericTest.java:12)

Collection应该只存放String对象,但是我们“不小心”添加了一个Integer类型的对象,编译正常进行,程序在运行时才发现错误。

下面是使用了泛型后的程序
例1-2代码 复制代码

   1. import java.util.ArrayList;  
   2. import java.util.Collection;  
   3. import java.util.Iterator;  
   4.  
   5. public class GenericTest {  
   6.     public static void main(String[] args) {  
   7.         Collection<String> c = new ArrayList<String>();  
   8.         c.add(new Integer(1));  
   9.         c.add("123");  
  10.         for(Iterator<String> i=c.iterator();i.hasNext();){  
  11.             String s = i.next();  
  12.             System.out.println(s);  
  13.         }  
  14.     }  
  15. }  
  16.  
  17. 运行结果  
  18. D:\test>javac GenericTest.java  
  19. GenericTest.java:8: 无法将 java.util.Collection<java.lang.String> 中的 add(java.lang.String) 应用于 (java.lang.Integer)  
  20.                 c.add(new Integer(1));  
  21.                  ^  
  22. 1 错误  
  23.  
  24. D:\test> 

例1-2代码

   1. import java.util.ArrayList; 
   2. import java.util.Collection; 
   3. import java.util.Iterator; 
   4.  
   5. public class GenericTest { 
   6.     public static void main(String[] args) { 
   7.         Collection<String> c = new ArrayList<String>(); 
   8.         c.add(new Integer(1)); 
   9.         c.add("123"); 
  10.         for(Iterator<String> i=c.iterator();i.hasNext();){ 
  11.             String s = i.next(); 
  12.             System.out.println(s); 
  13.         } 
  14.     } 
  15. } 
  16.  
  17. 运行结果 
  18. D:\test>javac GenericTest.java 
  19. GenericTest.java:8: 无法将 java.util.Collection<java.lang.String> 中的 add(java.lang.String) 应用于 (java.lang.Integer) 
  20.                 c.add(new Integer(1)); 
  21.                  ^ 
  22. 1 错误 
  23.  
  24. D:\test> 

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class GenericTest {
public static void main(String[] args) {
Collection<String> c = new ArrayList<String>();
c.add(new Integer(1));
c.add("123");
for(Iterator<String> i=c.iterator();i.hasNext();){
String s = i.next();
System.out.println(s);
}
}
}

运行结果
D:\test>javac GenericTest.java
GenericTest.java:8: 无法将 java.util.Collection<java.lang.String> 中的 add(java.lang.String) 应用于 (java.lang.Integer)
                c.add(new Integer(1));
                 ^
1 错误

D:\test>



使用了泛型之后在编译时就发现了错误,可以增强程序的健壮性,而其i.next();也不用使用强制类型转换了。



2、增强for循环(For-Each)

For-Each的内部是用Iterator实现的,但是使用起来更简单,例如使用For-Each实现1-2如下
例2-1 代码 复制代码

   1. import java.util.ArrayList;  
   2. import java.util.Collection;  
   3.  
   4. public class GenericTest {  
   5.     public static void main(String[] args) {  
   6.         Collection<String> c = new ArrayList<String>();  
   7.         c.add("aa");  
   8.         c.add("bb");  
   9.         for(String s:c){  
  10.             System.out.println(s);  
  11.         }  
  12.     }  
  13. }  
  14. 运行结果:  
  15. aa  
  16. bb 

例2-1 代码

   1. import java.util.ArrayList; 
   2. import java.util.Collection; 
   3.  
   4. public class GenericTest { 
   5.     public static void main(String[] args) { 
   6.         Collection<String> c = new ArrayList<String>(); 
   7.         c.add("aa"); 
   8.         c.add("bb"); 
   9.         for(String s:c){ 
  10.             System.out.println(s); 
  11.         } 
  12.     } 
  13. } 
  14. 运行结果: 
  15. aa 
  16. bb 

import java.util.ArrayList;
import java.util.Collection;

public class GenericTest {
public static void main(String[] args) {
Collection<String> c = new ArrayList<String>();
c.add("aa");
c.add("bb");
for(String s:c){
System.out.println(s);
}
}
}
运行结果:
aa
bb




比Integer方便多了吧?可以使程序员更加注重逻辑,而不是代码本身。



3、自动装箱拆箱(Autoboxing/unboxing)


例3-1代码 复制代码

   1. Integer i = new Integer(2);  
   2. //i自动拆箱为int类型  
   3. System.out.println(i==2);  
   4. //3自动装箱为Integer类型  
   5. System.out.println(i.equals(3)); 

例3-1代码

   1. Integer i = new Integer(2); 
   2. //i自动拆箱为int类型 
   3. System.out.println(i==2); 
   4. //3自动装箱为Integer类型 
   5. System.out.println(i.equals(3)); 

Integer i = new Integer(2);
//i自动拆箱为int类型
System.out.println(i==2);
//3自动装箱为Integer类型
System.out.println(i.equals(3));



4、静态导入(static import)


例4-1代码 复制代码

   1. //静态导入Math的random方法  
   2. import static java.lang.Math.random;  
   3.  
   4. public class StaticImportTest {  
   5.     public static void main(String[] args){  
   6.         //类中生成随机数数可以直接使用静态引入的random方法了,而不用Math.random()这样调用了  
   7.         System.out.println(random());  
   8.     }  
   9. } 

例4-1代码

   1. //静态导入Math的random方法 
   2. import static java.lang.Math.random; 
   3.  
   4. public class StaticImportTest { 
   5.     public static void main(String[] args){ 
   6.         //类中生成随机数数可以直接使用静态引入的random方法了,而不用Math.random()这样调用了 
   7.         System.out.println(random()); 
   8.     } 
   9. } 

//静态导入Math的random方法
import static java.lang.Math.random;

public class StaticImportTest {
public static void main(String[] args){
//类中生成随机数数可以直接使用静态引入的random方法了,而不用Math.random()这样调用了
System.out.println(random());
}
}



5、格式化打印(formatted print)

C语言中printf()风格的格式化输出。

这里只举一个thinking in java的一个例子:
例5-1代码 复制代码

   1. public class SimpleFormat {  
   2.     public static void main(String[] args) {  
   3.         int x = 5;  
   4.         double y = 5.332542;  
   5.         //The old way  
   6.         System.out.println("Row 1: ["+x+" "+y+"]");  
   7.         //The new way  
   8.         System.out.format("Row 1: [%d %f]\n", x,y);  
   9.         //or  
  10.         System.out.printf("Row 1: [%d %f]\n", x, y);  
  11.     }  
  12. }  
  13.  
  14. 运行结果:  
  15. Row 1: [5 5.332542]  
  16. Row 1: [5 5.332542]  
  17. Row 1: [5 5.332542] 

例5-1代码

   1. public class SimpleFormat { 
   2.     public static void main(String[] args) { 
   3.         int x = 5; 
   4.         double y = 5.332542; 
   5.         //The old way 
   6.         System.out.println("Row 1: ["+x+" "+y+"]"); 
   7.         //The new way 
   8.         System.out.format("Row 1: [%d %f]\n", x,y); 
   9.         //or 
  10.         System.out.printf("Row 1: [%d %f]\n", x, y); 
  11.     } 
  12. } 
  13.  
  14. 运行结果: 
  15. Row 1: [5 5.332542] 
  16. Row 1: [5 5.332542] 
  17. Row 1: [5 5.332542] 

public class SimpleFormat {
public static void main(String[] args) {
int x = 5;
double y = 5.332542;
//The old way
System.out.println("Row 1: ["+x+" "+y+"]");
//The new way
System.out.format("Row 1: [%d %f]\n", x,y);
//or
System.out.printf("Row 1: [%d %f]\n", x, y);
}
}

运行结果:
Row 1: [5 5.332542]
Row 1: [5 5.332542]
Row 1: [5 5.332542]



可以看到,format和printf是等价的,他们只需要一个简单的格式化字符串,加上一串参数即可,每个参数对应一个格式修饰符



6、枚举(Enum)

当每一类型可取值范围是有限的时候,可以使用枚举,例如每个学生登记只能用ABCD表示,如果直接用E的话,那么编译不会出错,但是却不符合输入要求,而使用枚举增加程序的易读性和健壮性?
Java代码 复制代码

   1. public class GradeTest {  
   2.     public static void main(String[] args) {  
   3.         Student stu = new Student();  
   4.         stu.setName("wasw100");  
   5.         stu.setGrade(Grade.A);  
   6.         //输出学生信息  
   7.         System.out.println(stu);  
   8.     }  
   9. }  
  10.  
  11. /** 
  12.  * 枚举:Grader 学生考试等级 
  13.  * @author wasw100 
  14.  */ 
  15. enum Grade{  
  16.     A,B,C,D  
  17. }  
  18.  
  19. class Student {  
  20.     private String name;  
  21.     private Grade grade;  
  22.       
  23.     //重写toString()方法  
  24.     public String toString(){  
  25.         return "name:+"+name+"\ngrader:"+grade;  
  26.     }  
  27.  
  28.     public String getName() {  
  29.         return name;  
  30.     }  
  31.  
  32.     public void setName(String name) {  
  33.         this.name = name;  
  34.     }  
  35.  
  36.     public Grade getGrade() {  
  37.         return grade;  
  38.     }  
  39.  
  40.     public void setGrade(Grade grade) {  
  41.         this.grade = grade;  
  42.     }  
  43.  
  44. } 

Java代码

   1. public class GradeTest { 
   2.     public static void main(String[] args) { 
   3.         Student stu = new Student(); 
   4.         stu.setName("wasw100"); 
   5.         stu.setGrade(Grade.A); 
   6.         //输出学生信息 
   7.         System.out.println(stu); 
   8.     } 
   9. } 
  10.  
  11. /**
  12.  * 枚举:Grader 学生考试等级
  13.  * @author wasw100
  14.  */ 
  15. enum Grade{ 
  16.     A,B,C,D 
  17. } 
  18.  
  19. class Student { 
  20.     private String name; 
  21.     private Grade grade; 
  22.      
  23.     //重写toString()方法 
  24.     public String toString(){ 
  25.         return "name:+"+name+"\ngrader:"+grade; 
  26.     } 
  27.  
  28.     public String getName() { 
  29.         return name; 
  30.     } 
  31.  
  32.     public void setName(String name) { 
  33.         this.name = name; 
  34.     } 
  35.  
  36.     public Grade getGrade() { 
  37.         return grade; 
  38.     } 
  39.  
  40.     public void setGrade(Grade grade) { 
  41.         this.grade = grade; 
  42.     } 
  43.  
  44. } 

public class GradeTest {
public static void main(String[] args) {
Student stu = new Student();
stu.setName("wasw100");
stu.setGrade(Grade.A);
//输出学生信息
System.out.println(stu);
}
}

/**
* 枚举:Grader 学生考试等级
* @author wasw100
*/
enum Grade{
A,B,C,D
}

class Student {
private String name;
private Grade grade;

//重写toString()方法
public String toString(){
return "name:+"+name+"\ngrader:"+grade;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public Grade getGrade() {
return grade;
}

public void setGrade(Grade grade) {
this.grade = grade;
}

}



7、可变长参数(varargs)

方法的参数是不固定的我们一般会使用重载或者使用数组参数。重载需要些更多写更多的方法,数组需要在使用时先声明。

可能参数是一个不错的解决方案。

下面是网上一个 唐僧 给 悟空 将佛经的例子
Java代码 复制代码

   1. public class VarargsTest {  
   2.     public void speak(String name, Object... arguments) {  
   3.         System.out.print(name+": ");  
   4.         for (Object object : arguments) {  
   5.             System.out.print(object);  
   6.         }  
   7.         System.out.println();  
   8.     }  
   9.  
  10.     public static void main(String[] args) {  
  11.         VarargsTest vt = new VarargsTest();  
  12.         vt.speak("悟空", "人和妖精都是妈生的,");  
  13.         vt.speak("悟空", "不同的人是人他妈生的,", "妖是妖他妈生的,");  
  14.     }  
  15. }  
  16.  
  17. 运行结果:  
  18. 悟空: 人和妖精都是妈生的,  
  19. 悟空: 不同的人是人他妈生的,妖是妖他妈生的, 

Java代码

   1. public class VarargsTest { 
   2.     public void speak(String name, Object... arguments) { 
   3.         System.out.print(name+": "); 
   4.         for (Object object : arguments) { 
   5.             System.out.print(object); 
   6.         } 
   7.         System.out.println(); 
   8.     } 
   9.  
  10.     public static void main(String[] args) { 
  11.         VarargsTest vt = new VarargsTest(); 
  12.         vt.speak("悟空", "人和妖精都是妈生的,"); 
  13.         vt.speak("悟空", "不同的人是人他妈生的,", "妖是妖他妈生的,"); 
  14.     } 
  15. } 
  16.  
  17. 运行结果: 
  18. 悟空: 人和妖精都是妈生的, 
  19. 悟空: 不同的人是人他妈生的,妖是妖他妈生的, 

public class VarargsTest {
public void speak(String name, Object... arguments) {
System.out.print(name+": ");
for (Object object : arguments) {
System.out.print(object);
}
System.out.println();
}

public static void main(String[] args) {
VarargsTest vt = new VarargsTest();
vt.speak("悟空", "人和妖精都是妈生的,");
vt.speak("悟空", "不同的人是人他妈生的,", "妖是妖他妈生的,");
}
}

运行结果:
悟空: 人和妖精都是妈生的,
悟空: 不同的人是人他妈生的,妖是妖他妈生的,

可变长参数只能作为最后一个参数。



JDK1.6的九大新特性


一:Desktop类和SystemTray类

在JDK1.6中,AWT新增加了两个类:Desktop和SystemTray。

前者可以用来打开系统默认浏览器浏览指定的URL,打开系统默认邮件客户端给指定的邮箱发邮件,用默认应用程序打开或编辑文件(比如,用记事本打开以txt为后缀名的文件),用系统默认的打印机打印文档;后者可以用来在系统托盘区创建一个托盘程序。

二:使用JAXB2来实现对象与XML之间的映射

JAXB是Java Architecture for XML Binding的缩写,可以将一个Java对象转变成为XML格式,反之亦然。

我们把对象与关系数据库之间的映射称为ORM,其实也可以把对象与XML之间的映射称为OXM(Object XML Mapping)。原来JAXB是Java EE的一部分,在JDK1.6中,SUN将其放到了Java SE中,这也是SUN的一贯做法。JDK1.6中自带的这个JAXB版本是2.0,比起1.0(JSR 31)来,JAXB2(JSR 222)用JDK5的新特性Annotation来标识要作绑定的类和属性等,这就极大简化了开发的工作量。

实际上,在Java EE 5.0中,EJB和Web Services也通过Annotation来简化开发工作。另外,JAXB2在底层是用StAX(JSR 173)来处理XML文档。除了JAXB之外,我们还可以通过XMLBeans和Castor等来实现同样的功能。

三:理解StAX

StAX(JSR 173)是JDK1.6.0中除了DOM和SAX之外的又一种处理XML文档的API。

StAX 的来历:在JAXP1.3(JSR 206)有两种处理XML文档的方法:DOM(Document Object Model)和SAX(Simple API for XML)。

由于JDK1.6.0中的JAXB2(JSR 222)和JAX-WS 2.0(JSR 224)都会用到StAX所以Sun决定把StAX加入到JAXP家族当中来,并将JAXP的版本升级到1.4(JAXP1.4是JAXP1.3的维护版本)。JDK1.6里面JAXP的版本就是1.4。

StAX是The Streaming API for XML的缩写,一种利用拉模式解析(pull-parsing)XML文档的API.StAX通过提供一种基于事件迭代器(Iterator)的API让程序员去控制xml文档解析过程,程序遍历这个事件迭代器去处理每一个解析事件,解析事件可以看做是程序拉出来的,也就是程序促使解析器产生一个解析事件然后处理该事件,之后又促使解析器产生下一个解析事件,如此循环直到碰到文档结束符;

SAX也是基于事件处理xml文档,但却是用推模式解析,解析器解析完整个xml文档后,才产生解析事件,然后推给程序去处理这些事件;DOM采用的方式是将整个xml文档映射到一颗内存树,这样就可以很容易地得到父节点和子结点以及兄弟节点的数据,但如果文档很大,将会严重影响性能。

四:使用Compiler API

现在我 们可以用JDK1.6 的Compiler API(JSR 199)去动态编译Java源文件,Compiler API结合反射功能就可以实现动态的产生Java代码并编译执行这些代码,有点动态语言的特征。

这个特性对于某些需要用到动态编译的应用程序相当有用,比如JSP Web Server,当我们手动修改JSP后,是不希望需要重启Web Server才可以看到效果的,这时候我们就可以用Compiler API来实现动态编译JSP文件,当然,现在的JSP Web Server也是支持JSP热部署的,现在的JSP Web Server通过在运行期间通过Runtime.exec或ProcessBuilder来调用javac来编译代码,这种方式需要我们产生另一个进程去做编译工作,不够优雅而且容易使代码依赖与特定的操作系统;Compiler API通过一套易用的标准的API提供了更加丰富的方式去做动态编译,而且是跨平台的。

五:轻量级Http Server API

JDK1.6 提供了一个简单的Http Server API,据此我们可以构建自己的嵌入式Http Server,它支持Http和Https协议,提供了HTTP1.1的部分实现,没有被实现的那部分可以通过扩展已有的Http Server API来实现,程序员必须自己实现HttpHandler接口,HttpServer会调用HttpHandler实现类的回调方法来处理客户端请求,在这里,我们把一个Http请求和它的响应称为一个交换,包装成HttpExchange类,HttpServer负责将HttpExchange传给HttpHandler实现类的回调方法。
六:插入式注解处理API(Pluggable Annotation Processing API)

插入式注解处理API(JSR 269)提供一套标准API来处理Annotations(JSR 175)

实际上JSR 269不仅仅用来处理Annotation,我觉得更强大的功能是它建立了Java 语言本身的一个模型,它把method,package,constructor,type,variable, enum,annotation等Java语言元素映射为Types和Elements(两者有什么区别?),从而将Java语言的语义映射成为对象,我们可以在javax.lang.model包下面可以看到这些类。 所以我们可以利用JSR 269提供的API来构建一个功能丰富的元编程(metaprogramming)环境。

JSR 269用Annotation Processor在编译期间而不是运行期间处理Annotation,Annotation Processor相当于编译器的一个插件,所以称为插入式注解处理.如果Annotation Processor处理Annotation时(执行process方法)产生了新的Java代码,编译器会再调用一次Annotation Processor,如果第二次处理还有新代码产生,就会接着调用Annotation Processor,直到没有新代码产生为止.每执行一次process()方法被称为一个"round",这样整个Annotation processing过程可以看作是一个round的序列。

JSR 269主要被设计成为针对Tools或者容器的API. 举个例子,我们想建立一套基于Annotation的单元测试框架(如TestNG),在测试类里面用Annotation来标识测试期间需要执行的测试方法。

七:用Console开发控制台程序

JDK1.6中提供了java.io.Console 类专用来访问基于字符的控制台设备。你的程序如果要与Windows下的cmd或者Linux下的Terminal交互,就可以用Console类代劳。但我们不总是能得到可用的Console,一个JVM是否有可用的Console依赖于底层平台和JVM如何被调用。如果JVM是在交互式命令行(比如Windows的cmd)中启动的,并且输入输出没有重定向到另外的地方,那么就可以得到一个可用的Console实例。

八:对脚本语言的支持

如: ruby,groovy,javascript。

九:Common Annotations

Common annotations原本是Java EE 5.0(JSR 244)规范的一部分,现在SUN把它的一部分放到了Java SE 6.0中。

随着Annotation元数据功能(JSR 175)加入到Java SE 5.0里面,很多Java 技术(比如EJB,Web Services)都会用Annotation部分代替XML文件来配置运行参数(或者说是支持声明式编程,如EJB的声明式事务),如果这些技术为通用目的都单独定义了自己的Annotations,显然有点重复建设,所以,为其他相关的Java技术定义一套公共的Annotation是有价值的,可以避免重复建设的同时,也保证Java SE和Java EE 各种技术的一致性。

下面列举出Common Annotations 1.0里面的10个Annotations Common Annotations Annotation Retention Target Description Generated Source ANNOTATION_TYPE,CONSTRUCTOR,FIELD,LOCAL_VARIABLE,METHOD,PACKAGE,PARAMETER,TYPE 用于标注生成的源代码Resource Runtime TYPE,METHOD,FIELD用于标注所依赖的资源,容器据此注入外部资源依赖,有基于字段的注入和基于setter方法的注入两种方式 Resources Runtime TYPE同时标注多个外部依赖,容器会把所有这些外部依赖注入PostConstruct Runtime METHOD标注当容器注入所有依赖之后运行的方法,用来进行依赖注入后的初始化工作,只有一个方法可以标注为PostConstruct PreDestroy Runtime METHOD当对象实例将要被从容器当中删掉之前,要执行的回调方法要标注为PreDestroy RunAs Runtime TYPE用于标注用什么安全角色来执行被标注类的方法,这个安全角色必须和Container的Security角色一致的。RolesAllowed Runtime TYPE,METHOD用于标注允许执行被标注类或方法的安全角色,这个安全角色必须和Container的Security角色一致的 PermitAll Runtime TYPE,METHOD允许所有角色执行被标注的类或方法DenyAll Runtime TYPE,METHOD不允许任何角色执行被标注的类或方法,表明该类或方法不能在Java EE容器里面运行DeclareRoles Runtime TYPE用来定义可以被应用程序检验的安全角色,通常用isUserInRole来检验安全角色。

注意:
1.RolesAllowed,PermitAll,DenyAll不能同时应用到一个类或方法上

2.标注在方法上的RolesAllowed,PermitAll,DenyAll会覆盖标注在类上的RolesAllowed,PermitAll,DenyAll

3.RunAs,RolesAllowed,PermitAll,DenyAll和DeclareRoles还没有加到Java SE 6.0上来

4. 处理以上Annotations的工作是由Java EE容器来做,Java SE 6.0只是包含了上面表格的前五种Annotations的定义类,并没有包含处理这些Annotations的引擎,这个工作可以由Pluggable Annotation Processing API(JSR 269)来做
分享到:
评论

相关推荐

    jdk1.5 jdk1.6 反编译 工具

    标题中的“jdk1.5 jdk1.6 反编译 工具”指的是用于对Java字节码进行反编译的软件,这类工具能够将Java的.class文件转换回可读的.java源代码形式,这对于理解和学习已有的Java类库或者进行逆向工程非常有帮助。...

    最新最全最好用的JDK1.5/5.0/1.6中文版(全译)下载地址

    根据提供的标题、描述、标签及部分内容,我们可以了解到这篇文章主要提供了JDK 1.5/5.0/1.6三个版本的中文文档下载链接。这些文档以CHM格式提供,分别对应不同版本的JDK,并且是经过完整翻译的中文版。下面我们将...

    JDK1.5JDK1.6各自的新特性

    JDK1.5JDK1.6各自的新特性

    Gson1.5/1.6/2.2三个版本

    我们来详细探讨一下Gson的1.5、1.6和2.2这三个版本中的关键特性和变化。 1. Gson 1.5: - 发布于2010年,这是Gson的一个早期版本。 - 支持基本的JSON类型(如字符串、数字、布尔值、数组和对象)以及自定义Java...

    jdk1.5/1.6合集

    Java开发工具合集,主要包含了JDK 1.5和JDK 1.6两个版本,这是Java编程语言历史上非常重要的两个里程碑。JDK(Java Development Kit)是Oracle公司提供的用于开发和运行Java应用程序的核心工具集,对于Java开发者来...

    jdk1.5/1.6/1.7新特性

    ### JDK 1.5、1.6 和 1.7 的新特性详解 #### JDK 1.5 新特性概述 1. **自动装箱与拆箱:** - 自动装箱指的是将基本数据类型自动转换为对应的包装类对象的过程。 - 例如:`Integer iObj = 3;` 这里将整型 `3` ...

    JDK1.5和1.6新增特性[借鉴].pdf

    在JDK 1.5和1.6这两个版本中,Java语言引入了一系列重大特性,极大地提高了开发效率和代码质量。这些特性使得Java更加现代化,更适应面向对象编程的需求。以下是这些特性的详细介绍: 1. 泛型(Generic):泛型是...

    jdk1.5、1.6压缩包

    JDK 1.5(2004年发布)是Java发展的一个重要里程碑,引入了许多新特性,极大地提升了开发效率和代码质量。以下是一些关键的更新: 1. **泛型**:泛型允许在类、接口和方法中使用类型参数,增强了类型安全,减少了...

    包含 jdk1.5免安装、jdk1.6免安装、jdk1.8(32和64)

    JDK 1.5在2004年发布,引入了许多重要的新特性,如: 1. **Generics(泛型)**:泛型允许在定义类、接口和方法时指定类型参数,提高了代码的类型安全性和重用性。 2. **Autoboxing/Unboxing(自动装箱/拆箱)**:...

    jdk 1.5:1.6:1.7.zip

    JDK 1.5在2004年发布,引入了许多重要的新特性和改进,其中最显著的是: 1. **泛型**:泛型增加了类型安全,允许在编译时检查类型,避免了运行时的ClassCastException。 2. **枚举类型**:这是一种新的数据类型,...

    JDK1.5、1.6、1.7新特性.doc

    Java的发展历程中,JDK1.5、1.6和1.7版本引入了许多重要的新特性,极大地提升了开发效率和代码质量。以下是对这些版本新特性的详细解析: 1. 自动装箱与拆箱: 在JDK1.5中,Java引入了自动装箱和拆箱功能,使得...

    JDK1.5-1.6-1.7之新特性总结

    在Java Development Kit (JDK)从1.5到1.7的发展历程中,引入了许多显著的新特性,这些特性极大地丰富了Java语言的功能性、可读性和编程效率。下面,我们将详细探讨这些版本中的主要新增功能。 ### JDK 1.5(代号:...

    java JDK1.5,1.6版本,和安装

    JDK1.5,也被称为Java SE 5.0,引入了许多重要的新特性,包括: 1. **泛型**:泛型允许在定义类、接口和方法时指定类型参数,提高了代码的类型安全性,减少了类型转换的需要。 2. **枚举类型**:作为预定义常量的...

    JDK1.5-1.6-1.7新特性

    在Java的JDK 1.5到1.7版本中,引入了一系列的新特性,极大地提升了开发效率和代码的可读性。以下是对这些新特性的详细介绍: 1. **自动装箱与拆箱**: 自动装箱允许基本类型与对应的包装类之间进行无缝转换。在JDK...

    JDK1.5-1.6-1.7之新特性总结-1

    在Java的发展历程中,JDK 1.5到1.7版本引入了许多重要的新特性,极大地提升了开发效率和代码质量。下面将详细讲解这些版本中的关键特性。 **1. 自动装箱与拆箱** 自动装箱是JDK 1.5引入的一个重要特性,它使得基本...

    JDK1.4,1.5,1.6的区别

    #### JDK1.5 新特性 JDK1.5,也称为Java 5,是Java发展史上的一个重要里程碑,引入了许多新特性,极大地提高了开发效率和代码质量。这些新特性包括: 1. **泛型** - 泛型是一种在编译时检查类型安全,并且所有的...

    API文档jdk1.5及1.6 中英文文档

    本资源包含针对Java开发者的JDK 1.5和1.6版本的API文档,以及JavaScript 5的文档,同时还有关于HTML的基础信息。以下是对这些文档的详细解析: **JDK 1.5 API中文版**: 这个`.chm`文件是Java Development Kit 1.5...

    jxl.jar与jdk1.5和jxl.jar与jdk1.6匹配

    总结来说,jxl.jar在JDK1.5和JDK1.6环境下都可以使用,但每个新版本的JDK都可能带来性能差异和潜在的兼容性问题。因此,进行详尽的测试和评估是确保项目稳定运行的关键。同时,开发者也需要关注和考虑更新的库和技术...

    jdk1.5 1.6 1.7的新特征总结

    【JDK1.5新特性】 1. 泛型(Generic) JDK1.5引入了泛型,这是对类型安全的重要改进。泛型允许在集合类中指定元素的类型,确保了在编译时就能进行类型检查,避免了运行时的强制类型转换和可能的ClassCastException...

    中文版JDK 1.6 ,1.8 api文档合集

    本合集包括了JDK 1.6和JDK 1.8的中文API文档,对于学习和理解Java语言,尤其是对Java API的使用有着极大的帮助。 JDK 1.6,也被称为Java SE 6,是Java平台的一个重要版本。在这个版本中,Java引入了许多新特性与...

Global site tag (gtag.js) - Google Analytics