Enum的toString方法 - CSDN博客
Enum的toString方法
定义一个枚举型的变量(Enum)，如：
Public Enum Status&&&&&&& Initial = 0&&&&&&& Process = 1&&&&&&& Finished = 2End Enum
如果使用Dim strValue As String = Status.Initial.toString()
得到的strValue的值为&Initial&，从这个方面来说上面这句话与
Dim strValue As String = Status.Initial.toString(&G&)等价。
而我们时常需要得到的是枚举型数据对应的值，也就是当我们使用Status.Initial的时候，往往希望得到的是0。
要得到值，应该这样写：
Dim strValue As String = Status.Initial.toString(&D&)
或者使用强制转换
CStr(Status.Initial)也可以达到相同的效果。
用Reflector看了一下Enum.toString()的具体实现，看不懂。请高手指点一下，感激不尽！
具体的实现代码是：
public override string ToString()
Type type1 = base.GetType();
FieldInfo info1 = Enum.GetValueField(type1);
object obj1 = ((RuntimeFieldInfo) info1).InternalGetValue(this, false);
return Enum.InternalFormat(type1, obj1);
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
以下是从MSDN中找到的有关toString([expression])中参数代表意思的解释：
.NET Framework 开发人员指南&
枚举格式字符串&
可以使用 ToString 方法创建新的字符串对象，以表示
的数字、十六进制或字符串值。此方法采用某个枚举格式化字符串指定希望返回的值。
下表列出了枚举格式化字符串及其返回的值。这些格式说明符不区分大小写。
格式字符串
如有可能，将枚举项显示为字符串值，否则显示当前实例的整数值。如果枚举定义中设置了 Flags 属性，则串联每个有效项的字符串值并将各值用逗号分开。如果未设置 Flags 属性，则将无效值显示为数字项。
如有可能，将枚举项显示为字符串值。如果值可以完全显示为枚举项的总和（即使未提供 Flags 属性），则串联每个有效项的字符串值并将各值用逗号分开。如果值不能完全由枚举项确定，则将值格式化为整数值。
以尽可能短的表示形式将枚举项显示为整数值。
将枚举项显示为十六进制值。按需要将值表示为带有前导零，以确保值的长度最少有八位。
下面的示例定义一个名为 Colors 的枚举，该枚举包含三项：Red、Blue 和 Green。
Visual Basic
Public Enum Colors
public enum Colors{Red = 1, Blue = 2, Green = 3}
定义了枚举后，可以按下面的方式声明实例。
Visual Basic
Dim MyColors As Colors = Colors.Green
Colors MyColors = Colors.G
下面的示例使用枚举格式化方法将
枚举的字符串、数字和十六进制表示形式赋予字符串 MyString。此代码创建 DayOfWeek 枚举的新实例（名为 MyDays），并为其赋值 Friday。然后，它使用&G&、&F&、&D&和&X&格式化字符串将不同的枚举表示形式赋予 MyString。
Visual Basic
Dim MyDays As DayOfWeek = DayOfWeek.Friday
Dim MyString As String = MyDays.ToString(&G&)
' In the U.S. English culture, MyString has the value: &Friday&.
MyString = MyDays.ToString(&F&)
' In the U.S. English culture, MyString has the value: &Friday&.
MyString = MyDays.ToString(&D&)
' In the U.S. English culture, MyString has the value: &5&.
MyString = MyDays.ToString(&X&)
' In the U.S. English culture, MyString has the value: &&.
DayOfWeek MyDays = DayOfWeek.F
String MyString = MyDays.ToString(&G&);
// In the U.S. English culture, MyString has the value: &Friday&.
MyString = MyDays.ToString(&F&);
// In the U.S. English culture, MyString has the value: &Friday&.
MyString = MyDays.ToString(&D&);
// In the U.S. English culture, MyString has the value: &5&.
MyString = MyDays.ToString(&X&);
// In the U.S. English culture, MyString has the value: &&.
本文已收录于以下专栏：
相关文章推荐
慎用Enum的ToString Enum.ToString() 由 .NET Compact Framework 支持。  将此实例的值转换为其等效的字符串表示。  我们常在开发中常用到自定义枚举类型...
Enum为枚举提供基类，其基础类型可以是除 Char 外的任何整型。如果没有显式声明基础类型，则使用Int32。编程语言通常提供语法来声明由一组已命名的常数和它们的值组成的枚举。
    注意：枚举...
I saw two posts on Enums today on Eric Lipperts and Chris Rathjen's blog. Enums are significantly di...
关于重写toString
java对象是都是Object类的实例，都可直接调用该类中定义的方法，这些方法提供了处理java对象的通用方法。
& & 6.2.1打印对象和toString方法
    先看下面...
字符型转换为字符串
// C 货币2.5.ToString(&C&); //
￥2.50// D 10进制数25.ToString(&D5&); //
25000// E 科学型25...
问题引入：首先我们搭建hibernate一对一双向关联关系，在我们建立hibernate一对一双向关联之后不能再toString()方法中相互引入，否则会报StackOverFlowError,也就是...
他的最新文章
讲师：宋宝华
讲师：何宇健
您举报文章：
举报原因：
原文地址：
原因补充：
(最多只允许输入30个字)5828人阅读
JavaSE（45）
仍然采用&例子。稍加修改。
package mark.
public class EnumDemo {
public static void main(String[] args) {
for (Color color : Color.values()) {
System.out.println(color);
public enum Color {
RED(&red color&, 0), GREEN(&green color&, 1), BLUE(&blue color&, 2), YELLOW(
&yellow color&, 3);
Color(String name, int id) {
private String _
private int _
public String getName() {
public int getId() {
原本以为会打印如下形式的东西
但是，实际情况不是这样。具体可以查看 Enum 的源码，看看 toString 方法：
* Returns the name of this enum constant, as contained in the
* declaration.
This method may be overridden, though it typically
* isn't necessary or desirable.
An enum type should override this
* method when a more &programmer-friendly& string form exists.
* @return the name of this enum constant
public String toString() {
注释写的很明白，返回的是 the name of enum constant（枚举常量值的名字）。
如果我们想要得到如期的结果，需要重写 toString 方法。
package mark.
public class EnumDemo {
public static void main(String[] args) {
for (Color color : Color.values()) {
System.out.println(color);
public enum Color {
RED(&red color&, 0), GREEN(&green color&, 1), BLUE(&blue color&, 2), YELLOW(
&yellow color&, 3);
Color(String name, int id) {
private String _
private int _
public String getName() {
public int getId() {
public String toString() {
return _name + &,& + _
上面代码里面使用增强 for 循环调用 values() 方法，遍历枚举的值，也可以这样来遍历：
for (Color color : Color.values()) {
System.out.println(color.getName() + &,& + color.getId());
Enum 类的 equals、hashCode 方法
* Returns true if the specified object is equal to this
* enum constant.
* @param other the object to be compared for equality with this object.
true if the specified object is equal to this
enum constant.
public final boolean equals(Object other) {
return this==
* Returns a hash code for this enum constant.
* @return a hash code for this enum constant.
public final int hashCode() {
return super.hashCode();
都是 final 的，很明显，设计者不想让子类去重写这两个方法。
的确，在枚举里面无法重写这两个方法。但是如何使用这个方法呢？
现在，我们不去重写 toString 方法，看看 equals 效果。
public enum Color {
RED(&red color&, 0), GREEN(&green color&, 1),
BLUE(&blue color&, 2), YELLOW(&yellow color&, 3);
Color(String name, int id) {
private String _
private int _
public String getName() {
public int getId() {
测试结果：
public static void main(String[] args) {
System.out.println(Color.RED.equals(&&));// false
System.out.println(Color.RED.equals(&red color&));// false
System.out.println(Color.RED.equals(&RED&));// false
System.out.println(Color.RED.equals(Color.BLUE));// false
// 同一个对象
System.out.println(Color.RED.equals(Color.RED));// true
// 实际是两个 String
System.out.println(Color.RED.toString().equals(&RED&));// true
// 实际是两个 String
System.out.println(Color.RED.getName().equals(&red color&));// true
// hashCode
System.out.println(&Color.RED.hashCode = & + Color.RED.hashCode());
如果重写了类似上面的 toString 方法，那么
System.out.println(Color.RED.toString().equals(&RED&));
返回的可能是 true，也可能是 false，这取决于你的&toString 具体实现。
如下面这种实现方法：返回 _name 的大写形式。
public String toString() {
return this._name.toUpperCase();
综上，建议根据需要可以重写 toString 方法，善用 equals 方法。
&&相关文章推荐
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：987742次
积分：14065
积分：14065
排名：第964名
原创：260篇
转载：11篇
评论：482条
(window.slotbydup = window.slotbydup || []).push({
id: '4740887',
container: s,
size: '250,250',
display: 'inlay-fix'Java中的枚举类型Enum
中所有的枚举类型都是java.lang.Enum的子类。
1. 定义枚举类型
简单定义一个枚举类型，如下：
public enum Week {
WEDNESDAY,
2. 枚举类型的常用方法
可以使用枚举类型的values()静态方法返回枚举类型中的所有枚举值，使用枚举常量的name()方法返回枚举常量的名称，使用枚举常量的ordinal()方法返回枚举常量的序数（常量在枚举声明中的位置，从0开始）。示例代码如下：
public static void main(String[] args) {
//获取枚举类型中的全部枚举值
Week[] days = Week.values();
for(Week day : days) {
//返回枚举常量的名称
String name = day.name();
//返回枚举常量的序数（常量在枚举声明中的位置，从0开始）
int ordinal = day.ordinal();
String toString = day.toString();
Class declaringClass = day.getDeclaringClass();
Class superClass = declaringClass.getSuperclass();
System.out.println(
"Name: " + name
+ "Ordinal: " + ordinal
+ "ToString: " + toString
+ "DeclaringClass: " + declaringClass
+ "SuperClass: " + superClass
}输出结果如下：Name: MONDAY
Ordinal: 0
ToString: MONDAY
DeclaringClass: class myEnum.Week
SuperClass: class java.lang.Enum
Name: TUESDAY
Ordinal: 1
ToString: TUESDAY
DeclaringClass: class myEnum.Week
SuperClass: class java.lang.Enum
Name: WEDNESDAY
Ordinal: 2
ToString: WEDNESDAY
DeclaringClass: class myEnum.Week
SuperClass: class java.lang.Enum
Name: THURSDAY
Ordinal: 3
ToString: THURSDAY
DeclaringClass: class myEnum.Week
SuperClass: class java.lang.Enum
Name: FRIDAY
Ordinal: 4
ToString: FRIDAY
DeclaringClass: class myEnum.Week
SuperClass: class java.lang.Enum
Name: SATURDAY
Ordinal: 5
ToString: SATURDAY
DeclaringClass: class myEnum.Week
SuperClass: class java.lang.Enum
Name: SUNDAY
Ordinal: 6
ToString: SUNDAY
DeclaringClass: class myEnum.Week
SuperClass: class java.lang.Enum
3. 比较枚举常量
判断两个枚举类型常量的值是否相等，可以直接使用“==”，而不用equals()方法。比较两个枚举类型常量的值的大小，可以使用compareTo()方法。
public static void main(String[] args) {
Week mon = Week.MONDAY;
Week tues = Week.TUESDAY;
Week wed = Week.WEDNESDAY;
//比较枚举常量，实际上是比较它们序数的大小
System.out.pareTo(tues));
System.out.pareTo(wed));
System.out.pareTo(mon));
输出结果如下：
实际上，比较两个枚举常量的大小，就是比较它们序数ordinal的大小。在JDK1.6的Enum中compareTo()方法如下：
public final int compareTo(E o) {
Enum other = (Enum)o;
Enum self =
if (self.getClass() != other.getClass() && // optimization
self.getDeclaringClass() != other.getDeclaringClass())
throw new ClassCastException();
return self.ordinal - other.
4. 创建枚举常量
创建枚举常量主要有三种方法：直接利用枚举类型创建枚举常量、使用Enum的valueOf()静态方法创建枚举常量、使用枚举类型的valueOf()静态方法创建枚举常量。
//直接创建枚举常量
Week mon = Week.MONDAY;
//使用Enum的valueOf()静态方法创建枚举常量
Week tues = Enum.valueOf(Week.class, "TUESDAY");
//使用枚举类型的valueOf()静态方法创建枚举常量
Week wed = Week.valueOf("WEDNESDAY");
5. 定义高级的枚举类型
根据需要，可以在枚举类型中添加构造器、方法和字段，还可以让枚举类型继承接口。
定义接口IWeek，如下：
public interface IWeek {
public void println();
定义高级的枚举类型AdvancedWeek，拥有自己的构造器、方法和字段，并实现IWeek接口。public enum AdvancedWeek
implements IWeek{
MONDAY("星期一", "Mon."),
TUESDAY("星期二", "Tues."),
WEDNESDAY("星期三", "Wed."),
THURSDAY("星期四", "Thurs."),
FRIDAY("星期五", "Fri."),
SATURDAY("星期六", "Sat."),
SUNDAY("星期日", "Sun.");
private String nameCn;
//构造方法只能为private
private AdvancedWeek() {}
private AdvancedWeek(String nameCn, String abbreviation) {
this.setNameCn(nameCn);
this.setAbbreviation(abbreviation);
public String getNameCn() {
return nameCn;
public void setNameCn(String nameCn) {
this.nameCn = nameCn;
public String getAbbreviation() {
public void setAbbreviation(String abbreviation) {
this.abbreviation =
public void println() {
System.out.println(this.ordinal() + " - " + this.name() + " - " + this.getAbbreviation() + " - " + this.getNameCn());
}需要注意的是，枚举类型的构造方法只能为private。
测试AdvancedWeek，如下：
public static void main(String[] args) {
AdvancedWeek[] days = AdvancedWeek.values();
for(AdvancedWeek day : days) {
day.println();
}输出结果为：0 - MONDAY - Mon. - 星期一
1 - TUESDAY - Tues. - 星期二
2 - WEDNESDAY - Wed. - 星期三
3 - THURSDAY - Thurs. - 星期四
4 - FRIDAY - Fri. - 星期五
5 - SATURDAY - Sat. - 星期六
6 - SUNDAY - Sun. - 星期日博客分类：
Java 中的枚举（enum）
枚举就是一组有限数据的集合,比如：性别就可以用枚举表示，他们的元素分别为男、女，最多还加个未知或者人妖。
枚举也是一种特殊的类，与普通类的区别在于普通类在定义的时候不明确他将会有哪些实例对象存在，完全由程序员自己去生成实例，而枚举只是他的值在定义的时候就已经实例话了，如下面的枚举定义方式:
* 定义了颜色有红、绿、蓝三种颜色的枚举类型
* @author lzjun
public enum Color {
RED,GREEN,BLUE
枚举与类相同的地方在于，定义了一个枚举时，编译器同样会生成一个相关的类，这个类是继承的java.lang.Enum.
System.out.println(Color.BLUE.getClass());
System.out.println(Color.BLUE.getClass().getSuperclass());
输出结果：class com.lzjun.Color
class java.lang.Enum
从输出结果可以很明确的看出枚举本质上就是一个类，而他的父类是Enum.
既然是一个类的话，他就有类的特性，包括属性和方法。
* 三个static方法
// 根据String类型参数返回一个枚举值
System.out.println(Color.valueOf("BLUE"));
//返回该枚举中所有枚举值作为一个数组，顺序依然按照初始化的状态存放
System.out.println(Color.values());
//此方法继承与Enum中的valueOf方法，作用与第一个方法类似，具体使用可以参看jdk文档
System.out.println(Color.valueOf(Color.class, "RED"));
实例方法，继承自Enum
pareTo(Color.GREEN);
//比较枚举的顺序
Color.BLUE.name();
//返回枚举的名称
Color.BLUE.ordinal();
//返回该枚举值在枚举定义时的位置
我们可以查看Enum的源码可以看出：
1、Enum类为抽象的
2、该类中没有ValueOf(String)方法和Values()方法
那么我们是否自己可以写一个继承Enum类的类呢，答案是否定的，编译器根本不允许你这么干，难道Enum就成摆设了？
我们可以尝试去反编译Color，看看创建一个枚举的时候，编译器究竟帮我们做了什么事情？
public final class com.lzjun.Color extends java.lang.Enum{
public static final com.lzjun.Color RED;
public static final com.lzjun.Color GREEN;
public static final com.lzjun.Color BLUE;
static {};
public static com.lzjun.Color[] values();
public static com.lzjun.Color valueOf(java.lang.String);
从代码看出其实这个Enum类是用来被继承的。
当然同样可以和普通类一样的去使用，除继承之外
* 任意的扩展此枚举类
* @author lzjun
public enum Color implements SomeInterface{
RED,GREEN,BLUE("蓝色");
private Color(){};
private Color(String description){
this.description
public String toString() {
public static void main(String[] args) {
System.out.println(BLUE);
enum还有一个重要的特点是就是可以用于switch语句。当然jdk7包括字符串在内的类型也能用于switch这个多路分支判断语句。
enum既然是一个集合，但遗憾的是他不能改变大小，就像数组一样，于是就诞生了EnumSet类，这样我们就可以像集合一样对他做CURD操作了.
lantian_123
浏览: 960172 次
来自: 广州
学会了recording，感谢~~
看完了才发现这篇文章果然是你写的
看完了，才发现时部长写的，真爱啊
(window.slotbydup=window.slotbydup || []).push({
id: '4773203',
container: s,
size: '200,200',
display: 'inlay-fix'}