`
healthandbeauty
  • 浏览: 168081 次
  • 性别: Icon_minigender_1
  • 来自: 西安
社区版块
存档分类
最新评论

jdk 1.5新特性说明

    博客分类:
  • java
阅读更多
“JDK1.5”的一个重要主题就是通过新增一些特性来简化开发,这些特性包括泛型,for-each 循环,自动装包/拆包,枚举,可变参数, 静态导入 。使用这些特性有助于我们编写更加清晰,精悍,安全的代码。

一. 首先简单介绍一下各种特性及其使用

1.泛型(Generic)
C++通过模板技术可以指定集合的元素类型,而Java在1.5之前一直没有相对应的功能。一个集合可以放任何类型的对象,相应地从集合里面拿对象的时候我们也不得不对他们进行强制得类型转换。猛虎引入了泛型,它允许指定集合里元素的类型,这样你可以得到强类型在编译时刻进行类型检查的好处。


“JDK1.5”的一个重要主题就是通过新增一些特性来简化开发,这些特性包括泛型,for-each 循环,自动装包/拆包,枚举,可变参数, 静态导入 。使用这些特性有助于我们编写更加清晰,精悍,安全的代码。

一. 首先简单介绍一下各种特性及其使用

1.泛型(Generic)
C++通过模板技术可以指定集合的元素类型,而Java在1.5之前一直没有相对应的功能。一个集合可以放任何类型的对象,相应地从集合里面拿对象的时候我们也不得不对他们进行强制得类型转换。猛虎引入了泛型,它允许指定集合里元素的类型,这样你可以得到强类型在编译时刻进行类型检查的好处。

1 Collection<String> c = new ArrayList();
2 c.add(new Date());

  编译器会给出一个错误:

add(java.lang.String) in java.util.Collection<java.lang.String> cannot be applied to (java.util.Date)

2.For-Each循环For-Each循环得加入简化了集合的遍历。假设我们要遍历一个集合对其中的元素进行一些处理。典型的代码为:

1 void processAll(Collection c){
2 for(Iterator i=c.iterator(); i.hasNext();){
3 MyClass myObject = (MyClass)i.next();
4 myObject.process();
5 }
6 }

  使用For-Each循环,我们可以把代码改写成:

1 void processAll(Collection<MyClass> c){
2 for (MyClass myObject :c)
3 myObject.process();
4 }

  这段代码要比上面清晰许多,并且避免了强制类型转换。

3.自动装包/拆包(Autoboxing/unboxing)自动装包/拆包大大方便了基本类型数据和它们包装类地使用。
自动装包:基本类型自动转为包装类.(int >> Integer)
自动拆包:包装类自动转为基本类型.(Integer >> int)
  在JDK1.5之前,我们总是对集合不能存放基本类型而耿耿于怀,现在自动转换机制解决了我们的问题。

1 int a = 3;
2 Collection c = new ArrayList();
3c.add(a);//自动转换成Integer.
4 Integer b = new Integer(2);
5c.add(b + 2);

  这里Integer先自动转换为int进行加法运算,然后int再次转换为Integer.
4.枚举(Enums)
JDK1.5加入了一个全新类型的“类”-枚举类型。为此JDK1.5引入了一个新关键字enmu. 我们可以这样来定义一个枚举类型。

1 public enum Color
2 {
3 Red,
4 White,
5 Blue
6 }

  然后可以这样来使用Color myColor = Color.Red.
  枚举类型还提供了两个有用的静态方法values()和valueOf(). 我们可以很方便地使用它们,例如

1 for (Color c : Color.values())
2 System.out.println(c);

5.可变参数(Varargs)  可变参数使程序员可以声明一个接受可变数目参数的方法。注意,可变参数必须是函数声明中的最后一个参数。假设我们要写一个简单的方法打印一些对象,

util.write(obj1);
util.write(obj1,obj2);
util.write(obj1,obj2,obj3);


  在JDK1.5之前,我们可以用重载来实现,但是这样就需要写很多的重载函数,显得不是很有效。如果使用可变参数的话我们只需要一个函数就行了

1 public void write(Object... objs) {
2 for (Object obj: objs)
3 System.out.println(obj);
4 }

  在引入可变参数以后,Java的反射包也更加方便使用了。对于c.getMethod("test", new Object[0]).invoke(c.newInstance(), new Object[0])),现在我们可以这样写了c.getMethod("test").invoke(c.newInstance()),这样的代码比原来清楚了很多。 
6.静态导入(Static Imports)
  要使用用静态成员(方法和变量)我们必须给出提供这个方法的类。使用静态导入可以使被导入类的所有静态变量和静态方法在当前类直接可见,使用这些静态成员无需再给出他们的类名。

import static java.lang.Math.*;
…….

r = sin(PI * 2); //无需再写r = Math.sin(Math.PI);

不过,过度使用这个特性也会一定程度上降低代码地可读性。

二. 重点讲一下泛型

在已发布的Java1.4中在核心代码库中增加了许多新的API(如Loging,正则表达式,NIO)等,在最新发布的JDK1.5和即将发布的JDK1.6中也新增了许多API,其中比较有重大意义的就是Generics(范型)。

1.什么是Generics?

Generics可以称之为参数类型(parameterized types),由编译器来验证从客户端将一种类型传送给某一对象的机制。如Java.util.ArrayList,编译器可以用Generics来保证类型安全。

  在我们深入了解Generics之前,我们先来看一看当前的java集合框架(Collection)。在j2SE1.4中所有集合的Root Interface是Collection

Collections example without genericity: Example 1

1 protected void collectionsExample() {
2  ArrayList list = new ArrayList();
3  list.add(new String("test string"));
4  list.add(new Integer(9)); // purposely placed here to create a runtime ClassCastException
5  inspectCollection(list);
6 }
7
8
9 protected void inspectCollection(Collection aCollection) {
10  Iterator i = aCollection.iterator();
11  while (i.hasNext()) {
12   String element = (String) i.next();
13  }
14 }

  以上的样例程序包含的两个方法,collectionExample方法建立了一个简单的集合类型ArrayList,并在ArrayList中增加了一个String和一个Integer对象.而在inspecCollection方法中,我们迭代这个ArrayList用String进行Cast。我们看第二个方法,就出现了一个问题,Collection在内部用的是Object,而我们要取出Collection中的对象时,需要进行Cast,那么开发者必需用实际的类型进行Cast,像这种向下造型,编译器无

  法进行检查,如此一来我们就要冒在代码在运行抛出ClassCastException的危险。我们看inspecCollection方法,编译时没有问题,但在运行时就会抛出ClassCastException异常。所以我们一定要远离这个重大的运行时错误

2.使用Generics

  从上一章节中的CassCastException这种异常,我们期望在代码编译时就能够捕捉到,下面我们使用范型修改上一章的样例程序。

//Example 2

1 protected void collectionsExample() {
2  ArrayList<String> list = new ArrayList<String>();
3  list.add(new String("test string"));
4  // list.add(new Integer(9)); this no longer compiles
5  inspectCollection(list);
6 }
7
8
9 protected void inspectCollection(Collection<String> aCollection) {
10  Iterator<String> i = aCollection.iterator();
11  while(i.hasNext()) {
12   String element = i.next();
13  }
14 }

  从上面第2行我们在创建ArrayList时使用了新语法,在JDK1.5中所有的Collection都加入了Generics的声明。例:

//Example 3

1 public class ArrayList<E> extends AbstractList<E> {
2  // details omitted...
3  public void add(E element) {
4   // details omitted
5  }
6  public Iterator<E> iterator() {
7   // details omitted
8  }
9 }

  这个E是一个类型变量,并没有对它进行具体类型的定义,它只是在定义ArrayList时的类型占位符,在Example 2中的我们在定义ArrayList的实例时用String绑定在E上,当我们用add(E element)方法向ArrayList中增加对象时,那么就像下面的写法一样: public void add(String element);因为在ArrayList所有方法都会用String来替代E,无论是方法的参数还是返回值。这时我们在看Example 2中的第四行,编译就会反映出编译错误。

所以在java中增加Generics主要的目的是为了增加类型安全。

  通过上面的简单的例子我们看到使用Generics的好处有:

· 1.在类型没有变化时,Collection是类型安全的。

· 2.内在的类型转换优于在外部的人工造型。

· 3.使Java接口更加强壮,因为它增加了类型。

· 4.类型的匹配错误在编译阶段就可以捕捉到,而不是在代码运行时。

  受约束类型变量

  虽然许多Class被设计成Generics,但类型变量可以是受限的

public class C1<T extends Number> { }
public class C2<T extends Person & Comparable> { }

  第一个T变量必须继承Number,第二个T必须继承Person和实现Comparable

3.Generics方法

  像Generics类一样,方法和构造函数也可以有类型参数。方法的参数的返回值都可以有类型参数,进行Generics。

//Example 4

1 public <T extends Comparable> T max(T t1, T t2) {
2  if (t1.compareTo(t2) > 0)
3   return t1;
4  else return t2;
5 }

  这里,max方法的参数类型为单一的T类型,而T类型继承了Comparable,max的参数和返回值都有相同的超类。下面的Example 5显示了max方法的几个约束。

//Example 5

1 Integer iresult = max(new Integer(100), new Integer(200));
2 String sresult = max("AA", "BB");
3 Number nresult = max(new Integer(100), "AAA"); // does not compile

  在Example 5第1行参数都为Integer,所以返回值也是Integer,注意返回值没有进行造型。

  在Example 5第2行参数都为String,所以返回值也是String,注意返回值没有进行造型。以上都调用了同一个方法。

  在Example 5第3行产生以下编译错误:

Example.java:10: incompatible types
found  : java.lang.Object&java.io.Serializable&java.lang.Comparable<?>
required: java.lang.Number
    Number nresult = max(new Integer(100), "AAA");

  这个错误发生是因为编译器无法确定返回值类型,因为String和Integer都有相同的超类Object,注意就算我们修正了第三行,这行代码在运行仍然会报错,因为比较了不同的对象。

3.通配(Wildcards)

先看以下两行代码是否合法:
List<String> ls = new ArrayList<String>(); // 1
List<Object> lo = ls; // 2
第一行没问题, 关键在第二行代码, 大多数人会认为, "一个String的List自然更是一个Object的List", 因此, 第2行没问题.

好, 接着看以下代码:
lo.add(new Object()); // 3
String s = ls.get(0); // 4: 试图将一个Object赋给一个String!
可见, 通过别名lo, 我们能对ls, 一个String的列表, 进行数据操作(特别是插入一个Object), 从而导致ls不仅仅是容纳了String对象! 这是Java编译器不容许的! 编译时, 第2行会报告一个编译错误的.

通常, 若Foo是Bar的一个子类型(子类或子接口), G是某个泛型声明, 则G<Foo>并不是G<Bar>的一个子类型.

假定要输出一个集合中的所有元素. 以下分别是旧版本及新版本(JDK 1.5)中的写法:

void printCollection(Collection c) {
  Iterator i = c.iterator();
  for( k = 0; k < c.size(); k++) {
    System.out.println( i.next() );
}}

void printCollection(Collection<Object> c) {
  for(Object e : c) {
    System.out.println(e);
}}

问题在于, 新版本反而不如旧版本更有用些. 因为旧版本能使用各种类型的集合作为参数, 但新版本则只能使用Collection<Object>. 而正如上节看到的, Collection<Object>并不是其它各种集合的超类型(父类型).

所有集合的超类型应该写作: Collection<?>, 读作: collection of unknown(未知集合), 即一个集合, 其元素类型可以与任何类型相匹配. 因此称这种类型为"通配类型".

正确实现上述旧版本的代码可以这么写:
void printCollection(Collection<?> c) {
  for(Object e : c) {
    System.out.println(e);
}}

这时, 可以用任意类型的集合来调用此方法. 注意在方法体中, 仍然从 c 中读入元素并赋给了Object, 这是没有错误的, 因此不论类型实参是何种集合, 它的元素都是object. 然而, 如果任意给它增加一个object则是不安全的:

Collection<?> c = new ArrayList<String>();
c.add(new Object()); // 编译时的错误

由于我们不知道c的元素类型是什么, 所以不能给它增加一个object. 方法add()接受一个类型E的参数, 而E与集合的元素类型相同. 当类型实参是?时, 它表示"未知的类型", 我们传递给add的参数必须是这个"未知类型"的子类型. 不幸的是, 既然类型未知, 也就无法决定其子类型, 于是什么也不能作为其参数. 唯一的例外是null, 因为null是所有类型的一个成员.

另一方面, 如果给了一个List<?>, 我们可以调用get()方法并使用其返回的元素. 虽然返回的元素类型是"未知类型", 但它总归是一个object, 因此将get()返回的元素赋给一个Object类型的变量, 或将其传递给一个可接受Object的参数都是安全的.
分享到:
评论

相关推荐

    javajdk1.5安装与配置环境变量(最新).txt

    JDK 1.5(也称为Java SE 5.0)是Sun Microsystems公司于2004年发布的版本,该版本引入了许多重要的改进和特性,如泛型、枚举类型、可变参数方法等。 #### 二、JDK 1.5 的安装步骤 1. **下载JDK 1.5**: - 访问...

    绿色版的jdk1.5

    JDK1.5,也称为Java SE 5.0,是Java发展历史上的一个重要里程碑,它引入了一系列新特性和优化,极大地提升了开发效率和程序性能: 1. **泛型(Generics)**:泛型允许在类、接口和方法中使用类型参数,提高了代码的...

    JDK1.5 中文版文档.rar

    **JDK1.5 中文版文档概述** JDK(Java Development Kit)是Java编程...通过阅读这份文档,开发者可以深入理解JDK1.5的特性和最佳实践,提升Java编程技能。同时,它也是解决问题和解决开发中遇到疑问的重要参考来源。

    jdk1.5 jdk1.6 反编译 工具

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

    JDK1.5配置+Tomcat5.0配置

    JDK 1.5是Java语言的一个重要版本,引入了诸如自动资源管理(try-with-resources)、泛型、枚举类型等新特性。以下是配置步骤: 1. **安装JDK**:首先需要下载并安装JDK 1.5,将其安装在如`C:\Program Files\jdk1.5...

    windowsJdk1.5

    1. 打开命令行窗口,输入`java -version`,如果返回JDK1.5的相关信息,说明安装成功。 2. 输入`javac -version`,如果返回JDK1.5的编译器版本信息,表明编译器已正确配置。 四、JDK1.5的使用 1. 编写Java程序:...

    JDK 1.5 API 中文文档 HTML格式

    JDK 1.5,全称为Java Development Kit版本1.5,是Java编程语言的一个重要里程碑,它在2004年发布,引入了大量的新特性,显著提升了开发效率和程序性能。API(Application Programming Interface)文档是JDK的核心...

    jdk1.5

    以下是对JDK 1.5主要特性的详细说明: 1. **泛型(Generics)**:这是JDK 1.5最重要的特性之一,允许在类、接口和方法声明中使用类型参数,增强了代码的类型安全性,减少了运行时类型异常的可能性。泛型使程序员...

    jdk1.5绿色版

    总的来说,JDK1.5绿色版为开发者提供了便捷的开发环境,通过合理的配置和使用,可以充分发挥Java 5的新特性和优势,提升开发效率。同时,了解并掌握这些新特性,对于理解后续版本的Java语言以及提升编程水平都具有...

    jdk1.5 64位

    总的来说,JDK 1.5是Java发展的一个重要阶段,它的许多新特性如泛型、枚举、注解和增强的并发工具,都为后续版本的Java开发奠定了坚实的基础。安装并熟悉这个版本的JDK,对于理解现代Java编程的许多核心概念是非常有...

    JDK1.5的安装与配置

    JDK1.5,也被称为Java SE 5.0,是Java语言的一个重要版本,它引入了许多新特性,如泛型、枚举、自动装箱/拆箱以及增强的for循环等。以下将详细介绍JDK1.5的安装与配置步骤,以及一些关键的新特性。 ### 一、JDK1.5...

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

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

    JDK1.5API_CN.rar

    JDK1.5 API则具体指Java 1.5版本提供的API集合,这个版本引入了许多重要的新特性,例如泛型(Generics)、枚举(Enums)、自动装箱与拆箱(Autoboxing and Unboxing)以及可变参数(Varargs)等。 1. **泛型**:...

    json 2.2.3 jdk 1.5 && jdk1.3 lib && src && doc文档 官方下载 天涯浪子

    JDK 1.5(也称为Java 5.0)引入了许多重要的新特性,如泛型、枚举、可变参数、注解等,而JDK 1.3是早期的版本,虽然相对较旧,但仍然有项目可能依赖这些版本。 "lib"通常指的是库文件,这里指JSON 2.2.3针对JDK 1.5...

    JDK 1.5 中文文档.rar

    《JDK 1.5 中文文档》是一个非常重要的资源,尤其对于Java开发者而言,它提供了JDK 1.5版本的详细技术指南和...通过阅读这份中文文档,开发者可以深入理解JDK 1.5的新特性和最佳实践,从而更好地利用Java进行软件开发。

    JavaJDK1.5中文简体API文档

    2. **JDK 1.5新特性** - **泛型(Generics)**:允许在类、接口和方法中使用类型参数,增强了代码的类型安全性和重用性。 - **枚举(Enums)**:提供了一种创建固定数量的常量集合的方式,防止了常量的误修改。 -...

    jdk1.5 jdk

    以下是对JDK 1.5主要特性的详细说明: 1. **泛型(Generics)**:这是JDK 1.5中的核心特性之一,它允许在类、接口和方法中使用类型参数,提高了代码的类型安全性和重用性。泛型使得集合框架能够处理特定类型的元素...

    jdk1.5的中文API文档(CHM格式)

    **JDK 1.5中文API文档概述** JDK(Java Development Kit)是Java编程语言的核心...无论你是初学者还是经验丰富的开发者,都应该充分利用这份文档,深入理解JDK 1.5的新特性和API用法,从而编写出更高质量的Java代码。

Global site tag (gtag.js) - Google Analytics