java 28

枚举

枚举概述

　　是指将变量的值一一列出来,变量的值只限于列举出来的值的范围内。举例：一周只有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();
    }
}