码迷，mamicode.com
首页 > 其他好文 > 详细

高新技术---枚举及部分JDK1.5新特性

时间：2015-01-16 12:38:05      阅读：224      评论：0      收藏：0      [点我收藏+]

标签：

第一讲     枚举

一、概述

        这里说的枚举，不是集合vector的特有枚举迭代器，而是JDK1.5的一个新特性。之所以单独拿它开刷，是这个知识点比较重要，同时相对来说比较难理解一些。

        为什么要有枚举

        问题：要定义星期几或性别的变量，该怎么定义？假设用1-7分别表示星期一到星期日，但有人可能会写成int weekday = 0;或即使使用常量方式也无法阻止意外。

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

示例：

[java] view plaincopy
 
  1. /* 
  2.  * 用普通类如何实现枚举功能，定义一个Weekday的类来模拟枚举功能。  
  3.     1、私有的构造方法 
  4.     2、每个元素分别用一个公有的静态成员变量表示 
  5.     3、可以有若干公有方法或抽象方法。采用抽象方法定义nextDay就将大量的if.else语句转移成了一个个独立的类。 
  6.  
  7. */  
  8.   
  9. package cn.itheima;  
  10.   
  11. public abstract class WeekDay {  
  12.     private WeekDay(){}  
  13.   
  14.     public final static WeekDay SUN=new WeekDay(){  
  15.         public WeekDay nextDay(){  
  16.             return MON;  
  17.         }  
  18.     };  
  19.       
  20.     public final static WeekDay MON=new WeekDay(){  
  21.         public WeekDay nextDay(){  
  22.             return SUN;  
  23.         }  
  24.     };  
  25.       
  26.     public abstract WeekDay nextDay();  
  27.   
  28.     public String toString(){  
  29.         return this==SUN?"SUM":"MON";  
  30.     }  
  31. }  


二、枚举的基本应用

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

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

3、好处：在编译时期就会发现错误，表明值不符合，减少了运行时期的错误。

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

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

5、常用方法：

构造器：

        1）构造器只是在构造枚举值的时候被调用。

        2）构造器只有私有private，绝不允许有public构造器。这样可以保证外部代码无法重新构造枚举类的实例。因为枚举值是public static final的常量，但是枚举类的方法和数据域是可以被外部访问的。

        3）构造器可以有多个，调用哪个即初始化相应的值。

非静态方法：（所有的枚举类都继承了Enum方法）

        1）String toString() ;//返回枚举量的名称

        2）int ordinal() ;//返回枚举值在枚举类中的顺序，按定义的顺序排

        3）Class getClass() ;//获取对应的类名

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

静态方法：

        1）valueOf(String e) ;//转为对应的枚举对象，即将字符串转为对象

        2）values() ;//获取所有的枚举对象元素

示例：

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

 

三、枚举的高级应用

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

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

3、带构造方法的枚举

        1）构造方法必须定义成私有的

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

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

4、带方法的枚举

如：

[java] view plaincopy
 
  1. /* 
  2.  * 抽象的枚举方法 
  3.  * 此时枚举中的常量需要子类来实现，这是可以利用内部类的方式来定义枚举常量 
  4.  * 带方法的枚举 
  5.     1）定义枚举TrafficLamp 
  6.     2）实现普通的next方法 
  7.     3）实现抽象的next方法：每个元素分别是由枚举类的子类来生成的实例对象，这些子类 
  8.     4）用类似内部类的方式进行定义。 
  9.     5）增加上表示时间的构造方法 
  10.  * */  
  11.   
  12. package cn.itheima;  
  13.   
  14. public class EnumTest {  
  15.     public enum TrafficLamp{  
  16.         RED(30){  
  17.             public TrafficLamp nextLamp(){  
  18.                 return GREEN;  
  19.             }  
  20.         },  
  21.         GREEN(30){  
  22.             public TrafficLamp nextLamp(){  
  23.                 return YELLOW;  
  24.             }  
  25.         },  
  26.         YELLOW(5){  
  27.             public TrafficLamp nextLamp(){  
  28.                 return RED;  
  29.             }  
  30.         };  
  31.         private int time;  
  32.         //构造器  
  33.         private TrafficLamp(int time){  
  34.             this.time=time;}  
  35.         //抽象方法  
  36.         public abstract TrafficLamp nextLamp();  
  37.     }         
  38. }  

小结：

        1、匿名内部类比较常用

        2、类的方法返回的类型可以是本类的类型

        3、类中可定义静态常量，常量的结果就是自己这个类型的实例对象

        4、枚举只有一个成员时，就可以作为一种单例的实现方式。

注：

        1、所有的枚举都继承自java.lang.Enum类。由于Java不支持多继承，所以枚举对象不能再继承其他类。

         2、switch语句支持int,char,enum类型，使用枚举，能让我们的代码可读性更强。

 

第二讲     JDK1.5其他部分新特性

一、静态导入

1、写法：

        import staticjava.util.Arrays.*;//导入的是Arrays这个类中的所以静态成员。

        import staticjava.lang.System.*//导入了Ssytem类中所以静态成员。

        没加static导入的是类，加上static导入的全是某一个类中所以的静态成员。这样写在调用该类的静态方法时可以不用再写类名。如：Arrays.sort(数组);就可以直接写sort(数组);

2、注意：

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

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

示例：

[java] view plaincopy
 
  1. import java.util.*;  
  2. import static java.util.Arrays.*;  
  3. import static java.lang.System.*;  
  4.   
  5. class  StaticImport //extends Object  
  6. {  
  7.     public static void main(String[] args)   
  8.     {  
  9.         out.println("haha");//打印输出时就可以直接省略书写System.  
  10.         int[] arr = {3,1,5};  
  11.   
  12.         sort(arr);//使用Arrays工具类的方法sort时就可以省略书写Array.  
  13.   
  14.         int index = binarySearch(arr,1);//半分查找也是一样可以省略  
  15.         out.println("Index="+index);  
  16.   
  17.         //当没有指定继承时，所以类默认继承了Object，  
  18.        //因为toString方法都具备，所以为了区分，必须写上具体调用者  
  19.        out.println(Arrays.toString(arr));  
  20.     }  
  21. }  

 

二、增强for循环

1、格式：

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

2、说明

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

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

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

       高级for有一个局限性。必须有被遍历的目标（集合或数组）。

       传统for遍历数组时有索引。

建议在遍历数组的时候，还是希望使用传统for。因为传统for可以定义角标。

注意：变量类型前可加修饰符，如final（可被局部内部类访问到）。

示例： 

[java] view plaincopy
 
  1. import java.util.*;  
  2. class For  
  3. {  
  4.     public static void main(String[] args)   
  5.     {  
  6.         //定义一个ArrayList集合  
  7.         ArrayList<String> al = new ArrayList<String>();  
  8.         al.add("abc1");  
  9.         al.add("abc2");  
  10.         al.add("abc3");  
  11.   
  12.         for(String s : al)  
  13.         {  
  14.             System.out.println(s);//用高级for遍历集合  
  15.         }  
  16.   
  17.         //传统for与高级for遍历数组  
  18.         int[] arr = {3,5,1};  
  19.   
  20.         for(int x=0; x<arr.length; x++)  
  21.         {  
  22.             System.out.println(arr[x]);  
  23.         }  
  24.         for(int i : arr)  
  25.         {  
  26.             System.out.println("i:"+i);  
  27.         }  
  28.   
  29.         //定义一个HashMap集合  
  30.         HashMap<Integer,String> hm = new HashMap<Integer,String>();  
  31.   
  32.         hm.put(1,"a");  
  33.         hm.put(2,"b");  
  34.         hm.put(3,"c");  
  35.   
  36.         //keySet取出方式的高级for遍历  
  37.         Set<Integer> keySet = hm.keySet();  
  38.         for(Integer i : keySet)  
  39.         {  
  40.             System.out.println(i+"::"+hm.get(i));  
  41.         }  
  42.   
  43.         //entrySet取出方式的高级for遍历  
  44.         for(Map.Entry<Integer,String> me : hm.entrySet())  
  45.         {  
  46.             System.out.println(me.getKey()+"------"+me.getValue());  
  47.         }  
  48.   
  49.     }  
  50. }  

 

三、可变参数：（方法的重载）VariableParameter

        如果一个方法在参数列表中传入多个参数，个数不确定，那么每次都要复写该方法。这时可以用数组作为形式参数。但是在传入时，每次都需要定义一个数组对象，作为实际参数。在JDK1.5版本后，就提供了一个新特性：伤感的句子可变参数。

        用…这三个点表示，且这三个点位于变量类型和变量名之间，前后有无空格皆可。

        可变参数其实就是数组参数的简写形式。不用每一次都手动的建立数组对象。只要将要操作的元素作为参数传递即可。隐式将这些参数封装成了数组。

        在使用时注意：可变参数一定要定义在参数列表的最后面。

示例：

[java] view plaincopy
 
  1. class  ParamMethodDemo  
  2. {  
  3.     public static void main(String[] args)   
  4.     {  
  5.         show("haha",2,3,4,5,6);  
  6.     }  
  7.     public static void show(String str,int... arr)//...就表示可变参数  
  8.     {  
  9.         System.out.println(arr.length);  
  10.     }  
  11. }  

 

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

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

2、自动拆箱：iObj + 2;

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

4、享元模式（flyweight）：

        1）概述：有很多个小的对象，他们有很多相同的属性，把属性相同的部分变为同一个对象，这些属性称为内部状态。那些不同的属性，把他们变成方法的参数，称之为外部的状态。这种优化内存，只创建一个对象的模式，称之为享元模式。例如：Integer对象中对象取值范围在-128~127时，其值相同的对象想等，因为这些小的数被缓存在一个池中，被调用的频率较高，所以通常在池中取，从而导致对象相同。这就是典型的享元设计模式。

        2）应用：

          （1）word中输入英文字母，可创建26对象，每个对象值是出现的位置不同（坐标），所以可用一个对象调用位置的方法：如，字母i：i.display(intx,inty)，将高度重复使用的char类型的字母i封装成一个对象使用。

          （2）图标：window下的文件夹图标，只有名称这个属性不同，包含了很多其他相同的属性，那么可以应用享元模式。

        3）valueOf(int x)：Integer中静态方法，将一个整数转换为Integer，即把基本数据类型变为包装类。

高新技术---枚举及部分JDK1.5新特性

标签：

原文地址：http://www.cnblogs.com/tiankong101/p/4228176.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！