java枚举小结

标签：style   class   blog   code   java   http   

在百度百科上是这样介绍枚举的:

在C#或C++,java等一些计算机编程语言中，枚举类型是一种基本数据类型而不是构造数据类型，而在C语言等计算机编程语言中，它是一种构造数据类型。枚举类型用于声明一组命名的常数，当一个变量有几种可能的取值时，可以将它定义为枚举类型。

而在java中,枚举扩大了这一概念,因为在java中,枚举已经称为一个类,因此完全具有类的特性.

我们都知道枚举是JDK1.5才推出的新概念,那么在此之前,我们如果想使用一些固定的常量集合,比如性别(2个),季节(4个),星期(7个)以及一些其他复杂的,我们该如何表示这些呢?我们就以星期来举例说明:

在JDK1.5之前,大多数程序员是使用下面这种方式:

[java] view plaincopy

1. class Enum01 {  
2.     static final String MONDAY = "星期一";  
3.     static final String TUESDAY = "星期一";  
4.     static final String WEDNESDAY = "星期一";  
5.     static final String THURDAY = "星期一";  
6.     static final String FRIDAY = "星期一";  
7.     static final String SATURDAY = "星期一";  
8.     static final String SUNDAY = "星期一";  
9. }  

[java] view plaincopy

1. System.out.println("今天是"+Enum01.THURDAY);  
2.     System.out.println("明天是"+Enum01.FRIDAY);  

[java] view plaincopy

1. enum Enum2 {  
2.     MONDAY("星期一"), TUESDAY("星期二"), WEDNESDAY("星期三"), THURDAY("星期四"), FRIDAY(  
3.             "星期五"), SATURDAY("星期六"), SUNDAY("星期日");  
4.     private String weekday;  
5.     public String getWeekday() {  
6.         return this.weekday;  
7.     }  
8.     Enum2(String weekday) {  
9.         this.weekday = weekday;  
10.     }  
11. }  

[java] view plaincopy

1. for (Enum2 en : Enum2.values()) {  
2.             System.out.println(en.getWeekday());  
3.         }  

注意:enum类只能有一个受保护(并非protected修饰)的构造函数,并且程序员无法进行调用

上面的内容都不是干货,看上去既无味也没什么实际说明,下面我们给出一个能够在实际生活中用到的情况.

假如一家超市在出售几种类型的水果,apple(苹果),banana(香蕉),(菠萝),watermelon(西瓜),grape(葡萄),我们就以这五种水果来举例:

代码如下:

[java] view plaincopy

1. enum Fruits{  
2.     apple(3.24),banana(2.34),pineapple(4.23),watermelon(2.5),grape(1.2);  
3.     private double price;  
4.     public double getPrice() {  
5.         return this.price;  
6.     }  
7.     public void setPrice(double price) {  
8.         this.price = price;  
9.     }  
10.     private Fruits(double price) {  
11.         this.price = price;  
12.     }  
13. }  

[java] view plaincopy

1. class Customer{  
2.     public double buy(Fruits type,double weight){  
3.         return type.getPrice()*weight;  
4.     }  
5. }  

回值是购买该水果所花费的金额.

下面进行测试,

[java] view plaincopy

1. Customer xiaoming = new Customer();  
2.         double cost = 0 ;   
3.         cost = xiaoming.buy(Fruits.apple, 1);//小明购买了2斤苹果  
4.         cost += xiaoming.buy(Fruits.banana, 2);//小明购买了2斤香蕉  
5.         cost += xiaoming.buy(Fruits.grape, 3);//小明购买了2斤葡萄  
6.         cost += xiaoming.buy(Fruits.pineapple, 4);//小明购买了2斤菠萝  
7.         cost += xiaoming.buy(Fruits.watermelon, 5);//小明购买了西瓜  
8.         //计算小明一共所花的金额  
9.         System.out.println("结账,您一共花费了"+cost+"元");  

说明的,就像上面所说的,一家商店不可能只出售这么几种水果,也不可能保存水果始终在这个价格,假如下一个礼拜商店新

进了几种水果,而且要进行促销(假如是五一黄金期),那么商店比如会重新改动该枚举类,并且要增加新的水果和改变原有水

果的价格,但是--显然,这不是一种好的处理方案,我们不能在原有的类中进行修改,在语言本身上,这不符合开闭原则(既一个类

对扩展开放,而对修改关闭).从显示角度上说,也不符合现实生活,如果促销期一过,我们需要将水果价钱恢复到促销前呢?那么

修改后的类显然无法做到这点.因此,我们有必要新建一个扩展枚举类,但是随之而来的问题出现了,java中的枚举类都已经默认

实现了java.lang.Enum类,因此无法进行多继承,那么该怎么半呢?

[java] view plaincopy

1. enum OnSalesFruits{  
2.     apple(2.24),banana(1.34),pineapple(3.23),watermelon(1.5),grape(0.2),mango(2.5);//mango为新增  
3.     private double price;  
4.     public double getPrice() {  
5.         return this.price;  
6.     }  
7.     public void setPrice(double price) {  
8.         this.price = price;  
9.     }  
10.     private OnSalesFruits(double price) {  
11.         this.price = price;  
12.     }  
13. }  

下面.客户小明又来买水果了.

[java] view plaincopy

1. System.out.println("促销前小明购买水果:");  
2.         Customer xiaoming = new Customer();  
3.         double cost1 = 0 ;   
4.         cost1 = xiaoming.buy(Fruits.apple, 1);//小明购买了2斤苹果  
5.         cost1 += xiaoming.buy(Fruits.banana, 2);//小明购买了2斤香蕉  
6.         cost1 += xiaoming.buy(Fruits.grape, 3);//小明购买了2斤葡萄  
7.         cost1 += xiaoming.buy(Fruits.pineapple, 4);//小明购买了2斤菠萝  
8.         cost1 += xiaoming.buy(Fruits.watermelon, 5);//小明购买了西瓜  
9.         //计算小明一共所花的金额  
10.         System.out.println("结账,您一共花费了"+cost1+"元");  
11.         System.out.println("促销后小明购买水果:");  
12.         double cost2 = 0 ;   
13.         cost2 = xiaoming.buy(OnSalesFruits.apple, 1);//小明购买了2斤苹果  
14.         cost2 += xiaoming.buy(OnSalesFruits.banana, 2);//小明购买了2斤香蕉  
15.         cost2 += xiaoming.buy(OnSalesFruits.grape, 3);//小明购买了2斤葡萄  
16.         cost2 += xiaoming.buy(OnSalesFruits.pineapple, 4);//小明购买了2斤菠萝  
17.         cost2 += xiaoming.buy(OnSalesFruits.watermelon, 5);//小明购买了5斤西瓜  
18.         cost2 +=xiaoming.buy(OnSalesFruits.mango, 5);//小明购买6斤芒果  
19.         System.out.println("结账,您一共花费了"+cost2+"元");  

结果如下:

但是这样我们很不满意,因为并没能去继承Fruits类让人很失望,不过,这也从侧面说明了一个问题,那就是枚举不适合

做那些需要改变数据的集合,因此也回到了枚举的定义上:

枚举类:包含常量集合的容器,因此如果发现你创建的类中的值需要变化,那么不建议使用枚举,因为他无法实现

扩展(继承意义上的扩展);

下面说道真正使用枚举类的情况:

假如我们有一串常量需要表示单位换算,比如从千克到磅,到克拉,到盎司,我们知道这些转换率不像如今的货币换算一样

会发生变化,它们的转换率是不变的,因此我们可以创建一个枚举来表示:

[java] view plaincopy

1. enum Converter{  
2.     Kg(0.45359237), Cart(2267.96185), Gms(453.59237) ,Ounce(16);  
3.     private final double symbol ;  
4.     public double getSymbol() {  
5.         return this.symbol;  
6.     }  
7.     Converter(double sybol){  
8.         this.symbol =sybol;  
9.     }  
10. }  

[java] view plaincopy

1. class ExchangeUtil{  
2.     public static double  kgToPound(Converter1 type,double d){  
3.         return type.getSymbol() *d;  
4.     }  
5.     public static double  cartToPound(Converter1 type,double d){  
6.         return type.getSymbol() *d;  
7.     }  
8.     public static double  gmsToPound(Converter1 type,double d){  
9.         return type.getSymbol() *d;  
10.     }  
11.     public static double  ounceToPound(Converter1 type,double d){  
12.         return type.getSymbol() *d;  
13.     }  
14. }  

这样,我们就可以使用上述代码来完成我们由磅到千克,克拉,盎司的转换了.

测试代码:

[java] view plaincopy

1. System.out.println("100千克转换成磅后为:"+ExchangeUtil.kgToPound(Converter1.Kg, 100)+"磅");  

从百度工具上测试结果:

发现很好的吻合了.但是这中方法需要建立两个类,很麻烦,那么有没有简单的方法呢?有--一个枚举类就可以实现:

我们修改原有的Converter类,

[java] view plaincopy

1. enum Converter{  
2.     KgToPound("KG"){  
3.         @Override  
4.         double performConversion(double f){  
5.             return f*0.45359237;  
6.         }  
7.     },  
8.     CartToPound("cart"){  
9.         @Override  
10.         double performConversion(double f){  
11.             return f*2267.96185;  
12.         }  
13.     },  
14.     GmsToPound("gms"){  
15.         @Override  
16.         double performConversion(double f){  
17.             return f*453.59237;  
18.         }     
19.     },  
20.     OunceToPound("ounce"){  
21.         @Override  
22.         double performConversion(double f){  
23.             return f*16;  
24.         }  
25.     };  
26.     private final String symbol;  
27.     public String getSymbol() {  
28.         return this.symbol;  
29.     }  
30.     Converter(String symbol){  
31.         this.symbol = symbol;  
32.     }  
33.     abstract double performConversion(double f);  
34. }  

也许很奇怪,我们可以从类中定义抽象方法,并且在类本身中去实现它,这就是java中枚举的新特性,因为在其他语言中无法

实现将方法添加到枚举中,二java为了让枚举实现类的特点,突破了传统枚举的定义,我们可以在枚举类中实现自定义的

抽象方法,但是也有限制,那就是该枚举类中所有的常量都必须实现该抽象方法.

这样一来,我们再进行转换的时候,就无需新创建一个工具类来实现转换功能了.

[java] view plaincopy

1. System.out.println("100千克转换成磅后为:"+Converter.KgToPound.performConversion(100.0)+"磅");  

身来实现转换功能,而前述中的代码却需要引入一个工具类,增加了系统的耦合度.

将枚举说道这里,基本差不多了,就剩下了常用枚举的方法,以及枚举的序列化,

至于枚举的序列化和普通类的序列化没什么区别,如果感兴趣可以看看:java对象序列化小结

而枚举常用的方法,这里要说明两个  一个是ordinal,一个是compareTo

ordinal就是返回当前枚举在原有常量序列中的序列号

compareTo就是比较枚举类中两个常量的相对位置

至此,枚举小结.

java枚举小结,布布扣,bubuko.com

java枚举小结

标签：style   class   blog   code   java   http   

原文地址：http://blog.csdn.net/u012332735/article/details/30728247