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 + " ");
}
}
}
如果大家要对集合进行增删的话,请使用迭代器进行操作。这里对迭代器不进行详细说明,请相关的文章吧,后面会写到的。