查看: 1275|回复: 0

[Java学习] 深入学习java枚举的应用

发表于 2018-3-2 08:05:16

一.枚举和静态常量区别

讲到枚举我们首先思考,它和public static final String 修饰的常量有什么不同。

我举枚举的两个优点:

1. 保证了类型安全:调用者无法随意传一个 int或者String 等值;

2.代码可读性非常高;

举个例子:

在实际编程中,往往存在着这样的“数据集”,它们的数值在程序中是稳定的,而且“数据集”中的元素是有限的。例如春夏秋冬四个数据元素组成了四季的“数据集”。

你写了方法get(String season),输入的类型只能是String类型,同时要String只能是(春、夏。秋。冬)。

这个时候。你写四个字符串常量

  1. public class Common {
  2. public static final String SPRING="春";
  3. public static final String SEASON="夏";
  4. public static final String SUMMER="秋";
  5. public static final String AUTUMN="冬";
  6. }
复制代码

在get方法里放入get(Common.SEASON),确实是把"春",放进去了,但是这个时候你会发现这里面有一个隐患,你get(String season),毕竟放入的是String类型的,如果新同事或者不知情的同事,不知道这个方法里只能放“春、夏、秋、冬”,它放了个其期它字符串比如get("小小“),这个时候,在编译期它是不会报错的,只有运行之后,才发现错了。

为了防止上面的隐患,枚举出现了

  1. public enum Season {
  2. SPRING("春"),
  3. SUMMER("夏"),
  4. AUTUMN("秋"),
  5. WINTER("冬");
  6. .....
  7. }
复制代码

这个时候,我们修改get方法的传参,改成get(Season season) 这个时候加入get(Season.SPRING),这就能保证传入的参数只能是这几个。

二.理解枚举

首要我们要明确,其实枚举也是个class类,我写个枚举来理解。

  1. //我们把枚举当做一个普通类
  2. public enum Season {
  3. SPRING(1,"春"),
  4. SUMMER(2,"夏" ),
  5. AUTUMN(3,"秋" ),
  6. WINTER(4,"冬"); //这里最后一个一定要分号,否则报错
  7. /*我们可以理解成
  8. *public static final Season SPRING = new Season(1,春);
  9. *public static final Season SUMMER = new Season(2,夏);
  10. *public static final Season AUTUMN = new Season(3,秋);
  11. *public static final Season WINTER = new Season(4,冬);
  12. *既然是对象,那下面就很好理解了
  13. */
  14. /*
  15. * 1.上面对象里放了两个参数,那下面就肯定要有这个类型的构造函数
  16. * 2.这里是private,因为不能在被new对象了
  17. */
  18. private Season(int code,String name) {
  19. this.name = name;
  20. this.code = code;
  21. }
  22. //对象的属性
  23. private String name;
  24. private int code;
  25. //获取对象属性的方法
  26. public String getName() {
  27. return this.name;
  28. }
  29. public String getCode() {
  30. return this.name;
  31. }
  32. //通过code获得对象,我们就可以获得对象的其它属性
  33. public static Season decode(int code) {
  34. Season season = null;
  35. for (Season type : Season.values()) {
  36. if (type.code==code) {
  37. season = type;
  38. break;
  39. }
  40. }
  41. return season;
  42. }
  43. //重新toString方法
  44. public String toString() {
  45. return this.name;
  46. }
  47. }
复制代码

上面这个例子,就很好解释了枚举,它和普通类没什么区别,只是用另一种写法创建了几个有属性的对象,这也必须写这样有属性的构造函数,仅此而已。

这里顺便列举下枚举的一些特点:

1.它不能有public的构造函数,这样做可以保证客户代码没有办法新建一个enum的实例。
2. 枚举不能在继承其它类了,因为它默认继承了java.lang.Enum
3. 常量值地址唯一,可以用==直接对比,性能会有提高.
4.Enum还提供了values方法,这个方法使你能够方便的遍历所有的枚举值。
5.Enum还有一个oridinal的方法,这个方法返回枚举值在枚举类种的顺序,这个顺序根据枚举值声明的顺序而定。

三.枚举的常见用法

第一种:switch运用

先建一个枚举:

  1. public enum Common {
  2. INSERT,
  3. MODIFY,
  4. DELETE
  5. }
  6. //因为这里是无参的对象,所以可以用系统默认的构造函数。也不用写属性和方法。
复制代码

在写实现代码

  1. public class CommonUtils {
  2. public static void getType(Common common){
  3. Common c=common;
  4. switch(c)
  5. {
  6. case INSERT:
  7. System.out.println("进行插入操作");
  8. break;
  9. case MODIFY:
  10. System.out.println("进行修改操作");
  11. break;
  12. case DELETE:
  13. System.out.println("进行删除操作");
  14. break;
  15. }
  16. }
  17. public static void main(String[] args) {
  18. getType(Common.DELETE); //后台输出:进行删除操作
  19. }
  20. }
复制代码

第二种用法,通过key值获得value值获取其它值

枚举类

  1. public enum Season {
  2. SPRING(1,"春","春天放风筝"),
  3. SUMMER(2,"夏","夏天去游泳"),
  4. AUTUMN(3,"秋","秋天去秋游"),
  5. WINTER(4,"冬","冬天吃火锅");
  6. private Season(int code,String name,String bz) {
  7. this.code = code;
  8. this.name = name;
  9. this.bz=bz;
  10. }
  11. private int code;
  12. private String name;
  13. private String bz;
  14. public static Season decode(int code) {
  15. Season season = null;
  16. for (Season type : Season.values()) {
  17. if (type.code==code) {
  18. season = type;
  19. break;
  20. }
  21. }
  22. return season;
  23. }
  24. public int getCode() {
  25. return code;
  26. }
  27. public String getName() {
  28. return name;
  29. }
  30. public String getBz() {
  31. return bz;
  32. }
  33. }
复制代码

测试类

好了,就写这么多,以后有需要会更深入了解。感谢大家对程序员之家的支持。



回复

使用道具 举报