Java编程之jdk1.4,jdk1.5和jdk1.6的区别分析(经典)

Java编程之jdk1.4,jdk1.5和jdk1.6的区别分析(经典)

本文结合实例详细分析了java编程之jdk1.4,jdk1.5和jdk1.6的区别。分享给大家供大家参考，具体如下：

简单说：1.4和1.5最大的区别有两个，一个是1.5有泛型，另一个1.5可以自动封装八大基本数据类型的封装数据类型，即，Integer a = 4这个1.4是不可以的。1.5和1.6的区别不大。1.6我觉得最多的变化，我觉得最大的部分是在GUI上面，提供了很多方便的布局管理和扩展。

这段时间进了一家电子政务公司，都用weblogic8,那咱就用jdk1.4吧，eclipse一改jdk版本，这不以前的项目基本都一片红了。

★jdk1.5的新特性：

1. 泛型

2 自动装箱/拆箱

3 for-each

4 static import

5 变长参数

1. 泛型 （避免类型强制转换可能引起的运行错误）

例如:

ArrayList list=new ArrayList();

list.add(new Integer(3));

list.add(new Integer(4));

int i=((Integer)(list.get(0))).parseInt();

很麻烦

ArrayListlist=new ArrayList();

list.add(new Integer(3));

list.add(new Integer(4));

int i=list.get(0).parseInt();

2 自动装箱/拆箱

上面例子的最后一句可改为：

复制代码 代码如下:

int i=list.get(0);

因为原始类型与对应的包装类不用显式转换

3 for-each

循环的增强

int a[]={........};//初始化

for(int i:a)

{

......

}

不用以前的i=0;i

4 static import

以前调Java.math

复制代码 代码如下:

Math.sqrt();

现在 static import java.lang.Math.sqrt;

再 sqrt();

相当于你自己类里有这个方法

5 变长参数

int sum(int ...intlist)

{

int sum;

sum=0;

for(int i=0;i

{

sum+=intlist[i];

}

return sum;

}

有任意个参数,把他看作数组

★jdk6.0新特性

增强的for循环语句

注释

枚举

“隐藏的”静态方法

可变参数(Vararg)

通配符和协变返回

增强的for循环语句

为了迭代集合和数组，增强的for循环提供了一个简单、兼容的语法。有两点值得一提：

一、在循环中，初始化表达式只计算一次。int表达式

未增强的For：

int sum = 0;

Integer[] numbers = computeNumbers();

for (int i=0; i < numbers.length ; i++)

sum += numbers[i];

增强后的For：

int sum = 0;

for ( int number: computeNumbers() )

sum += number;

局限性

增强的for循环迭代期间不能访问迭代器或下标

请看下面的例子：

for (int i=0; i < numbers.length ; i++) {

if (i != 0) System.out.print(",");

System.out.print(numbers[i]);

}

这是另一个例子：

for (Iterator it = n.iterator() ; it.hasNext() ; )

if (it.next() < 0)

it.remove();

注释

注释处理是一个很大的话题。因为本文只关注核心的语言特性，所以我们不打算涵盖它所有的可能形式和陷阱。 我们将讨论内置的注释（SuppressWarnings，Deprecated和Override）以及一般注释处理的局限性。

Suppress Warnings

该注释关闭了类或方法级别的编译器警告。有时候您比编译器更清楚地知道，代码必须使用一个被否决的方法或执行一些无法静态确定是否类型安全的动作，而使用：

@SuppressWarnings("deprecation")

public static void selfDestruct() {

Thread.currentThread().stop();

}

这可能是内置注释最有用的地方。遗憾的是，1.5.0_04的javac不支持它。但是1.6支持它，并且Sun正在努力将其向后移植到1.5中。

Eclipse 3.1中支持该注释，其他IDE也可能支持它。这允许您把代码彻底地从警告中解脱出来。如果在编译时出现警告，可以确定是您刚刚把它添加进来——以帮助查看那些可能不安全的代码。随着泛型的添加，它使用起来将更趁手。

Deprecated

遗憾的是，Deprecated没那么有用。它本来旨在替换@deprecated javadoc标签，但是由于它不包含任何字段，所以也就没有方法来建议deprecated类或方法的用户应该使用什么做为替代品。大多数

用法都同时需要javadoc标签和这个注释。

Override

Override表示，它所注释的方法应该重写超类中具有相同签名的方法：

@Override

public int hashCode() {

...

}

看上面的例子，如果没有在hashCode中将“C”大写，在编译时不会出现错误，但是在运行时将无法像期望的那样调用该方法。通过添加Overridehttp://标签，编译器会提示它是否真正地执行了重写。

在超类发生改变的情况中，这也很有帮助。如果向该方法中添加一个新参数，而且方法本身也被重命名了，那么子类将突然不能编译，因为它不再重写超类的任何东西。

其它注释

注释在其他场景中非常有用。当不是直接修改行为而是增强行为时，特别是在添加样板代码的情况下，注释在诸如EJB和Web services这样的框架中运行得非常好。

注释不能用做预处理器。Sun的设计特别预防了完全因为注释而修改类的字节码。这样可以正确地理解该语言的成果，而且IDE之类的工具也可以执行深入的代码分析和重构之类的功能。

注释不是银弹。第一次遇到的时候，人们试图尝试各种技巧。请看下面这个从别人那里获得的建议：

public class Foo {

@Property

private int bar;

}

其思想是为私有字段bar自动创建getter和setter方法。遗憾的是，这个想法有两个失败之处：1)它不能运行，2)它使代码难以阅读和处理。 它是无法实现的，因为前面已经提到了，Sun特别阻止了对出现注释的类进行修改。

即使是可能的，它也不是一个好主意，因为它使代码可读性差。第一次看到这段代码的人会不知道该注释创建了方法。此外，如果将来您需要在这些方法内部执行一些操作，注释也是没用的。 总之，不要试图用注释去做那些常规代码可以完成的事情。

枚举

enum非常像public static final int声明，后者作为枚举值已经使用了很多年。对int所做的最大也是最明显的改进是类型安全——您不能错误地用枚举的一种类型代替另一种类型，这一点和int不同，所有的int对编译器来说都是一样的。除去极少数例外的情况，通常都应该用enum实例替换全部的枚举风格的int结构。

枚举提供了一些附加的特性。EnumMap和EnumSet这两个实用类是专门为枚举优化的标准集合实现。如果知道集合只包含枚举类型，那么应该使用这些专门的集合来代替HashMap或HashSet。

大部分情况下，可以使用enum对代码中的所有public static final int做插入替换。它们是可比的，并且可以静态导入，所以对它们的引用看起来是等同的，即使是对于内部类（或内部枚举类型）。注意，比较枚举类型的时候，声明它们的指令表明了它们的顺序值。

“隐藏的”静态方法

两个静态方法出现在所有枚举类型声明中。因为它们是枚举子类上的静态方法，而不是Enum本身的方法，所以它们在java.lang.Enum的javadoc中没有出现。

第一个是values()，返回一个枚举类型所有可能值的数组。

第二个是valueOf()，为提供的字符串返回一个枚举类型，该枚举类型必须精确地匹配源代码声明。

方法

关于枚举类型，我们最喜欢的一个方面是它可以有方法。过去您可能需要编写一些代码，对public static final int进行转换，把它从数据库类型转换为JDBC URL。而现在则可以让枚举类型本身带一个整

理代码的方法。下面就是一个例子，包括DatabaseType枚举类型的抽象方法以及每个枚举实例中提供的实现：

public enum DatabaseType {

ORACLE {

public String getJdbcUrl() {...}

},

mysql {

public String getJdbcUrl() {...}

};

public abstract String getJdbcUrl();

}

现在枚举类型可以直接提供它的实用方法。例如：

DatabaseType dbType = ...;

String jdbcURL = dbType.getJdbcUrl();

要获取URL，必须预先知道该实用方法在哪里。

可变参数(Vararg)

正确地使用可变参数确实可以清理一些垃圾代码。典型的例子是一个带有可变的String参数个数的log方法：

Log.log(String code)

Log.log(String code, String arg)

Log.log(String code, String arg1, String arg2)

Log.log(String code, String[] args)

当讨论可变参数时，比较有趣的是，如果用新的可变参数替换前四个例子，将是兼容的：

复制代码 代码如下:

Log.log(String code, String... args)

所有的可变参数都是源兼容的——那就是说，如果重新编译log()方法的所有调用程序，可以直接替换全部的四个方法。然而，如果需要向后的二进制兼容性，那么就需要舍去前三个方法。只有最后那个带一个字符串数组参数的方法等效于可变参数版本，因此可以被可变参数版本替换。

类型强制转换

如果希望调用程序了解应该使用哪种类型的参数，那么应该避免用可变参数进行类型强制转换。看下面这个例子，第一项希望是String，第二项希望是Exception：

Log.log(Object... objects) {

String message = (String)objects[0];

if (objects.length > 1) {

Exception e = (Exception)obtDMuecBgjects[1];

// Do something with the exception

}

}

方法签名应该如下所示，相应的可变参数分别使用String和Exception声明：

复制代码 代码如下:

Log.log(String message, Exception e, Object... objects) {...}

不要使用可变参数破坏类型系统。需要强类型化时才可以使用它。对于这个规则，PrintStream.printf()是一个有趣的例外：它提供类型信息作为自己的第一个参数，以便稍后可以接受那些类型。

协变返回

协变返回的基本用法是用于在已知一个实现的返回类型比API更具体的时候避免进行类型强制转换。在下面这个例子中，有一个返回Animal对象的Zoo接口。我们的实现返回一个AnimalImpl对象，但是在JDK 1.5之前，要返回一个Animal对象就必须声明。:

public interface Zoo {

public Animal getAnimal();

}

public class ZooImpl implements Zoo {

public Animal getAnimal(){

return new AnimalImpl();

}

}

协变返回的使用替换了三个反模式：

直接字段访问。为了规避API限制，一些实现把子类直接暴露为字段：

复制代码 代码如下:

ZooImpl._animal

另一种形式是，在知道实现的实际上是特定的子类的情况下，在调用程序中执行向下转换：

复制代码 代码如下:

((AnimalImpl)ZooImpl.getAnimal()).implMethod();

我看到的最后一种形式是一个具体的方法，该方法用来避免由一个完全不同的签名所引发的问题：

复制代码 代码如下:

ZooImpl._getAnimal();

这三种模式都有它们的问题和局限性。要么是不够整洁，要么就是暴露了不必要的实现细节。

协变

协变返回模式就比较整洁、安全并且易于维护，它也不需要类型强制转换或特定的方法或字段：

public AnimalImpl getAnimal(){

return new AnimalImpl();

}

使用结果：

复制代码 代码如下:

ZooImpl.getAnimal().implMethod();

使用泛型

我们将从两个角度来了解泛型：使用泛型和构造泛型。我们不讨论List、Set和Map的显而易见的用法。知道泛型集合是强大的并且应该经常使用就足够了。

我们将讨论泛型方法的使用以及编译器推断类型的方法。通常这些都不会出问题，但是当出问题时，错误信息会非常令人费解，所以需要了解如何修复这些问题。

泛型方法

除了泛型类型，Java 5还引入了泛型方法。在这个来自java.util.Collections的例子中，构造了一个单元素列表。新的List的元素类型是根据传入方法的对象的类型来推断的：

复制代码 代码如下:

static List Collections.singletonList(T o)

示例用法：

public List getListOfOne() {

return Collections.singletonList(1);

}

在示例用法中，我们传入了一个int。所以方法的返回类型就是List。编译器把T推断为Integer。这和泛型类型是不同的，因为您通常不需要显式地指定类型参数。

这也显示了自动装箱和泛型的相互作用。类型参数必须是引用类型：这就是为什么我们得到的是List而不是List。

不带参数的泛型方法

emptyList()方法与泛型一起引入，作为java.util.Collections中EMPTY_LIST字段的类型安全置换：

复制代码 代码如下:

static List Collections.emptyList()

示例用法：

public List getNoIntegers() {

return Collections.emptyList();

}

与先前的例子不同，这个方法没有参数，那么编译器如何推断T的类型呢？基本上，它将尝试使用一次参数。如果没有起作用，它再次尝试使用返回或赋值类型。在本例中，返回的是List，所以T被推断为Integer。

如果在返回语句或赋值语句之外的位置调用泛型方法会怎么样呢？那么编译器将无法执行类型推断的第二次传送。在下面这个例子中，emptyList()是从条件运算符内部调用的：

public List getNoIntegers() {

return x ? Collections.emptyList() : null;

}

因为编译器看不到返回上下文，也不能推断T，所以它放弃并采用Object。您将看到一个错误消息，比如：“无法将List