jdk 1.5 枚举替代类 Enum

写的很简单.
原文连接:
http://blog.csdn.net/mdog26/archive/2008/11/03/3210274.aspx------------------------------------------------------------------------------------
   在使用jdk1.5开发的项目中,遇到需要改成1.4版本.     如何更改才能使得项目中的代码更改量最小化.     其中枚举,应该如何替代?         这样一个类,主要用来模拟java.lang.Enum类.import java.io.Serializable; 
import java.util.Collection; /* 
 * @模拟java.lang.Enum类 
 * @author dongchang 2008-09-26 
 *   
 */ 
public class EnumImitation extends Object implements Comparable, Serializable { //<E extends Enum<E>> 
     
    private final String name;     public final String name() { 
        return name; 
    }     private final int ordinal;     public final int ordinal() { 
        return ordinal; 
    }     public EnumImitation(String name, int ordinal) { 
        this.name = name; 
        this.ordinal = ordinal; 
    }     public String toString() { 
        return name; 
    }     public final boolean equals(Object other) { 
        if (this == other) { 
            return true; 
        } 
       if(other.toString().equals(this.name)){ 
           return true; 
       } 
       return false;         
    }     public final int hashCode() { 
        return System.identityHashCode(this); 
    }     protected final Object clone() throws CloneNotSupportedException { 
        throw new CloneNotSupportedException(); 
    }     public final int compareTo(Object o) { 
        EnumImitation other = (EnumImitation) o; 
        EnumImitation self = this;       
        return self.ordinal - other.ordinal; 
    } 
     
    protected static Object[] baseValuesEnum(Collection enums) {// dongchang 
        return enums.toArray(); 
    } 
}      这个类,是继承,可以扩展.这里只扩展了一个values方法import java.util.LinkedList; 
import java.util.List; 
/* 
 * @模拟java.lang.Enum类values() 
 * @author dongchang 2008-09-26 
 *   
 */ 
public class EnumIs extends EnumImitation{ 
    public static List list = new LinkedList();//储存 用于values方法     public EnumIs(String name, int ordinal) { 
        super(name, ordinal);            
        list.add(this); 
    } 
    protected static Object[] valuesEnum(){ 
        return baseValuesEnum(list); 
    } 
}
    以下就是简单的例子.    因为jdk1.4没有泛型,所以每一个枚举实现类,都需要覆盖values和valueOf方法./* 
     * enum更改类 适用于jdk1.4 
     * dongchang 2008-09-28 
     */ 
    public static class SEARCH_TYPE extends EnumIs{ 
         
        public final static SEARCH_TYPE SEARCH_KEYWORD = new SEARCH_TYPE("keyword", "search.keyword","SEARCH_KEYWORD",0);  
        public final static SEARCH_TYPE SEARCH_METADATA = new SEARCH_TYPE("metadata", "search.metadata","SEARCH_METADATA",1);  
        public final static SEARCH_TYPE SEARCH_FULLTEXT = new SEARCH_TYPE("fulltext",   "search.fulltext","SEARCH_FULLTEXT",2); 
        private String type = null;         private String parmName = null;         private SEARCH_TYPE(String type, String parmName,String name, int ordinal) {//dongchang 2008-09-28 
            super(name, ordinal); 
            this.type = type; 
            this.parmName = parmName; 
        }         public String getType() { 
            return this.type; 
        }         public String getParmName() { 
            return this.parmName; 
        } 
         
        /* 
         * dongchang 2008-09-28 
         */ 
        public static SEARCH_TYPE valueOf(String enumName) { 
            SEARCH_TYPE[] enums = SEARCH_TYPE.values(); 
            for (int i = 0; i < enums.length; i++) { 
                if (enums[i] == null) 
                    continue; 
                if (enums[i].name().equals(enumName)) { 
                    return enums[i]; 
                } 
            } 
            return null; 
        }         /* 
         * dongchang 2008-09-28 
         */ 
        public static SEARCH_TYPE[] values() { 
            Object[] os = SEARCH_TYPE.valuesEnum(); 
            List list = new ArrayList(); 
            for (int i = 0; i < os.length; i++) { 
                if (os[i] instanceof SEARCH_TYPE) { 
                    list.add(os[i]); 
                } 
            } 
            SEARCH_TYPE[] enums = new SEARCH_TYPE[list.size()]; 
            for (int i = 0; i < enums.length; i++) { 
                enums[i] = (SEARCH_TYPE) list.get(i); 
            } 
            return enums; 
        } 
    }     现在所需要更改的就是项目代码中的switch方法.判断字符串来替换.     和原来的枚举类可进行对比. public static enum SEARCH_TYPE { 
        SEARCH_KEYWORD("keyword", "search.keyword"),  
        SEARCH_METADATA("metadata", "search.metadata"),  
        SEARCH_FULLTEXT("fulltext", "search.fulltext"); 
        private String type = null;         private String parmName = null;         private SEARCH_TYPE(String type, String parmName) { 
            this.type = type; 
            this.parmName = parmName; 
        }         public String getType() { 
            return this.type; 
        }         public String getParmName() { 
            return this.parmName; 
        } 
    }
     又一个例子:public class FailedValue extends EnumIs{ 
    public FailedValue(String name, int ordinal) { 
        super(name, ordinal); 
    } 
     
    public final static FailedValue Null = new FailedValue("Null",0); 
    public final static class Nullclass extends FailedValue{ 
        public Nullclass(String name, int ordinal) { 
            super(name, ordinal); 
        } 
        public Object get(){return null;} 
    }     public final static FailedValue True = new FailedValue("True",1); 
    public final static class Trueclass extends FailedValue{ 
        public Trueclass(String name, int ordinal) { 
            super(name, ordinal); 
        } 
        public Object get(){return new Boolean(true);}//dongchang 2008-10-06 
    } 
     
    public final static FailedValue False= new Falseclass("False",2); 
    public final static class Falseclass extends FailedValue{ 
        public Falseclass(String name, int ordinal) { 
            super(name, ordinal); 
        } 
        public Object get(){return new Boolean(false);}//dongchang 2008-10-06 
    }     public Object get(){return new Object();} 
     
    /* 
     * dongchang 2008-09-28 
     */ 
    public static FailedValue valueOf(String enumName) { 
        FailedValue[] enums = FailedValue.values(); 
        for (int i = 0; i < enums.length; i++) { 
            if (enums[i] == null) 
                continue; 
            if (enums[i].name().equalsIgnoreCase(enumName)) { 
                return enums[i]; 
            } 
        } 
        return null; 
    }     /* 
     * dongchang 2008-09-28 
     */ 
    public static FailedValue[] values() { 
        Object[] os = FailedValue.valuesEnum(); 
        List list = new ArrayList(); 
        for (int i = 0; i < os.length; i++) { 
            if (os[i] instanceof FailedValue) { 
                list.add(os[i]); 
            } 
        } 
        FailedValue[] enums = new FailedValue[list.size()]; 
        for (int i = 0; i < enums.length; i++) { 
            enums[i] = (FailedValue) list.get(i); 
        } 
        return enums; 
    } 
}
    对比:public enum FailedValue{ 
        Null    {public Object get(){return null;}}, 
        True    {public Object get(){return true;}}, 
        False   {public Object get(){return false;}}, 
         
        EmptyString         {public Object get(){return "";}}, 
        ; 
        public abstract Object get(); 
}