java 28 - 4 JDK5的新特性 之 枚举的概述和自定义枚举类

枚举

枚举概述

　　是指将变量的值一一列出来,变量的值只限于列举出来的值的范围内。举例：一周只有7天，一年只有12个月等。

　　回想单例设计模式：单例类是一个类只有一个实例

　　那么多例类就是一个类有多个实例，但不是无限个数的实例，而是有限个数的实例。这才能是枚举类。

 

自定义枚举类。

　

　　　第一版：无参构造

 1 public class Direction {
 2     // 创建几个实例
 3     public static final Direction FRONT = new Direction();
 4     public static final Direction BEHIND = new Direction();
 5     public static final Direction LEFT = new Direction();
 6     public static final Direction RIGHT = new Direction();
 7 
 8     // 构造私有，别人就不能无限的创建了
 9     private Direction() {
10     }
11 }

 

　　第二版：带参构造

 1 public class Direction2 {
 2     // 创建几个实例
 3     public static final Direction2 FRONT = new Direction2("前");
 4     public static final Direction2 BEHIND = new Direction2("后");
 5     public static final Direction2 LEFT = new Direction2("左");
 6     public static final Direction2 RIGHT = new Direction2("右");
 7 
 8     // 构造私有，别人就不能无限的创建了
 9     // private Direction2() {
10     // }
11 
12     // 加入成员变量,并去掉无参构造
13     private String name;
14 
15     private Direction2(String name) {
16         this.name = name;
17     }
18 
19     public String getName() {
20         return name;
21     }
22 }

 

　　第三个版本：有构造方法和带参构造

 1 public abstract class Direction3 {
 2     // 创建几个实例
 3     
 4     // 由于抽象类中不能实例化对象，也就是说不能这样
 5     //public static final Direction3 FRONT = new Direction3("前");
 6     //但是，可以使用匿名内部方法，如下：
 7     //这样就是把new Direction3("前"){}这个子类对象重写了抽象方法：show()，并赋予 给 父亲Direction3 FRONT。
 8     public static final Direction3 FRONT = new Direction3("前") {
 9         @Override
10         public void show() {
11             System.out.println("前");
12         }
13 
14     };
15     public static final Direction3 BEHIND = new Direction3("后") {
16         @Override
17         public void show() {
18             System.out.println("后");
19         }
20 
21     };
22     public static final Direction3 LEFT = new Direction3("左") {
23         @Override
24         public void show() {
25             System.out.println("左");
26         }
27 
28     };
29     public static final Direction3 RIGHT = new Direction3("右") {
30         @Override
31         public void show() {
32             System.out.println("右");
33         }
34 
35     };
36 
37     // 构造私有，别人就不能无限的创建了
38     // private Direction2() {
39     // }
40 
41     // 加入成员变量,并去掉无参构造
42     private String name;
43 
44     private Direction3(String name) {
45         this.name = name;
46     }
47 
48     public String getName() {
49         return name;
50     }
51 
52     // 加入抽象方法
53     public abstract void show();
54 }

 

　　最后是测试类：

 1 public class DirectionDemo {
 2     public static void main(String[] args) {
 3         
 4         //打印第一种方式
 5         Direction d = Direction.FRONT;
 6         System.out.println(d); // 打印出地址值
 7         System.out.println("------------------------------------");
 8         
 9         //打印第二种方式
10         Direction2 d2 = Direction2.FRONT;
11         System.out.println(d2);// 打印出地址值
12         System.out.println(d2.getName()); //前
13         d2 = Direction2.RIGHT;
14         System.out.println(d2);
15         System.out.println(d2.getName());
16         System.out.println("------------------------------------");
17         
18         //打印第三种方式
19         Direction3 d3 = Direction3.FRONT;
20         System.out.println(d3);// 打印出地址值
21         System.out.println(d3.getName());//前
22         //按理说抽象类不能调用方法，但这个可以调方法。
23         //由于new Direction3("前"){}这个子类对象重写了抽象方法：show()方法，而运行看右边，有show()
24         d3.show();
25         d3 = Direction3.LEFT;
26         System.out.println(d3);
27         System.out.println(d3.getName());
28         d3.show();
29     }
30 }

 

转载于:https://www.cnblogs.com/LZL-student/p/5970730.html