大家好，我是讯享网，很高兴认识大家。

java5.0的新特性

自动装箱和自动拆箱

自动封箱和自动拆箱，它实现了简单类型和封装类型的相互转化时，实现了自动转化。

自动封箱解箱只在必要的时候才进行。还有其它选择就用其它的

byte b -128~127

Byte b 多一个null

简单类型和封装类型之间的差别

封装类可以等于null ，避免数字得0时的二义性。

Integer i=null；

int ii=i； 会抛出NullException 异常。

相当于 int ii=i.intValue();

Integer i=1；相当于Integer i=new Integer(1);

在基本数据类型和封装类之间的自动转换

5.0之前

Integer i=new Integer（4）；

int ii= i.intValue();

5.0之后

Integer i=4；

Long l=4.3;

静态引入

静态成员的使用，使用import static 引入静态成员，也就是可以用静态引入是导入包中的某个类的静态成员，在使用时不用再写类名。

很简单的东西，看一个例子：

没有静态导入

Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2));

有了静态导入

import static java.lang.Math.*;

sqrt(pow(x, 2) + pow(y, 2));

其中import static java.lang.Math.*;就是静态导入的语法，它的意思是导入Math类中的所有static方法和属性。这样我们在使用这些方法和属性时就不必写类名。

需要注意的是默认包无法用静态导入，另外如果导入的类中有重复的方法和属性则需要写出类名，否则编译时无法通过。

增强的for循环

for-each循环实现了对数组和集合的便利的统一，解决遍历数组和遍历集合的不统一。

import java.util.*;

import java.util.Collection;

public class Foreach

{

private Collection<String> c = null;

private String[java核心基础笔记] belle = new String[4];

public Foreach()

{

belle[0] = "西施";

belle[1] = "王昭君";

belle[2] = "貂禅";

belle[3] = "杨贵妃";

c = Arrays.asList(belle);

}

public void testCollection(){

for (String b : c){

System.out.println("曾经的风化绝代:" + b);

}

}

public void testArray(){

for (String b : belle){

System.out.println("曾经的青史留名:" + b);

}

}

public static void main(String[] args){

Foreach each = new Foreach();

each.testCollection();

each.testArray();

}

}

对于集合类型和数组类型的，我们都可以通过foreach语法来访问它。上面的例子中，以前我们要依次访问数组，挺麻烦：

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

String b = belle[i];

System.out.println("曾经的风化绝代:" + b);

}

现在只需下面简单的语句即可：

for (String b : belle){

System.out.println("曾经的青史留名:" + b);

}

对集合的访问效果更明显。以前我们访问集合的代码：

for (Iterator it = c.iterator(); it.hasNext();){

String name = (String) it.next();

System.out.println("曾经的风化绝代:" + name);

}

现在我们只需下面的语句：

for (String b : c){

System.out.println("曾经的风化绝代:" + b);

}

Foreach也不是万能的，它也有以下的缺点：

在以前的代码中,我们可以通过Iterator执行remove操作。

for (Iterator it = c.iterator(); it.hasNext();){

it.remove();

}

但是，在现在的for-each版中，我们无法删除集合包含的对象。你也不能替换对象。

同时，你也不能并行的for-each多个集合。所以，在我们编写代码时，还得看情况而使用它。

可变长的参数

使用条件：只在必要的时候进行。同时有参数为数组，就不能使用变长参数，有变长参数，就不能使用数组，不能共存。一个方法最多只能有一个变长参数，而且是最后一个参数。

5.0之前

public static void main(String[] args){

}

JVM收到数据封装在数组里，然后传入方法

5.0之后

public static void m(String... s){

System.out.println("m(String)" +s);

}

调用m(String… s)

for(String s2:s){

System.out.println(s2);

}

格式化输出

格式化I/O(Formatted I/O)

java.util.Sacner类可以进行格式化的输入，可以使用控制台输入，结合了BufferedReader和StringTokener的功能。

增加了类似C的格式化输入输出，简单的例子：

public class TestFormat{

public static void main(String[] args){

int a = , b = 10;

float c = 5.0101f, d = 3.14f;

System.out.printf("%4d %4d%n", a, b);

System.out.printf("%x %x%n", a, b);

System.out.printf("%3.2f %1.1f%n", c, d);

System.out.printf("%1.3e %1.3e%n", c, d*100);

}

}

输出结果为：

10

249f0 a

5.01 3.1

5.010e+00 3.140e+02

类型安全的枚举

枚举也是一个类型，枚举中的对象只能定义一次并在定义时给其初始化，定义之后不能再改变其值，只能从枚举中选择其一。

enum 枚举名{

枚举值1(..)，枚举值2(..)，.....;

}

在5.0之前使用模式做出枚举

final class Season{

public static final Season SPRING=new Season();

public static final Season WINTER=new Season();

public static final Season SUMMER=new Season();

public static final Season AUTUMN=new Season();

private Season(){}

}

完全等价于

enum Season2{

SPRING(..),//枚举值

SUMMER(..),

AUTUMN(..),

WINTER(..);

......

}

枚举是一个反射关联的典型，反射关联，即在类的定义中有自身类型的属性。

枚举本质上也是一个类，Enum是枚举的父类。

枚举中的values()方法会返回枚举中的所有枚举值

枚举中可以定义方法和属性，最后的一个枚举值要以分号和类定义分开，枚举中可以定义的构造方法。

枚举可以实现接口，枚举不能有子类也就是final的，枚举的构造方法是private（私有的），枚举中可以定义抽象方法，可以在枚举值的值中实现抽象方法，枚举值就是枚举的对象，枚举默认是final，枚举值可以隐含的匿名内部类来实现枚举中定义抽象方法。

枚举类(Enumeration Classes)和类一样，具有类所有特性。Season2的父类是java.lang.Enum;

隐含方法： Season2[] ss=Season2.values(); 每个枚举类型都有的方法。enum可以switch中使用（不加类名）。

switch( s ){

case SPRING:

…………….

case SUMMER:

…………….

…………..

}

枚举的有参构造

enum Season2{

SPRING(“春”),-------------------------------逗号

SUMMER(“夏”),-------------------------------逗号

AUTUMN(“秋”),-------------------------------逗号

WINTER(“冬”);-------------------------------分号

private String name;

Season2(String name){

this.name=name;

}

String getName(){

return name;

}

}

Season2.SPRING.getName() ---------------------春

枚举的高级用法：

enum Operation{

ADD{

public double calculate(double s1,double s2){

return s1+s2;

}

},

SUBSTRACT{

public double calculate(double s1,double s2){

return s1-s2;

}

},

MULTIPLY{

public double calculate(double s1,double s2){

return s1*s2;

}

}，

DIVIDE{

public double calculate(double s1,double s2){

return s1/s2;

}

}；

public abstract double calculate(double s1 ,double s2);

}

有抽象方法枚举元素必须实现该方法。

java5.0中的泛型

说明

增强了java的类型安全，可以在编译期间对容器内的对象进行类型检查，在运行期不必进行类型的转换。而在java se5.0之前必须在运行期动态进行容器内对象的检查及转换，泛型是编译时概念，运行时没有泛型

减少含糊的容器，可以定义什么类型的数据放入容器

List<Integer> aList = new ArrayList<Integer>();

aList.add(new Integer(1));

// ...

Integer myInteger = aList.get(0);

支持泛型的集合，只能存放制定的类型，或者是指定类型的子类型。

我们可以看到，在这个简单的例子中，我们在定义aList的时候指明了它是一个只接受Integer类型的ArrayList，当我们调用aList.get(0)时，我们已经不再需要先显式的将结果转换成Integer，然后再赋值给myInteger了。而这一步在早先的Java版本中是必须的。也许你在想，在使用Collection时节约一些类型转换就是Java泛型的全部吗？远不止。单就这个例子而言，泛型至少还有一个更大的好处，那就是使用了泛型的容器类变得更加健壮：早先，Collection接口的get()和Iterator接口的next()方法都只能返回Object类型的结果，我们可以把这个结果强制转换成任何Object的子类，而不会有任何编译期的错误，但这显然很可能带来严重的运行期错误，因为在代码中确定从某个Collection中取出的是什么类型的对象完全是调用者自己说了算，而调用者也许并不清楚放进Collection的对象具体是什么类的；就算知道放进去的对象“应该”是什么类，也不能保证放到Collection的对象就一定是那个类的实例。现在有了泛型，只要我们定义的时候指明该Collection接受哪种类型的对象，编译器可以帮我们避免类似的问题溜到产品中。我们在实际工作中其实已经看到了太多的ClassCastException。

用法

声明及实例化泛型类：

HashMap<String,Float> hm = new HashMap<String,Float>();

编译类型的泛型和运行时类型的泛型一定要一致。没有多态。

不能使用原始类型

GenList<int> nList = new GenList<int>(); //编译错误