黑马程序员——【Java高新技术】——JDK1.5新特性：静态导入、可变参数、增强型for循环、自动装箱拆箱、枚举...

一、静态导入

1、import和import static区别：

（1）import 是导入一个类或某个包中所有的类。

（2）import static是导入一个类中的某个静态方法或所有的静态方法。

注：在调用静态导入的类的静态方法时，可以不用再写类名。如Arrays.sort(int[])可以直接写sort(int[]);

2、静态导入的写法：

（1）import static java.util.Arrays.*;   表示导入Arrays类中的所有静态成员。

（2）import static java.lang.System.*; 表示导入System类中所有的静态成员。

3、静态导入注意事项：

（1）当导入的两个类中有同名成员时，需要在成员前加上相应的类名。

（2）当类名重名时，需要指定具体的包名。

（3）方法重名时，需要指定具体所属的对象或者类。

二、可变参数

1、为什么引入可变参数？

如果一个方法在参数列表中传入多个参数，个数不确定，那么每次都要重载该方法，代码重复太多。虽然可以用数组作为形式参数，但是给形参传递数据时，每次都需要定义一个数组对象，作为实际参数，麻烦。于是在JDK1.5版本后，就提供了一个新特性：可变参数。

2、可变参数的书写格式：

在形式参数的变量类型和变量名之间，加入三个点 … ，前后有无空格皆可。例如：

add（int… x）{};

3、可变参数特点：

（1）可变参数必须定义在参数列表的最后；

（2）…位于“变量类型”和“变量名”之间；

（3）可变参数其实就是数组参数的简写形式，编译器为该可变参数隐式创建一个数组，在方法体中以数组的形式访问可变参数。

三、增强型for
循环

1、格式：

for(数据类型 变量名 : 被遍历的集合（collection）或者数组) {执行语句}

2、说明

（1）对集合进行遍历。只能获取集合元素。但是不能对集合进行操作。可以看作是迭代器的简写形式。

（2）迭代器除了遍历，还可以进行remove集合中元素的动作。如果使用ListIterator，还可以在遍历过程中对集合进行增、删、改、查的操作。

（3）增强型for循环的变量类型前可加修饰符，如final（可被局部内部类访问到）。

3、传统for和高级for的区别：

（1）传统for循环可以完成对语句的多次操作，因为可以控制循环增量条件。在遍历数组时有角标索引。

（2） 高级for循环是一种简化形式，它必须有遍历目标，该目标要么是array或Collection单列集合，不可以直接遍历Map集合，但可以将Map集合转化为单列的Set集合，就可以使用。例如：

1 for( Map.Entry) me : map.entrySet()){
2
3 Integer key = me.getKey();
4
5 String value = me.getValue();
6
7 System.out.println(key + “::” +value);
8
9 }

四、基本数据类型的自动拆箱与装箱

1、自动装箱：Integer iObj = 3;

2、自动拆箱：iObj + 2;

3、对于基本数据类型的说明：整数在-128 ~ 127之间的数，包装成Integer类型对象，会存入常量池中的缓存，再创建一个对象的时候，如果其值在这个范围内，就会直接到常量池中寻找，因为这些小数值使用的频率很高，所以缓存到常量池中，被调用时就方便很多。

4、享元模式（flyweight）：

描述：有 很多个小的对象
，它们有很多属性相同，把属性相同的部分变成一个对象，这些相同的属性称为这个对象的内部状态（intrinsic）。把那些不同的属性变成方法的参数，称之为外部的状态（extrinsic）。这种优化内存，只创建一个对象的模式，称之为享元模式。

例如：Integer对象中对象的取值范围在-128~127时，其值相同的对象相同，因为这些小的数被调用的频率较高，所以被缓存在一个池中以备随时调用。这样就不用在创建新的对象，这就是典型的享元设计模式。

五、枚举

（一）概述

1、枚举：就是要让某个类型的变量的取值只能为若干个固定值中的一个，否则，编译器就会报错。枚举可以让编译器在编译时就可以控制源程序中填写的非法值，普通变量的方式在开发阶段无法实现这一目标。它是java1.5中增加的一个新特性。

2、用普通类模拟枚举的实现原理，代码示例：

1 /* 普通类定义一个Weekday的类来模拟枚举功能。
2
3 1、私有的构造方法
4
5 2、每个元素分别用一个公有的静态成员变量表示
6
7 3、可以有若干公有方法或抽象方法。采用抽象方法定义nextDay就将大量的if.else语句转移成了一个个独立的类。
8
9 */
10
11 public abstract class WeekDay {
12
13 //构造函数被私有化，禁止别人创建对象
14
15 private WeekDay(){}
16
17 //将每一个元素，定义为静态常量
18
19 public final static WeekDay SUN=new WeekDay(){
20
21 public WeekDay nextDay(){
22
23 return MON;
24
25 }
26
27 };
28
29 public final static WeekDay MON=new WeekDay(){
30
31 public WeekDay nextDay(){
32
33 return SUN;
34
35 }
36
37 };
38
39 public abstract WeekDay nextDay();
40
41 public String toString(){
42
43 return this==SUN?"SUM":"MON";
44
45 }
46
47 }

（二）枚举的基本应用

1
、概述

（1）通过enum关键字定义枚举类，枚举类是一个特殊的类，每个元素都是该类的一个实例对象。

（2）用枚举类规定值，如上面的WeekDay类。以后用此类型定义的值只能是这个类中规定好的值，若不是这些值，编译器不会通过。

（3）在编译时期就会发现错误，减少了运行时期的错误。

（4）如果调用者想打印枚举类中元素的信息，需由编写此类的人定义toString方法。

注：枚举类是一个class，而且是一个不可被继承的final类，其中的元素都是类静态常量。

2
、枚举常用方法

（1
）构造方法

① 构造方法，只在构造枚举值的时候被调用。

② 构造方法只有private的，没有public的。这样禁止枚举实例对象被外部定义。枚举值是public static final的常量，枚举类的方法和数据域是可以被外部访问的。

③ 构造函数可以有多个，调用哪个即初始化相应的值。

（2
）静态方法

① valueOf(String e)：转为对应的枚举对象，即将字符串转为对象

② values() ：获取所有的枚举对象元素

（3
）非静态方法

① String toString()：返回枚举量的名称

② int ordinal()：返回枚举值在枚举类中的顺序，按定义的顺序排

③ Class getClass()：获取对应的类名

④ String name()：返回此枚举常量的名称，在其枚举声明中对其进行声明。

3
、示例代码：

1 public class EnumDemo {
2
3 public static void main(String[] args) {
4
5 WeekDay weekday = WeekDay.MON;
6
7 System.out.println(“1”+weekDay);//输出枚举常量名
8
9 System.out.println(“2”+weekDay.name());//输出对象名
10
11 System.out.println(“3”+weekDay.getClass());//输出对应类
12
13 System.out.println(“4”+weekDay.toString());//输出枚举对象名
14
15 System.out.println(“5”+weekDay.ordinal());//输出此对象在枚举常量的次序
16
17 System.out.println(“6”+WeekDay.valueOf("WED"));//将字符串转化为枚举常量
18
19 System.out.println(“7”+WeekDay.values().length);//获取所以的枚举元素，并打印其长度
20
21 }
22
23 //定义枚举内部类
24
25 public enum WeekDay{
26
27 SUN(1),MON,TUE,WED,THI,FRI,SAT;//分号可有可无，但如果下面还有方法或其他成员时，分号不能省。并且当有其他方法时，必须在这些枚举变量的下方。
28
29
30
31 //无参构造器
32
33 private WeekDay(){
34
35 System.out.println("First");
36
37 }
38
39 //带参数的构造器
40
41 private WeekDay(int day){
42
43 System.out.println("Second");
44
45 }
46
47 }
48
49 }

（三）枚举的高级应用

1
、枚举
：就相当于一个类，其中也可以定义构造方法、成员变量、普通方法和抽象方法。

2
、枚举元素
：必须位于枚举体中的最开始部分，枚举元素列表的后要有分号与其他成员分隔。把枚举中的成员方法或变量等放在枚举元素的前面，编译器报告错误。

3
、带构造方法的枚举

（1）构造方法必须定义成“私有“。

（2）如果有多个构造方法，该如何选择？

（3）枚举元素MON和MON（）的效果一样，都是调用默认的构造方法。

4
、带方法的枚举

（1）定义枚举TrafficLamp

（2）实现普通的next方法

（3）实现抽象的next方法：每个元素分别是由枚举类的子类来生成的实例对象，这些子类采用类似内部类的方式进行定义。

（4）增加表示时间的构造方法

*
代码示例：

1 public class EnumTest {
2
3 public enum TrafficLamp{
4
5 RED(30){
6
7 public TrafficLamp nextLamp(){
8
9 return GREEN;
10
11 }
12
13 },
14
15 GREEN(30){
16
17 public TrafficLamp nextLamp(){
18
19 return YELLOW;
20
21 }
22
23 },
24
25 YELLOW(5){
26
27 public TrafficLamp nextLamp(){
28
29 return RED;
30
31 }
32
33 };
34
35 private int time;
36
37 //构造器
38
39 private TrafficLamp(int time){
40
41 this.time=time;}
42
43 //抽象方法
44
45 public abstract TrafficLamp nextLamp();
46
47 }
48
49 }