手册   游戏   WEB   字典   单词   在线工具  

简单看看 java 之枚举

枚举类这个类用的比较少, 对这个不怎么熟悉, 最近看源码刚好可以好好了解一下, 那么, 枚举 Enum 是什么呢? 在 jdk 中, Enum 是一个抽象类下图所示, 这就说明这个类是不能进行实例化的, 那么我们应该怎么使用呢?

1. 枚举类的基本使用

简单的使用一下(随便借用的一个栗子), 我们可以直接把枚举类当作一个常量一样来使用这个类, 那么问题来了, 下面的这个枚举类和上面说的那么 Enum 抽象类是什么关系呢?

肯定是继承啊, 这里很像 Cglib 动态代理, 但肯定不是代理... 反正下面这个类经过编译, 就会编译出两个字节码文件, 一个是 TestEnum 类. 另外一个就是 Week 类(这个类自动继承 Enum 抽象类);

  1. public class TestEnum{
  2.     public static void main(String[] args) {
  3.         System.out.println(Week.MON);
  4.     }
  5. }
  6. // 这个枚举也可以放在 TestEnum 里面, 充当一个静态内部类
  7. enum Week{
  8.         MON,TUE,WED,THU,FRI,SAT,SUN
  9.     }

我们可以反编译一下看看 Week 类中到底是些什么东西;

  1. // Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.
  2. // Jad home page: http://www.kpdus.com/jad.html
  3. // Decompiler options: packimports(3)
  4. // Source File Name:   TestEnum.java
  5. // 自动的将枚举类 Week 继承 Enum
  6. final class Week extends Enum{
  7.     public static final Week MON;
  8.     public static final Week TUE;
  9.     public static final Week WED;
  10.     public static final Week THU;
  11.     public static final Week FRI;
  12.     public static final Week SAT;
  13.     public static final Week SUN;
  14.     private static final Week $VALUES[];
  15.   // 静态代码块中会实例化七个对象和一个 Week 数组, 用于存放这些实例化对象
  16.      static {
  17.         MON = new Week("MON", 0);
  18.         TUE = new Week("TUE", 1);
  19.         WED = new Week("WED", 2);
  20.         THU = new Week("THU", 3);
  21.         FRI = new Week("FRI", 4);
  22.         SAT = new Week("SAT", 5);
  23.         SUN = new Week("SUN", 6);
  24.         $VALUES = (new Week[] {
  25.             MON, TUE, WED, THU, FRI, SAT, SUN
  26.         });
  27.     }
  28.      // 构造器
  29.     private Week(String s, int i){
  30.         super(s, i);
  31.     }
  32.     // 生成静态方法 values, 克隆一份数组, 也就是调用这个方法之后就会返回一份包括枚举类中所有实例的数组
  33.     public static Week[] values(){
  34.         return (Week[])$VALUES.clone();
  35.     }
  36.     // 生成静态方法 valueOf, 通过指定一个枚举类型和实例的名称(字符串), 可以转化为一个该枚举类型的对象
  37.     public static Week valueOf(String s){
  38.         return (Week)Enum.valueOf(Week, s);
  39.     }
  40. }

可以看到 Enum 虽然我们用的时候是用 Enum 来声明的, 但是实际上就是一个类, 是为了让我们用起来方便简洁, 才这样设计的(虽然我还是觉得枚举很怪...);

2. 看看 Enum 抽象类

我们发现生成的 Week 类中构造器会调用父类的构造器, 其中 i 表示每个实例在数组中的位置, 还有 values 和 valueof 方法也会调用父类的方法, 我们看看父类所有方法实现, 然后再回头看看就清楚了;

  1. package java.lang;
  2. import java.io.Serializable;
  3. import java.io.IOException;
  4. import java.io.InvalidObjectException;
  5. import java.io.ObjectInputStream;
  6. import java.io.ObjectStreamException;
  7. // 这是一个抽象类, 只能被继承
  8. public abstract class Enum<E extends Enum<E>> implements Comparable<E>, Serializable {
  9.     // 枚举类中的实例名称
  10.     private final String name;
  11.     // 获取实例名称
  12.     public final String name() {
  13.         return name;
  14.     }
  15.     // 该实例在实例数组中的位置
  16.     private final int ordinal;
  17.     // 获取该实例所在位置
  18.     public final int ordinal() {
  19.         return ordinal;
  20.     }
  21.     // 此构造器只能由子类自己调用, 我们是不能调用, 看到子类 Week 中的构造器中的 super(s, i);
  22.     protected Enum(String name, int ordinal) {
  23.         this.name = name;
  24.         this.ordinal = ordinal;
  25.     }
  26.     // 输出实例名称
  27.     public String toString() {
  28.         return name;
  29.     }
  30.     // 重写 equal 方法和 hashcode 方法, 由于枚举类中都是对象, 那么比较的肯定就是引用是不是一样了
  31.     public final boolean equals(Object other) {
  32.         return this==other;
  33.     }
  34.     public final int hashCode() {
  35.         return super.hashCode();
  36.     }
  37.     // 克隆, 这里会直接报错, 子类中调用的是 Object 中的 clone 方法
  38.     protected final Object clone() throws CloneNotSupportedException {
  39.         throw new CloneNotSupportedException();
  40.     }
  41.     // 比较一个枚举类中实例名称的前后顺序
  42.     public final int compareTo(E o) {
  43.         Enum other = (Enum)o;
  44.         Enum self = this;
  45.         if (self.getClass() != other.getClass() &&
  46.             self.getDeclaringClass() != other.getDeclaringClass())
  47.             throw new ClassCastException();
  48.         return self.ordinal - other.ordinal;
  49.     }
  50.     // 获取枚举实例的 Class 对象和父类的 Class 对象, 然后判断是不是一个对象, 我也不知道干嘛用的
  51.     public final Class<E> getDeclaringClass() {
  52.         Class clazz = getClass();
  53.         Class zuper = clazz.getSuperclass();
  54.         return (zuper == Enum.class) ? clazz : zuper;
  55.     }
  56.     // 这个方法就是当存在多个枚举类的时候, 每个枚举类都有各自对应的多个实例, 这个方法就是将
  57.     // 根据对应的枚举类的类型, 该枚举类中的实例名称, 以此来返回该枚举类型的对象
  58.     public static <T extends Enum<T>> T valueOf(Class<T> enumType,String name) {
  59.         T result = enumType.enumConstantDirectory().get(name);
  60.         if (result != null)
  61.             return result;
  62.         if (name == null)
  63.             throw new NullPointerException("Name is null");
  64.             throw new IllegalArgumentException(
  65.             "No enum constant" + enumType.getCanonicalName() + "." + name);
  66.     }
  67.     // 最没用的方法, Object 中也有
  68.     protected final void finalize() { }
  69.     // 这两个方法不知道干嘛用的... 都会直接抛异常
  70.     private void readObject(ObjectInputStream in) throws IOException,ClassNotFoundException {
  71.         throw new InvalidObjectException("can't deserialize enum");
  72.     }
  73.     private void readObjectNoData() throws ObjectStreamException {
  74.         throw new InvalidObjectException("can't deserialize enum");
  75.     }
  76. }

这个抽象类方法也不是很多, 很容易, 现在再来看看枚举类应该就很容易了;

我们理一下思路: 当我们在一个平常的类中使用了枚举类的话, 而且这个枚举类中定义了很多个实例, 那么在使用的时候就会将枚举类拿出来和类分开编译, 这个枚举类中的多个实例 (这里每个实例都有自己的数组下标) 都给实例化出来, 并且放到一个实例数组中; 其中每个枚举类都会自动继承 Enum 这个抽象类, 我们可以根据对应的枚举类来获取每个实例的对象, 当然枚举类可能也有多个, 那么也可以根据 Enum 这个抽象类来获取对应枚举类中的实例, 并转化为该枚举类的类型返回...

原理就这么多吧! 下面来看看枚举类的一些其他用法;

3. 枚举类的简单用法

首先, 枚举类可以实现接口:

  1. public interface MyEnum {
  2.     public void say();
  3. }
  4. // 实现接口
  5. public enum TestEnum implements MyEnum{
  6.     // 注意,
  7.     MON, TUE, WED, THU, FRI, SAT, SUN;
  8.     @Override
  9.     public void say() {
  10.         System.out.println("實現接口 --------say");
  11.     }
  12.     public static void main(String[] args) {
  13.         TestEnum.MON.say();
  14.     }
  15. }

然后在枚举类中还能有一些属性, 以及 set/get 方法;

  1. package com.wyq.test;
  2. public enum TestEnum implements MyEnum{
  3.     // 注意, 这里最后要加分号
  4.     MON("mon",12), TUE("tue",12), WED("wed",12), THU("thu",12);
  5.     private String name;
  6.     private Integer age;
  7.     private TestEnum(String name, Integer age) {
  8.         this.name = name;
  9.         this.age = age;
  10.     }
  11.     public String getName() {
  12.         return name;
  13.     }
  14.     public void setName(String name) {
  15.         this.name = name;
  16.     }
  17.     public Integer getAge() {
  18.         return age;
  19.     }
  20.     public void setAge(Integer age) {
  21.         this.age = age;
  22.     }
  23.     @Override
  24.     public void say() {
  25.         System.out.println("实现接口 --------say");
  26.     }
  27.     public static void main(String[] args) {
  28.         System.out.println(TestEnum.MON.getName()+TestEnum.MON.getAge());
  29.     }
  30. }

4. 总结

反正枚举类用的比较少, 我就在那个单例模式下用过(天生的单例), 至于其他的地方暂时用的比较少, 不过当需要用的时候我们一定要会用啊;

简单的看了看源码之后, 其实再回头看看枚举类, 其实就跟我们平常用的类差不多, 不可以继承(因为默认已经继承了 Enum 类了), 可以有自己的属性, 方法, 也可以覆盖父类的方法(可以自己试试), 就跟平常类一样的使用! 就是写法略怪, 习惯就好!!!

话说昨天下午弄了好久, 终于被我找到在博客园配置出了血小板看板娘了, 哈哈哈, 我现在声明一句: 血小板就是我老婆, 不接受反驳! 嘿嘿嘿 @_@

来源: https://www.cnblogs.com/wyq1995/p/11119397.html


与本文相关文章

  1. java 之 ------ 枚举类型
  2. java 枚举学习笔记二
  3. [Java 提高] --- 枚举的应用
  4. 关于 JAVA 枚举
  5. 重新认识 java(十) ---- Enum(枚举类)
  6. 浅谈 Java 中的枚举
  7. java环境变量设置 Java 2：枚举
  8. Java(enum) 枚举用法详解
暂无,快来抢沙发吧！
更多





黑ICP备17005318号-1