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 + " ");
		}
	}

}

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