java 枚举原理

最新推荐文章于 2024-08-11 07:45:00 发布
最新推荐文章于 2024-08-11 07:45:00 发布
阅读量1.2k 收藏 1
点赞数
分类专栏： javaSE

　　每个枚举的成员其实就是您定义的枚举类型的一个实例（Instance）——换句话说，当定义了一个枚举类型后，在编译时刻就能确定该枚举类型有几个实例，分别是什么，在运行期间我们无法在使用该枚举类型创建新的实例了，这些实例在编译期间就已经完全确定下来了。

枚举的实际工程用处：在有限个选择项的环境中，如权限限制有系统管理员、管理员、vip用户、普通用户等，使用枚举

       我们回忆下所知道的java中的数据类型，java中的数据类型可以分为基本数据类型和引用数据类型。基本数据类型代表的是一种简单的数据结构，比如说我们经常所说的整型，浮点型，字符型，布尔型等。而在java当中有一种特殊的数据类型，我们叫做引用数据类型，而引用数据类型一共有四种，略懂java的人是知道的，这四种分别是类、数组、接口以及今天我要重点讲述的枚举。关于其他三种数据类型有机会我们再在一起讨论。

　　那么到底什么是枚举，枚举的作用是什么呢？枚举类型最主要的作用是限定类型的取值。那么我们来看一个例子！

　　我们首先要定义一个类，这个类是人类，非常简单！

　　public class Person{

　　}
　　就可以了，那么我们知道，类是用来描述一组具有相同属性（域）和方法的一个抽象。那么我们都应该清楚每一个人类的对象，也就是说每个人类的具体个体都具有相同的一些属性，比如说姓名，年龄等。那么我们就可以在以上类当中加入相应的属性。 

　　public class Person{
　　//名字
　　private String name;
　　//年龄
　　private int age;
　　}
　 　这里都比较容易理解，那么我们去看另外一个属性，这个属性我们叫做性别，总所周知，这个属性的取值只有两种，那么有和我较劲的同学不要提人妖这回事，人妖忽略。那么我们会发现，性别这个属性既然只有两个值，那么我们应该给这个属性定义为什么类型呢！有的同学说随便啊，比如说String类型就可以啊！那么我们来看一下，如果把性别属性定义为String类型会出现什么状况。 
　　public class Person{
　　//名字
　　private String name;
　　//年龄
　　private int age;
　　//性别
　　private String sex;
　　//构造器
　　public Person(String name,int age,String sex){
　　this.name = name;
　　this.age = age;
　　this.sex = sex;
　　}
}
　 　上面的例子我们看到，我添加了一个属性是性别，之后加入一个构造器，构造器最主要的作用是通过类来创建对象，上面的构造器是说当你创建一个人类对象的时候需要知道这个人的名字，年龄，以及性别。好了，那么我们来创建一个人类的对象，语法非常简单！
　　Person p = new Person(“杨过”,32,”男”);
　　我们一看，这是没有任何问题的，我们抛开名字和年龄不说，只看他的性别。
　　Person这个类我们会发现，创建这个类的对象的时候构造器的第三个参数只要是字符串就可以了，那么我们可以不可以这么写。
　　Person p = new Person(“杨过”,32,”大家好”);
　　这句话在语法上我们看有错吗？答案是没有，因为构造器的第三个参数就是字符串，那么我传一个字符串给构造器当然一点问题都没有。虽然语法上没有任何问题，但是我们看这个对象在创建上是不合理的，为什么呢？因为性别只有男和女之分，不能有其他的！有聪明的人已经想到了，那么我们可以把sex性别这个属性定义为boolean类型啊！因为boolean类型只有两个取值，那么我们传参的时候就可以穿true或者false，用true代表男人，用false代表女人，那么可以不可以？当然没问题，可是为题是为什么要用true代表男人，不用true代表女人啊！你会想到其实无所谓了true代表谁都可以，只要之前我们有一个规定就可以了！可逆会发现true和false根本就没有直观性！那么这么多问题，我们到底要怎么解决呢！
　　在枚举类型之前，java程序员的解决此类限定类型的值的时候用了一个非常巧妙的方法！他想到了新定义一个类型，这个类型只有两个值，这两个值，一个是男一个是女。那么怎么才能做到呢！好，我们先定义一个类型，怎么定义类型！我们说过类就是一种引用类型，那么引用类型的值是什么，之前我们讲过那就是对象。好了，我们现在要做的是创建一个类，这个类只能创建两个对象！ 
　　public class Sex{

　　}

　　首先我们要考虑，这个类只能创建两个对象，我们会想到我们之前学过的单例设计模式中，要求一个类只能创建一个对象。这其实是一个道理的。我们要考虑创建对象要用到构造器，那么构造器不可能是public 的，如果构造器是public那么我们就可以创建无数个对象。好了，那么我们在上面的类当中加入构造器，这个构造器一定是私有的。 

　　public class Sex{
　　private Sex(){
　　}
　　}
　　 那么我们可以在这个类中加入属性。 
　　public class Sex{
　　private String sex;
　　public static final Sex MALE = new Sex(“男”) ;
　　public static final Sex FEMALE = new Sex(“女”);
　　private Sex(String sex){
　　this.sex = sex;
　　}
　　}
　　 关于这个例子我们可以看到，这个类只有两个对象，这两个对象分别是Sex类中的两个属性。
　　之后我们可以将我们Person这个类的例子稍做修改。 
　　public class Person{
　　private String name; //名字
　　private int age; //年龄
　　private Sex sex; //性别
　　//构造器
　　public Person(String name,int age,Sex sex){
　　this.name = name;
　　this.age = age;
　　this.sex = sex;
　　}
　　}
　 　这个时候，我们创建这个对象的时候，如何创建呢？非常简单。 
　　Person p = new Person(“杨过”,32,new Sex(“男”));
　　 我们看可以吗？
　　很明显是不可以的，因为Sex构造器是私有的，怎么办，Person构造器的第三个参数又需要Sex类型，到这里我们会发现，Sex类型的值只有两个分别是在Sex类中是静态的常量而且是公有的，那就好办了！我们可以通过这种方式创建对象！ 
　　Person p = new Person(“杨过”,32,Sex.MALE);
　 　这个时候我们就可以看到这个人是个男人，因为我们知道male在Sex类中定义为男人！而且应为也是男人的意思！有直观又方便，那么有人说，我想看看他到底是男人还是女人怎么办！
　　你会想到，把属性打印出来就可以了！ 
　　System.out.println(p.sex);
　 　这个时候，打印的是这个对象的hashCode，我们只要在Sex类中加入toString方法就可以了！

　　到这里，我们会发现人类中有一个sex属性，这个属性是Sex类型的，而且这个属性只有两个取值。那么以后我们在遇到这种限定类型的时候就可以用这种方法。比如说血型等。
　　那么我们说了半天还没谈到枚举呢！其实在上面的文字中，我们已经不知不觉阐述了枚举的原理！枚举就是将新的类型做一个限定。我们来创建一个枚举。
 
　　public enum Sex{
　　MALE(“男”),FEMALE(“女”);
　　}
　　这就是枚举，这里是将Sex所有可能的取值都列举到这个枚举中，如果一个属性定义为枚举类型，只能到这个枚举中区寻找他的值！好了，我们改一下！
 
　　public class Person{ 
　　private String name; //名字
　　private int age; //年龄
　　private Sex sex; //性别
　　//构造器
　　public Person(String name,int age,Sex sex){
　　this.name = name;
　　this.age = age;
　　this.sex = sex;
　　}
　　}

　　创建对象的时候，同样Person p = new Person(“杨过”,32,Sex.MALE);就可以，这就是枚举！当然枚举还有很多东西需要大家去学习，但今天就说到这了，等有机会再深一步的去讲解！


——————————————————————使用枚举与不使用枚举（模拟枚举）代码对比————————————————————————————

上一篇：Java学习整理系列之Java枚举类型的使用http://blog.csdn.net/sup_heaven/article/details/35295851
本以为RED只是一个Color类的一个static final的实例而已。但后然发现不是这样的，先看看下面的一种枚举类型使用的代码。

package com.lxq.enumm;  
  
public enum Color  
{  
    RED{  
        public String getName(){  
            return "红色";  
        }  
    }  
    ,GREEN{  
        public String getName(){  
            return "绿色";  
        }  
    }  
    ,YELLOW{  
        public String getName(){  
            return "黄色";  
        }  
    };  
    public abstract String getName();  
}


如果RED只是一个Color类的一个static final的实例，那么上面的代码就很让了费解了，为什么在枚举类型中可以有一个抽象方法，而每个枚举值可以对其重新实现？
别急，看了我对这个类的测试代码你就明白，测试代码如下： 

import java.lang.reflect.Modifier;  
  
public class EnumDemoFour{  
    public static void main(String[] args){  
        //打印该枚举值的名称  
        System.out.println(Color.RED.getName());  
        //打印该枚举值的类  
        System.out.println(Color.RED.getClass());  
        //打印该枚举值的类的父类  
        System.out.println(Color.RED.getClass().getSuperclass());  
        //打印该枚举值的类的父类的父类  
        System.out.println(Color.RED.getClass().getSuperclass().getSuperclass());  
        //打印该枚举类型的修饰符  
        System.out.println(Modifier.toString(Color.class.getModifiers()));  
    }     
    /*运行结果 
    红色 
    class com.lxq.enumm.Color$1 
    class com.lxq.enumm.Color 
    class java.lang.Enum 
    public abstract*/  
}
该运行结果首先说明了RED和Color不是同一个类，而是前者是后者的一个子类；同时也说明了enum申明的其实是一个abstract的类，所以Color中可以有抽象方法。
那么，我们应该这么理解枚举类型的原理，首先enum Color继承了java.lang.Enum这个抽象类，但enum Color还是一个抽象类，所以它可以有抽象方法和非抽象方法。
而enum Color中的枚举值变量RED事实上上Color的一个匿名子类，所以它可以实现Color中的抽象方法，这样，当我们调用System.out.println(Color.RED.getName());
就是调用了匿名子类实现的方法。当然这些过程的很多事都有编译器等为我们做了，所以这里的代码很简单。
要是你不明白上面打印的内容，我再提供一个普通的类给你看看，还是类似的效果哦。 

public abstract class TestInnerClass  
{  
    public abstract void dosomething();  
    public static void main(String[] args){  
        TestInnerClass tic=new TestInnerClass(){  
            @Override  
            public void dosomething()  
            {  
                System.out.println("我是匿名子类");  
            }     
        };  
        tic.dosomething();  
        System.out.println(tic.getClass());  
    }  
    /*输出结果 
    我是匿名子类 
    class TestInnerClass$1 
    */  
}

最后再附上网上一个使用Java普通类模拟枚举的例子http://blog.csdn.net/xyang81/article/details/7185428，这个例子真的很好。
使用Java普通类模拟枚举 
import java.util.HashMap;  
import java.util.Map;  
  
/** 
 * 模拟星期中的表示的天，每个星期天都表示一个对象 
 * 1、类中的每一个枚举成员都是该类的一个实例对象 
 * 2、构造函数私有化 
 * 3、提供操作枚举成员的抽象方法和静态方法 
 */  
public abstract class WeekDate {  
    /** 
     * 星期一 
     */  
    public static final WeekDate MON = new WeekDate("MON",0) {//匿名子类  
        @Override  
        public WeekDate nextDay() {  
            return TUES;  
        }  
        @Override  
        public WeekDate preDay() {  
            return SUN;  
        }  
        @Override  
        public String toString() {  
            return "WeekDate.MON";  
        }  
    };    
      
    /** 
     * 星期二 
     */  
    public static final WeekDate TUES = new WeekDate("TUES",1) {  
        @Override  
        public WeekDate nextDay() {  
            return WEDNES;  
        }  
        @Override  
        public WeekDate preDay() {  
            return MON;  
        }  
        @Override  
        public String toString() {  
            return "WeekDate.TUES";  
        }  
    };  
      
    /** 
     * 星期三 
     */  
    public static final WeekDate WEDNES = new WeekDate("WEDNES",2) {  
        @Override  
        public WeekDate nextDay() {  
            return THURS;  
        }  
        @Override  
        public WeekDate preDay() {  
            return TUES;  
        }  
        @Override  
        public String toString() {  
            return "WeekDate.WEDNES";  
        }     
    };  
      
    /** 
     * 星期四 
     */  
    public static final WeekDate THURS = new WeekDate("THURS",3) {  
        @Override  
        public WeekDate nextDay() {  
            return FRI;  
        }  
        @Override  
        public WeekDate preDay() {  
            return WEDNES;  
        }         
        @Override  
        public String toString() {  
            return "WeekDate.THURS";  
        }         
    };  
      
    /** 
     * 星期五 
     */  
    public static final WeekDate FRI = new WeekDate("FRI",4){  
        @Override  
        public WeekDate nextDay() {  
            return SATUR;  
        }  
        @Override  
        public WeekDate preDay() {  
            return THURS;  
        }  
        @Override  
        public String toString() {  
            return "WeekDate.FRI";  
        }  
    };  
      
    /** 
     * 星期六 
     */  
    public static final WeekDate SATUR = new WeekDate("SATUR",5){  
        @Override  
        public WeekDate nextDay() {  
            return SUN;  
        }  
        @Override  
        public WeekDate preDay() {  
            return FRI;  
        }         
        @Override  
        public String toString() {  
            return "WeekDate.SATUR";  
        }         
    };  
      
    /** 
     * 星期日 
     */  
    public static final WeekDate SUN = new WeekDate("SUN",6){  
        @Override  
        public WeekDate nextDay() {  
            return MON;  
        }  
        @Override  
        public WeekDate preDay() {  
            return SATUR;  
        }  
        @Override  
        public String toString() {  
            return "WeekDate.SUN";  
        }  
    };  
      
    private static Map<String, WeekDate> valueMap = new HashMap<String, WeekDate>();  
      
    /** 
     * 枚举名称 
     */  
    private final String name;  
      
    /** 
     * 枚举成员的顺序 
     */  
    private final int ordinal;  
      
    private WeekDate(String name,int ordinal) {  
        this.name = name;  
        this.ordinal = ordinal;  
    }  
      
    /** 
     * 保存枚举成员 
     */  
    private static WeekDate[] values = {  
        MON,TUES,WEDNES,THURS,FRI,SATUR,SUN  
    };  
      
    //初始化  
    static {  
        valueMap.put("MON", values[0]);  
        valueMap.put("TUES", values[1]);  
        valueMap.put("WEDNES", values[2]);  
        valueMap.put("THURS", values[3]);  
        valueMap.put("FRI", values[4]);  
        valueMap.put("SATUR", values[5]);  
        valueMap.put("SUN", values[6]);  
    }  
      
    /** 
     * 下一天 
     * @return 
     */  
    public abstract WeekDate nextDay();  
      
    /** 
     * 前一天 
     * @return 
     */  
    public abstract WeekDate preDay();  
      
    /** 
     * 枚举中的所有成员 
     * @return 
     */  
    public static WeekDate[] values() {  
        return values;  
    }  
      
    /** 
     * 将一个字符串转换成一个枚举成员对象 
     * @param name 枚举名称 
     * @return 枚举对象 
     */  
    public static WeekDate valueOf(String name) {  
        if (name.equalsIgnoreCase("MON")) {  
            return MON;  
        } else if (name.equalsIgnoreCase("TUES")) {  
            return TUES;  
        } else if (name.equalsIgnoreCase("WEDES")) {  
            return WEDNES;  
        } else if (name.equalsIgnoreCase("THURS")) {  
            return THURS;  
        } else if (name.equalsIgnoreCase("FRI")) {  
            return FRI;  
        } else if (name.equalsIgnoreCase("SATUR")) {  
            return SATUR;  
        } else if (name.equalsIgnoreCase("SUN")) {  
            return SUN;  
        } else {  
            throw new IllegalArgumentException("找不到" + name + "枚举类型！");  
        }  
    }  
      
    /** 
     * 优化字符串转枚举对象 
     * @param name 枚举名称 
     * @return 枚举对象 
     */  
    public static WeekDate valueOf_2(String name) {  
        WeekDate value = valueMap.get(name.toUpperCase());  
        if (value == null) {  
            throw new IllegalArgumentException("找不到" + name + "枚举类型！");  
        }  
        return value;  
    }  
    public String getName() {  
        return name;  
    }  
    public int getOrdinal() {  
        return ordinal;  
    }  
}

使用JDK5.0中提供的枚举特性 

/** 
 * 枚举的应用 
 * 存储每周中的天份 
 */  
public enum WeekDateEnum {  
  
    MON {  
          
        @Override  
        public WeekDateEnum nextDay() {  
            return TUES;  
        }  
          
        @Override  
        public WeekDateEnum preDay() {  
            return SUN;  
        }  
          
    },  TUES {  
          
        @Override  
        public WeekDateEnum nextDay() {  
            return WEDNES;  
        }  
          
        @Override  
        public WeekDateEnum preDay() {  
            return MON;  
        }  
          
    },  WEDNES {  
          
        @Override  
        public WeekDateEnum nextDay() {  
            return THURS;  
        }  
          
        @Override  
        public WeekDateEnum preDay() {  
            return TUES;  
        }  
          
    },  THURS {  
          
        @Override  
        public WeekDateEnum nextDay() {  
            return FRI;  
        }  
          
        @Override  
        public WeekDateEnum preDay() {  
            return WEDNES;  
        }  
          
    },  FRI {  
          
        @Override  
        public WeekDateEnum nextDay() {  
            return SATUR;  
        }  
          
        @Override  
        public WeekDateEnum preDay() {  
            return THURS;  
        }  
          
    },  SATUR {  
          
        @Override  
        public WeekDateEnum nextDay() {  
            return SATUR;  
        }  
          
        @Override  
        public WeekDateEnum preDay() {  
            return FRI;  
        }  
          
    },  SUN {  
          
        @Override  
        public WeekDateEnum nextDay() {  
            return SATUR;  
        }  
          
        @Override  
        public WeekDateEnum preDay() {  
            return MON;  
        }  
          
    };  
  
    private WeekDateEnum() {}  
      
    /** 
     * 下一天 
     * @return 
     */  
    public abstract WeekDateEnum nextDay();  
      
    /** 
     * 前一天 
     * @return 
     */  
    public abstract WeekDateEnum preDay();  
      
    /** 
     * 枚举对象公共的toString方法，可以在case块中反馈自己想要返回的信息 
     */  
    public String toString() {  
        switch (this) {  
        case MON:  
            return "WeekDateEnum.MON";  
        case TUES:  
            return "WeekDateEnum.TUES";  
        case WEDNES:  
            return "WeekDateEnum.WEDNES";  
        case THURS:  
            return "WeekDateEnum.THURS";  
        case FRI:  
            return "WeekDateEnum.FRI";  
        case SATUR:  
            return "WeekDateEnum.SATUR";  
        case SUN:  
            return "WeekDateEnum.SUN";  
        default:  
            return null;  
        }  
    }  
}

枚举功能测试 

/** 
 * 枚举功能测试 
 */  
public class EnumTest {  
  
    public static void main(String[] args) {  
          
        //使用普通JAVA类模拟枚举的应用  
        WeekDate weekDate = WeekDate.MON;       //获得一个枚举对象  
        //调用枚举中提供的方法  
        System.out.println(weekDate.nextDay());   
        System.out.println(weekDate.preDay());  
        System.out.println(weekDate.getName());  
        //获得枚举成员所在枚举成员列表中的位置  
        System.out.println(weekDate.getOrdinal());  
        //调用某一个枚举成员的方法  
        System.out.println(WeekDate.values()[0].preDay());  
        System.out.println("---------------遍历枚举成员,普通JAVA类模拟--------------------------");  
        for (WeekDate weekDate2 : WeekDate.values()) {  
            System.out.println(weekDate2);  
        }  
          
        System.out.println("\n=================================================================\n");  
          
        //使用JDK中提供的枚举特性功能应用  
        WeekDateEnum weekDateEnum = WeekDateEnum.MON;   //获得一个枚举对象  
        System.out.println(WeekDate.values().length);   //获得枚举成员数量  
        System.out.println(weekDateEnum.name());        //获得枚举的字符串名称  
        System.out.println(weekDateEnum.toString());    //打印枚举对象，已重写toString方法，默认打印枚举的名称  
        System.out.println(weekDateEnum.nextDay().ordinal());   //枚举成员列表中的位置  
        System.out.println(WeekDateEnum.valueOf("FRI").nextDay().ordinal());  
        System.out.println("---------------遍历枚举成员，使用JDK的枚举特性-------------------------");  
        for (WeekDateEnum enumDemo : WeekDateEnum.values()) {  
            System.out.println(enumDemo);  
        }  
          
    }   
      
}


转载自：http://bbs.tianya.cn/post-414-50056-1.shtml

                  http://blog.csdn.net/sup_heaven/article/details/35559117

详情参考：http://blog.csdn.net/sup_heaven/article/details/35559117

Coding-lover
关注
专栏目录
深入浅出 Java 中枚举的实现原理
weixin_44433834的博客
12-14 428
作者：幻好 来源：恒生LIGHT云社区 Java 中的枚举— Enum 的全称为 Enumeration， 在 JDK 1.5 时就引入的特性，通过 java.lang 包中调用。 基本概述 在 JDK1.5 之前，通过定义常量使用的都是：public static fianl。而枚举的设计，就是把相关的常量分组到一个枚举类型里，方便创建和管理。 比如我们要定义一个颜色常量： public enum Colour { RED, YELLOW, BLUE, GREEN } 这段代码通过底层编.
java枚举类型的实现原理
热门推荐
痴人说梦
08-29 2万+
Java从JDK1.5开始支持枚举，也就是说，Java一开始是不支持枚举的，就像泛型一样，都是JDK1.5才加入的新特性。通常一个特性如果在一开始没有提供，在语言发展后期才添加，会遇到一个问题，就是向后兼容性的问题。像Java在1.5中引入的很多特性，为了向后兼容，编译器会帮我们写的源代码做很多事情，比如泛型为什么会擦除类型，为什么会生成桥接方法，foreach迭代，自动装箱/拆箱等，这有个术语叫
Java枚举详解：从基础到高级应用
最新发布
xycxycooo的博客
08-11 1107
在Java中，枚举通过enum关键字定义。枚举常量是枚举类型的实例，通常使用大写字母表示。Java枚举是一种强大且灵活的数据类型，通过合理使用枚举，可以提高代码的可读性、安全性和可维护性。本文详细介绍了枚举的概念、定义、使用方法以及高级应用，并通过实际案例展示了枚举的使用场景。希望本文能为读者在Java枚举的学习和应用方面提供有益的参考和启发，帮助读者编写出更清晰、更高效的代码。
Java之枚举的原理
ting说你跳？
08-09 286
转载自：Java 枚举型为什么是静态的，以及是怎么实现的？中的一个回答Java枚举型是静态常量，隐式地用static final修饰过。 确切地说，Java枚举型是“静态常量”，这里面包含了两层意思： 1.枚举型中的实例隐式地用static final修饰过。 2.枚举型作为某个类中的成员字段也隐式地用static final修饰过。public class Traffic { pub
轻松入门枚举类Enum源码
旅途
06-29 509
一、源码解读 public abstract class Enum<E extends Enum<E>> implements Comparable<E>, Serializable { /** * 枚举常量的名称 * 使用toString方法访问此字段。 */ private final String name; ...
enum java 原理_java中枚举实现原理
weixin_42467088的博客
02-16 155
介绍枚举是java5新增的特性，我们可以用来替代以前用常量完成的功能。java对枚举的支持还有EnumSet,EnumMap等工具类。使用public enum UserGenderEnum {MALE("0", "男"),FEMALE("1", "女"),NOT_KNOWN("2", "未知");private final String code;private final String inf...
"深入探讨Java枚举原理与应用技巧PPT
感谢观赏本次关于Java枚举的PPT。在本次PPT中，我们详细介绍了Java枚举的定义、用法、常用方法以及实现接口的方式等内容。以下是对本次PPT的详细总结： Java枚举是一系列常量的集合。枚举的含义既可以是列举，也...
Java EnumSet工作原理初窥
12-22
EnumSet是Java枚举类型的泛型容器，Java既然有了SortedSet、TreeSet、HashSet等容器，为何还要多一个EnumSet呢？答案肯定是EnumSet有一定的特性，举个例子，EnumSet的速度很快。其他特性不一一列举了，毕竟本文的...
Java面试枚举从使用到原理
10-24
本篇文章将深入探讨Java枚举的使用及其背后的原理。 一、枚举的定义与使用 1. 基本用法： 在Java中，枚举可以通过`enum`关键字来创建。例如，我们可以定义一个表示一周七天的枚举类型： ```java public enum ...
Java枚举类接口实例原理解析
08-25
Java 枚举类接口实例原理解析 Java 枚举类接口实例原理解析是 Java 编程语言中的一种重要概念。枚举类是一种特殊的类，它可以实现一个或多个接口。枚举类的实现接口时，需要实现该接口所包含的方法。如果需要每个...
java枚举 数字_java 枚举
weixin_36152824的博客
02-26 1203
Java中枚举的线程安全性及序列化问题--枚举是如何保证线程安全的要想看源码，首先得有一个类吧，那么枚举类型到底是什么类呢？是enum吗？答案很明显不是，enum就和class一样，只是一个关键字，他并不是一个类，那么枚举是由什么类维护的呢，我们简单的写一个枚举：然后我们使用反编译，看看这段代码到底是怎么实现的，反编...文章java填坑路2018-08-051238浏览量Java基础15：深入剖...
枚举
Dear_mango的博客
05-24 419
枚举类型是Java 5中新增特性的一部分，它是一种特殊的数据类型，之所以特殊是因为它既是一种类(class)类型却又比类类型多了些特殊的约束，但是这些约束的存在也造就了枚举类型的简洁性、安全性以及便捷性。下面先来看看什么是枚举？如何定义枚举？枚举的定义回忆一下下面的程序，这是在没有枚举类型时定义常量常见的方式/** * Created by zejian on 2017/5/7. * Blog...
Java枚举原理
Creepin_的博客
04-01 340
枚举的基本创建 public enum Color { RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4); //定义枚举实例 // 自定义成员变量 private String name; private int index; // 定义构造方法 pri...
Java枚举类的原理
天上飞的云传奇
03-10 344
学设计模式的时候，看到了单例模式，之前一直都是懒汉模式，饿汉模式，静态嵌套类。没想到还有一个枚举实现的单例。 枚举类的原理 package ThreeYue; enum Day { MONDAY,TUESDAY,WEDNESDAY } public class Study310 { public static void main(String[] args) { Day day = Day.MONDAY; } } 1.对于枚举类 Day 编译器会自动生成一个fina
Java枚举实现原理
johnjoe's blog
03-29 230
编译枚举EnumImplMechanism.java，通过jad反编译获得EnumImplMechanism.jad文件 D:\>javac EnumImplMechanism.java D:\>jad EnumImplMechanism.class Parsing EnumImplMechanism.class... Generating EnumImplMechanism.jad ...
java 枚举的实现原理
BlueKitty的博客
12-18 469
在java中 , 枚举实际上是一个特殊的类 public enum TestEnum { VAL1, VAL2; public static void main(String[] args) { System.out.println(TestEnum.VAL1); } } 编译后内部实现的方式 //继承java.lang.Enum并声明为...
java枚举类型原理_Java 枚举类型原理简要分析
weixin_29024675的博客
02-25 192
问题：枚举是一种特殊的数据类型，一般用来列举有限个、同类型的常量。它能保证参数的安全性，如方法声明传入的参数，必须是指定枚举中的常量。但使用枚举会比使用静态变量多消耗更多的内存，那为什么枚举这么耗内存？先看下这段代码：public class TestEnumClass {public enum MyColor {red, green, blue};public static void main(...
java 实现枚举_【Java基础】Java枚举实现原理
weixin_35876682的博客
02-12 197
定义一个事物的所有值的集合。枚举类型的属性因为枚举类型所代表的是一个事物的所有值的集合，所以枚举类型应具有的属性为：枚举类型所具有的值是不可变的。具有所有的值枚举的作用限定值的范围，通常可以用来限制接口的参数的取值范围。枚举的实现原理通过使用反编译命令javap我们可以得出一下结论：编译器将枚举类型编译为final类型的class类。枚举中的每一个枚举值编译为“public static fina...
JAVA 枚举的基础和原理
sekever的博客
08-10 809
当定义一个枚举类型时，每一个枚举类型成员都可以看作是 Enum 类的实例，这些枚举成员默认都被 final、public, static 修饰，当使用枚举类型成员时，直接使用枚举名称调用成员即可。java 为每个枚举都定义了两个属性，name和ordinal，name表示我们定义的枚举常量的名称，如ADD、SUBTRACT等，而ordinal是一个顺序号，根据定义的顺序分别赋予一个整形值，从0开始，因此该枚举对象可以调用name与ordinal方法。你可以将枚举类当成一个普通的java类，为其添加方法。..
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值