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

浏览数：14 / 时间：2015年06月08日

一、静态导入

　　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<Integer , String>) 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 }