Java-JDK1.5新特性

Java-JDK1.5新特性



这里说到的新特性有：枚举、静态导入、增强for循环、可变参数、基本数据类型的自动装箱与自动拆箱。下面进行说明。

一、枚举

什么是枚举呢？其实枚举就是限制某变量的取值类型是固定的，比如说季节类型的变量有四个，星期类型的变量有七个，月份类型的变量有十二个等等。至于应用后面再提吧！

在JDK1.5之前，没有枚举这新特性，当我们要定义枚举时，通过定义类的形式去定义。还是先说说JDK1.5以前的吧，看看是怎么实现枚举的。代码体现，定义一个季节类，但这个类只有四个取值。

public class Season {

// 提供类的属性，生命为私有的常量
private final String seasonName;
private final String seasonDesc;

// 不给外部实例化，只在内部初始化
private Season(String seasonName, String seasonDesc) {
this.seasonDesc = seasonDesc;
this.seasonName = seasonName;
}

// 调用属性
public String getSeasonName() {
return seasonName;
}

public String getSeasonDesc() {
return seasonDesc;
}

// 复写toString方法
public String toString() {
return "season [seasonName = " + seasonName + ",seasonDesc = " + seasonDesc + "]";
}
//创建枚举类
public static final Season SPRINT = new Season("spring","this is spring");
public static final Season SUMMER = new Season("summer","this is summer");
public static final Season FALL = new Season("fall","this is austumn");
public static final Season WINTER = new Season("winter","this is winter");

}

从上可知道，这个类只对外提供这个四个对象，分别是春夏秋冬。当我们要调用时，直接用类名.季节即可。当然，如果只对提供一个对象的时候，那么这个就是单例模式了。下面看一下调用吧。

public class SeasonTest {

public static void main(String[] args) {

Season spring = Season.SPRINT;
System.out.println(spring);
Season summer = Season.SUMMER;
System.out.println(summer);
Season fall = Season.FALL;
System.out.println(fall);
Season winter = Season.WINTER;
System.out.println(winter);

}

}

结果如下：

season [seasonName = spring,seasonDesc = this is spring]

season [seasonName = summer,seasonDesc = this is summer]

season [seasonName = fall,seasonDesc = this is austumn]

season [seasonName = winter,seasonDesc = this is winter]

在JDK1.5之前，人们都这么干的，但是在JDK1.5新特性之枚举出现以后，就不需要这样做了。直接用关键字enum来定义即可，当然，内部也变得简单了。

但是，有要注意的地方：

1、必须要把对象放在最前面；

2、只需要对象名，如果对象需要传入参数直接在后面传入即可；

3、对象与对象之间对逗号分开，最后一个对象用分号。

下面我们把上面的模仿枚举的类修改成枚举的形式：

public enum SeasonType {
// 对象放在前面
SPRING("spring", "this is spring"),
SUMMER("summer", "this is summer"),
FALL("fall", "this is fall"),
WINTER("winter", "this is winter");

// 两个常量
private final String seasonName;
private final String seasonDesc;

// 私有化构造器
private SeasonType(String seasonName, String seasonDesc) {
this.seasonDesc = seasonDesc;
this.seasonName = seasonName;
}

// 复写toString方法
public String toString() {
return "season [seasonName = " + seasonName + ",seasonDesc = " + seasonDesc + "]";
}
}

测试一下吧！

public class SeasonTest {

public static void main(String[] args) {

//枚举测试
SeasonType springType = SeasonType.SPRING;
System.out.println(springType);
SeasonType summerType = SeasonType.SUMMER;
System.out.println(summerType);
SeasonType fallType = SeasonType.FALL;
System.out.println(fallType);
SeasonType winterType = SeasonType.WINTER;
System.out.println(winterType);
}

}

结果如下：

season [seasonName = spring,seasonDesc = this is spring]

season [seasonName = summer,seasonDesc = this is summer]

season [seasonName = fall,seasonDesc = this is fall]

season [seasonName = winter,seasonDesc = this is winter]

由上可见，结果是一样的，也就是实现的功能一样，但是用enum更加简单，更有快。也有标识性。假如连属性都没有的话，那只有几个对象了。比如我们在定义方向时，东南西北，东南，东北，西南，西北，八个方向，没有属性，直接是定义对象名就可以了。

接下来，我们看看枚举中常用的方法

value()：会把该枚举中的所有对象，以一个数组的形式返回

public class SeasonTest {

public static void main(String[] args) {

SeasonType[] seasonTypes = SeasonType.values();
for(SeasonType seasonType : seasonTypes){
System.out.println(seasonType);
}
}
}
/*
* 结果如下：
* season [seasonName = spring,seasonDesc = this is spring]
* season [seasonName = summer,seasonDesc = this is summer]
* season [seasonName = fall,seasonDesc = this is fall]
* season [seasonName = winter,seasonDesc = this is winter]
*/

上面遍历就用到了增强的for循环，也是新特性，后面担到。当然，也可以单个进行获取，提供对象象就OK，好，试试吧！

valueOf

public class SeasonTest {

public static void main(String[] args) {

SeasonType season  = SeasonType.valueOf("SPRING");
System.out.println(season);
}
}
/*
* 结果如下：
* season [seasonName = spring,seasonDesc = this is spring]
*/

指定的名字必须是枚举里的，否则就会编译出异常，这也是枚举的一个好处。把运行时的异常转移到这个编译时来，然后让程序员进行修改，免得以后发生这样的错误，而用户无法处理。

另外这里说一下的就是，这个枚举不能被继承，也不能继承别的类，但可以实现接口。下面就看看如何实现接口，实现不同的对象不同的实现功能。

接口：

public interface Info {
void show();//展示季节的信息。
}

实现接口：

public enum SeasonType implements Info {
// 对象放在前面
SPRING("spring", "this is spring"){
public void show(){
System.out.println("this is spring");
}
},
SUMMER("summer", "this is summer"){
public void show(){
System.out.println("this is summer");
}
},
FALL("fall", "this is fall"){
public void show(){
System.out.println("this is fall");
}
},
WINTER("winter", "this is winter"){
public void show(){
System.out.println("this is winter");
}
};

// 两个常量
private final String seasonName;
private final String seasonDesc;

// 私有化构造器
private SeasonType(String seasonName, String seasonDesc) {
this.seasonDesc = seasonDesc;
this.seasonName = seasonName;
}

// 复写toString方法
public String toString() {
return "season [seasonName = " + seasonName + ",seasonDesc = " + seasonDesc + "]";
}
}

测试：

public class SeasonTest {

public static void main(String[] args) {

SeasonType spring = SeasonType.SPRING;
spring.show();
SeasonType summer = SeasonType.SUMMER;
summer.show();
SeasonType fall = SeasonType.FALL;
fall.show();
SeasonType winter = SeasonType.WINTER;
winter.show();
}
}
/*
* 结果如下：
* this is spring
* this is summer
* this is fall
* this is winter
*/

好啦，枚举知道这些就够了，可以赚钱啦，哈哈！继续往下看吧！

静态导入

当我们在学集合框架的时候，工具类Collections里头有很多静态的类，直接让我们通过类名.方法名调用，同样，系统类也有很多静态的方法供我们调用，最常用的System.out.pritnln()；是吧！

好，这些都是静态的方法，当我们把类导入时，就可以省略类了。比如导入集合工具包import static java.util.Collctions.*;也就是导入了Collections里的所有静态方法，当我们在使用时，直接sort(集合);

import java.util.*;//没有static导入的是类
import static java.util.Collections.*;//静态导入

public class StaticImport {

public static void main(String[] args) {

ArrayList<Integer> als = new ArrayList<Integer>();

// 随机添加整数
Random ran = new Random(10);//传入一个种子，保证每次数据一样。
for (int i = 0; i < 10; i++) {
als.add(ran.nextInt(100));
}
// 排序
sort(als);// 静态导入后直接使用即可
for (Integer al : als) {
System.out.print(al + " ");
}
}
}

结果：13 14 46 56 80 81 88 90 93 97

OK，静态导入到此为此，你也可以试试别的！

增强for循环（foreach）

我们上面已经两次用了增强for循环，增强for循环可以遍历数组，也可以遍历集合。

格式又是怎么样的呢？其实很简单的：for(类型 临时变量名称：数组/集合名称）{执行语句}

但是在使用增强for循环的时候，要注意的问题：对集合操作的时候，不能对集合中的元素进行操作。

import java.util.*;

public class ForeachDemo {

public static void main(String[] args) {

Random ran  = new Random(109);//给一个种子，好让大家测试的时候结果一样。

//搞个数组来遍历一下
int[] arrays = new int[10];
for (int i = 0; i < arrays.length; i++) {//传统for循环
arrays[i] = ran.nextInt(100);
}
//遍历数组
for(int array : arrays){
System.out.print(array+"  ");
}
}

}

上面是遍历数组，但是，不建议大家用这种方式来遍历数组，还是用回传统的for循环吧。

接下来，演示一下，用高级for循环来遍历集合。

import java.util.*;

public class ForeachDemo {

public static void main(String[] args) {

Random ran  = new Random(109);//给一个种子，好让大家测试的时候结果一样。

ArrayList<Integer> als =new ArrayList<Integer>();
for (int i = 0; i <10; i++) {
als.add(ran.nextInt(200));
}

//遍历集合
for(Integer al:als){
System.out.print(al + " ");
}
}

}

如果大家要对集合进行增删的话，请使用迭代器进行操作。这里对迭代器不进行详细说明，请相关的文章吧，后面会写到的。