进阶JAVA篇-深入了解枚举与抽象枚举

目录

      介绍一下枚举：

          1.1枚举的概念

          1.2具体如何来使用呢？

          1.3对枚举小结

          1.4抽象枚举概念

          1.5对抽象枚举小结

---

                介绍一下枚举：

        1.1枚举的概念

        在JAVA中，枚举是一种特殊的类，用于定义一组常量。Java中的枚举类型是通过使用关键字"enum"来定义的。枚举类中的第一行只能写一些合法的标识符（名称），多个名称需要逗号相隔开来，这些名称本质是常量，每个常量都会记住一个枚举类的对象。枚举类里面除了第一行的常量之外，其余跟一般的类所具有的成员（变量、方法、构造器、代码块、内部类）都有具有。

代码如下：

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

    }

}

enum EnumerateClasses{
    X,Y,Z;

    private String name;
    private int age;

    public void fun(){
        System.out.println("调用枚举类中的方法");
    }

    EnumerateClasses() {
    }

    EnumerateClasses(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

         接下来我们反汇编来观察枚举类，深入枚举内部了解一下：

        

        先来看第一个“红框”用关键字final来修饰一个枚举类，所以枚举类是不可以被别的类所继承的，枚举类是最终类。再来看第二个“大红框”，编写的第一行的符号（名称），之所以被称为常量，这样就一清二楚了，是因为用static final 来修饰所编写的名称，还有一个要注意的是，这些名称的类型是一个类！！！因此可以这样说枚举类的第一行必须罗列的是枚举对象的名称。

        还有一点注意，通过反汇编观察到，枚举类中无论是无参构造器还是有参构造器中都默认为私有的（private）来修饰构造器,所以枚举是不可以在枚举外部new创建对象的，只能在内部。其实枚举就是一个只能在自己内部定义自己的对象。

如下：

         1.2具体如何来使用呢？

代码如下：

public class Enum {
    public static void main(String[] args) {
        EnumerateClasses enumerateClasses = EnumerateClasses.X;
        enumerateClasses.fun();

        System.out.println(enumerateClasses.getName());
        System.out.println(enumerateClasses.getAge());
    }
}
enum EnumerateClasses{
    X("lisi",12),Y,Z;

    private String name;
    private int age;

    public void fun(){
        System.out.println("调用枚举类中的方法");
    }

    EnumerateClasses() {
    }

    EnumerateClasses(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

        对以上代码进行分析，首先先在枚举内初始化 X（"lisi","12"） 这个方式就是在用私有的有参数的构造器创建对象，因为这个对象是用static final修饰的，该对象将成为类的静态常量，所以可以用枚举名.对象，然后用枚举类型的变量来接收，接着就可以用这个变量名去访问公开的成员了。

 编译器中为枚举新增加了几个方法，下面来展示一下：

public class Enum {
    public static void main(String[] args) {
        EnumerateClasses enumerateClasses = EnumerateClasses.X;
        enumerateClasses.fun();

        System.out.println(enumerateClasses.getName());
        System.out.println(enumerateClasses.getAge());

        //该方法可以得到全部对象，并且放到一个数组中
        EnumerateClasses[] e = EnumerateClasses.values();
        for (int i = 0; i < e.length; i++) {
            EnumerateClasses j = e[i];
            System.out.print(j.getName()+" ");
            System.out.println(j.getAge());
        }

        System.out.println("-----------------------------------------");
        //该方法可以得到指定的对象
        EnumerateClasses name = EnumerateClasses.valueOf("X");
        System.out.print(name.getName() + " ");
        System.out.println(name.getAge());
        //该方法可以得到该对象对应的索引
        System.out.println(name.ordinal());
    }
}
enum EnumerateClasses{
    X("李四",12),Y("王五",22),Z("张三",33);

    private String name;
    private int age;

    public void fun(){
        System.out.println("调用枚举类中的方法");
    }

    EnumerateClasses() {
    }

    EnumerateClasses(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

        1.3对枚举小结：

        第一行定义的是常量，用合法字符来表示，每一个字符都会对应一个对象，该对象是类的静态常量，可以直接被类访问。枚举不能被继承，也不能去new对象，只能在枚举内部创建对象。了解了三个编译器为枚举新增的方法，分别可以得到全部对象，可以得到指定的对象，可以查找该对象的索引。

        1.4抽象枚举概念

        抽象枚举相比与普通的枚举，就是在枚举内部有抽象方法，需要重写抽象方法，才能够在枚举里面创建对象。

代码如下：

public class Text {
    public static void main(String[] args) {
        E e1 = E.CAT;
        E e2 = E.DOG;

        e1.go();
        e2.go();
    }
}
enum E {
    CAT("小猫"){
        @Override
        public void go() {
            System.out.println(getName()+"优雅地走");
        }
    },DOG("傻狗"){
        @Override
        public void go() {
            System.out.println(getName()+"狂跑");
        }
    };

    private String name;
    public abstract void go();

    E(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

        对以上代码简单分析一下，首先枚举里面有一个有参数的构造器，只能用这个构造器来创建对象了，发现枚举里面还有一个抽象方法，如果没有重写这个方法是不能创建对象的，所以在创建对象的时候需要重写方法，这个方式跟匿名内部类很相识的，需要区别开来。重写完方法后，就可以创建对象了，用E的类型变量去接收这些对象。

反编译观察CAT这个类：

       1.5对抽象枚举小结

        枚举如果有定义抽象方法的话，这个就是抽象枚举了。如果这时候创建对象的时候没有去抽象方法进行重写，创建对象就会失败。

---

---