当前位置:阳光沙滩 >Java > 查看文章
阿里云优惠码

Java-JDK1.5新特性

java's father

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

1.一、枚举

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

在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
 */

 

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

2.静态导入

当我们在学集合框架的时候,工具类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,静态导入到此为此,你也可以试试别的!

3.增强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 + " ");
		}
	}

}

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

 

本文链接:http://blog.sunofbeaches.com/archives/103 转载请注明出处.
如果喜欢:点此订阅本站
7K
相关文章
为您推荐
各种观点

报歉!评论已关闭.