枚举的基础知识点和使用情况

枚举

1.1枚举的概述

• 枚举是一个特殊的类

枚举的格式：

public enum A {
    X,Y,Z;
}

修饰符enum枚举类名{
名称1，名称2，...;
其他成员...
}
注意：枚举关键字是enum

注意：枚举类中的第一行，只能写一些合法的标识符（名称），多个名称用逗号隔开。

这些名称，本质是常量，每个常量都会记住枚举类的一个对象。

   Compiled from "A.java"
    public final class meiju.A extends java.lang.Enum<meiju.A> {
        public static final A X = new A（）;
        public static final A Y = new A（）;
        public static final A Z = new A（）;
        public static A[] values();
        public static A valueOf(java.lang.String);
        static {};
    }

• 枚举类的第一行只能罗列一些名称，这些名称都是常量，并且每个常量记住的都是枚举类的一个对象
• 枚举类的构造器都是私有的（写不写只能是私有的），因此，枚举类对外不能创建对象
• 枚举都是最终类，不可以被继承
• 枚举中，从第二行开始，可以定义类的其他各种成员
• 编译器为枚举类新增了几个方法，并且枚举类都是继承：java.lang.Enum类的，从enum类也会继承到一些方法。

底层代码：

public abstract class Enum<E extends Enum<E>>
        implements Constable, Comparable<E>, Serializable {

......
}

实现了Constable ，这个接口有一个方法describeConstable（），该方法返回一个ConstantDesc对象，该对象描述了如何将该对象转换为常量池中的形式。

Comparable方法，里面有CompareTo（）比较方法，可以返回比较结果。

Serializable接口是一个标记接口，它没有定义任何方法。实现这个接口的类表面其对象可以被序列化，即可以转换为字节流，从而可以保存到磁盘文件中或者网络上传输。

接口定义：Serializable 接口定义为空，没有方法。
作用：允许对象被序列化和反序列化。
实现方式：只需在类声明中添加 implements Serializable 即可

1.2枚举的方法

方法名	说明
String name()	获取枚举项的名称
int ordinal()	返回枚举项在枚举类中的索引值
int compareTo(E o)	比较两个枚举项，返回的是索引值的差值
String toString()	返回枚举常量的名称
static T valueOf(Class type,String name)	获取指定枚举类中的指定名称的枚举值
values()	获得所有的枚举项

package meiju;

public class Test {
    public static void main(String[] args) {
        A a = A.X;
        A b = A.Y;
        A c = A.Z;
        System.out.println(a+""+b+""+c);//XYZ
       //String name() 获取枚举项的名称
        String name = A.X.name();
        System.out.println(name);
        System.out.println(A.X.name());
        //ordinal() 获取枚举项的索引
        int ordinal = A.X.ordinal();
        System.out.println(ordinal);
        System.out.println(A.X.ordinal());
        //values() 获取枚举项的数组
        A[] values = A.values();
        for (A value : values) {
            System.out.println(value);
        }
       //compareTo() 比较两个枚举项
        int result = A.X.compareTo(A.Y);
        System.out.println(result);
        System.out.println(A.X.compareTo(A.Y));
        //toString() 获取枚举项
        String s = A.X.toString();
        System.out.println(s);
        //valueOf() 获取枚举项
        A a1 = A.valueOf("X");
        System.out.println(a1);
        System.out.println(A.valueOf("X"));
    }
}

1.3抽象枚举

枚举类也可以有抽象方法，但是枚举项必须重写该方法

package meiju;

import static java.lang.Character.getName;

public enum A {
     
    
    X(){
        public void print() {
            System.out.println("X");
        }
    },Y("李四"){
        public void print() {
            System.out.println("Y");
        }

    },Z("张三"){
        public  void print() {
            System.out.println(getName()+"Z");
        }
    };
    //抽象方法
public abstract void print();
    
private String name;
    A() {
    }
    A(String name){
   this.name=name;
    }

    public String getName() {
        return name;
    }

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

package meiju;

public class ATest {
    public static void main(String[] args) {
        A a = A.X;
        System.out.println(a);
        a.print();
        System.out.println("===================");
        A a1 = A.Y;
        System.out.println(a1);
        a1.print();
        System.out.println("===================");
        A a2 = A.Z;
        System.out.println(a2);
        a2.print();
    }
}

1.4枚举的应用场景

用来表示一组数据，然后作为参数进行传输。

选择定义一个一个的常量来表示一组信息，并作为参数传输

参数值不受约束

选择定义枚举表示一组信息，并作为参数传输

代码可读性好，参数值得到了约束，对使用者更友好，建议使用。

package meiju;



public enum A {
    BOY, GIRL;
    private String name;

    public String getName() {
        return name;
    }
}

package meiju;

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

            check(A.BOY);
                 check(A.GIRL);
    }
    public static void check(A sex){
        switch (sex){
            case BOY:
                System.out.println("男");
                break;
            case GIRL:
                System.out.println("女");
                break;
        }
    }
}

switch (sex){
case BOY:
System.out.println(“男”);
break;
case GIRL:
System.out.println(“女”);
break;
}
}
}