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

---------- android培训、java培训、期待与您交流！ ----------

一、静态导入

　　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 }

 

---------- android培训、java培训、期待与您交流！ ----------