黑马程序员——【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<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 }

 

郑重声明:本站内容如果来自互联网及其他传播媒体,其版权均属原媒体及文章作者所有。转载目的在于传递更多信息及用于网络分享,并不代表本站赞同其观点和对其真实性负责,也不构成任何其他建议。