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

枚举

枚举概述

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

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

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

自定义枚举类。

　

　　　第一版：无参构造

 public class Direction {
     // 创建几个实例
     public static final Direction FRONT = new Direction();
     public static final Direction BEHIND = new Direction();
     public static final Direction LEFT = new Direction();
     public static final Direction RIGHT = new Direction();

     // 构造私有，别人就不能无限的创建了
     private Direction() {
     }
 }

　　第二版：带参构造

 public class Direction2 {
     // 创建几个实例
     public static final Direction2 FRONT = new Direction2("前");
     public static final Direction2 BEHIND = new Direction2("后");
     public static final Direction2 LEFT = new Direction2("左");
     public static final Direction2 RIGHT = new Direction2("右");

     // 构造私有，别人就不能无限的创建了
     // private Direction2() {
     // }

     // 加入成员变量,并去掉无参构造
     private String name;

     private Direction2(String name) {
         this.name = name;
     }

     public String getName() {
         return name;
     }
 }

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

 public abstract class Direction3 {
     // 创建几个实例

     // 由于抽象类中不能实例化对象，也就是说不能这样
     //public static final Direction3 FRONT = new Direction3("前");
     //但是，可以使用匿名内部方法，如下：
     //这样就是把new Direction3("前"){}这个子类对象重写了抽象方法：show()，并赋予 给 父亲Direction3 FRONT。
     public static final Direction3 FRONT = new Direction3("前") {
         @Override
         public void show() {
             System.out.println("前");
         }

     };
     public static final Direction3 BEHIND = new Direction3("后") {
         @Override
         public void show() {
             System.out.println("后");
         }

     };
     public static final Direction3 LEFT = new Direction3("左") {
         @Override
         public void show() {
             System.out.println("左");
         }

     };
     public static final Direction3 RIGHT = new Direction3("右") {
         @Override
         public void show() {
             System.out.println("右");
         }

     };

     // 构造私有，别人就不能无限的创建了
     // private Direction2() {
     // }

     // 加入成员变量,并去掉无参构造
     private String name;

     private Direction3(String name) {
         this.name = name;
     }

     public String getName() {
         return name;
     }

     // 加入抽象方法
     public abstract void show();
 }

　　最后是测试类：

 public class DirectionDemo {
     public static void main(String[] args) {

         //打印第一种方式
         Direction d = Direction.FRONT;
         System.out.println(d); // 打印出地址值
         System.out.println("------------------------------------");

         //打印第二种方式
         Direction2 d2 = Direction2.FRONT;
         System.out.println(d2);// 打印出地址值
         System.out.println(d2.getName()); //前
         d2 = Direction2.RIGHT;
         System.out.println(d2);
         System.out.println(d2.getName());
         System.out.println("------------------------------------");

         //打印第三种方式
         Direction3 d3 = Direction3.FRONT;
         System.out.println(d3);// 打印出地址值
         System.out.println(d3.getName());//前
         //按理说抽象类不能调用方法，但这个可以调方法。
         //由于new Direction3("前"){}这个子类对象重写了抽象方法：show()方法，而运行看右边，有show()
         d3.show();
         d3 = Direction3.LEFT;
         System.out.println(d3);
         System.out.println(d3.getName());
         d3.show();
     }
 }