冷眼看 java 的枚举

看看这样一段 C# 代码实现了什么？

 1     public abstract class EnumBase<T> where T : EnumBase<T>
 2     {
 3         public int Value { get; protected set; }
 4 
 5         public string Code { get; protected set; }
 6 
 7         public string Name { get; protected set; }
 8 
 9         /// <summary>
         /// Initializes a new instance of the EnumBase class.
         /// </summary>
         protected EnumBase(int value, string code, string name)
         {
             Value = value;
             Code = code;
             Name = name;
         }
 
         protected static T ValueOf(IEnumerable<T> values, int value)
         {
             foreach (T item in values)
             {
                 if (item.Value == value)
                 {
                     return item;
                 }
             }
 
             return null;
         }
 
         protected static T ValueOf(IEnumerable<T> values, string name)
         {
             foreach (T item in values)
             {
                 if (item.Name.Equals(name, StringComparison.OrdinalIgnoreCase)
                     || item.Code.Equals(name, StringComparison.OrdinalIgnoreCase))
                 {
                     return item;
                 }
             }
 
             return null;
         }
 
         public override string ToString()
         {
             return Code;
         }
 
         public override int GetHashCode()
         {
             return Code.GetHashCode();
         }
     }
 
 
     public class CompScope : EnumBase<CompScope>
     {
         public static CompScope CommonComponent = new CompScope(0, "CommonComponent", "一般组件");
 
         public static CompScope SystemComponent = new CompScope(1, "SystemComponent", "系统组件");
 
         public static CompScope ShareComponent = new CompScope(2, "ShareComponent", "ShareComponent");
 
         private static CompScope[] values = new CompScope[] { CommonComponent, SystemComponent, ShareComponent };
 
         public static IEnumerable<CompScope> Values
         {
             get
             {
                 return values;
             }
         }
 
         public static CompScope ValueOf(int value)
         {
             return ValueOf(values, value);
         }
 
         public static CompScope ValueOf(string name)
         {
             return ValueOf(values, name);
         }
 
         /// <summary>
         /// Initializes a new instance of the CompScope class.
         /// </summary>
         private CompScope(int value, string code, string name) : base(value, code, name)
         {
         }
     }
 

 

是不是和 Java 的 Enum 很象，而且，很显然的，这段代码用Java写也是这样的效果。

当然，Java 中直接声明 Enum，不需要显式的声明继承自 Enum<XXXX>，那些 static 的枚举成员，只需要声明一个名称，而且不需要声明 values 数组和 ValueOf 函数，这些都由 java 编译器自动处理了。

可是，哦，这不就是个语法糖么，当 java 的那些家伙口口声声说 C# 3.0 lamda表达式，对象初始化等特性不就是一些语法糖的时候，不知道他们是否还记得，他们所谓的 枚举 其实不过也只是一个更大语法糖而已。