código fuente de Java enumeración detallada Enum y recuento
definición de clase
public abstract class Enum<E extends Enum<E>>
implements Comparable<E>, Serializable {
}definición de atributo
private final String name;
public final String name() {
return name;
}
private final int ordinal;
public final int ordinal() {
return ordinal;
}
protected Enum(String name, int ordinal) {
this.name = name;
this.ordinal = ordinal;
}
public String toString() {
return name;
}
public final boolean equals(Object other) {
return this==other;
}
public final int hashCode() {
return super.hashCode();
}
protected final Object clone() throws CloneNotSupportedException {
throw new CloneNotSupportedException();
}
public final int compareTo(E o) {
Enum<?> other = (Enum<?>)o;
Enum<E> self = this;
if (self.getClass() != other.getClass() && // optimization
self.getDeclaringClass() != other.getDeclaringClass())
throw new ClassCastException();
return self.ordinal - other.ordinal;
}
@SuppressWarnings("unchecked")
public final Class<E> getDeclaringClass() {
Class<?> clazz = getClass();
Class<?> zuper = clazz.getSuperclass();
return (zuper == Enum.class) ? (Class<E>)clazz : (Class<E>)zuper;
}
public static <T extends Enum<T>> T valueOf(Class<T> enumType,
String name) {
T result = enumType.enumConstantDirectory().get(name);
if (result != null)
return result;
if (name == null)
throw new NullPointerException("Name is null");
throw new IllegalArgumentException(
"No enum constant " + enumType.getCanonicalName() + "." + name);
}
protected final void finalize() { }
private void readObject(ObjectInputStream in) throws IOException,
ClassNotFoundException {
throw new InvalidObjectException("can't deserialize enum");
}
private void readObjectNoData() throws ObjectStreamException {
throw new InvalidObjectException("can't deserialize enum");
}- Utilice modificaciones finales, sin duda, tener un poco más consumida en la memoria, porque la piscina constante después de la última modificación de las propiedades se encuentran.
piscina constante (constant_pool) se refiere determinarse en tiempo de compilación, y algunos datos almacenados en los archivos .class compilados. Incluye constante sobre las clases, métodos, interfaces, y similares, y también incluye un simbólicos constantes de cadena de referencia. Tiempo de ejecución de la piscina constante es parte del método de la zona.
La piscina constante se utiliza principalmente para el almacenamiento de dos constantes Categorías: literal (literal) y la cantidad simbólica de referencia (referencias simbólicas), literal nivel constante equivalente al concepto del lenguaje Java, tales como cadenas de texto, declarado como valor constante definitiva de otros símbolos la teoría compilador de referencia pertenece al concepto de áreas, incluyendo los siguientes tres tipos de constantes:
1. el nombre completo de la clase y la interfaz
2. Nombre del campo y el descriptor
El nombre del método y el descriptor
La mayor parte de los ocho tipos básicos de Java envoltura clase implementa la tecnología de memoria constante, son Byte, Short, Integer, Long, del carácter, de Boole, además
No se consiguen dos clases de tipos de punto flotante de envasado (float, double). Además Byte, Short, Integer, Long, carácter estos cinco enteros únicamente en envases
Los valores correspondientes, a fin de utilizar la piscina objeto 127 -128
modificación final de propiedades: las propiedades de la clase no inicializado implícitamente (atributo de clase de inicialización debe tener un valor) o asignación (pero sólo uno está seleccionado) en el constructor.
2. Comparar el valor de dos tipos de enumeración, que no será necesario iguales llamadas, uso directo de "==" en él.
3. Todos los tipos se enumeran Enum subclase hereda muchas maneras, la más útil es el método toString, que puede devolver un nombres de constantes de enumeración. Como muelle de retorno SeasonEnum.SPRING.toString
4. toString inversa es un método valueOf método estático. Por ejemplo SeasonEnum s = Enum.valueof ( "Primavera" SeasonEnum.class), SeasonEnum.SPRING un conjunto s
5. devuelve el método ordinales enum posición constante declaración enumeración, una posición para empezar a contar de 0, por ejemplo SeasonEnum.SUMMER.ordinal () devuelve 1.
6. parámetro de tipo CompareTo utiliza en el proceso, como clase Clase, la vista simplificada de las consideraciones, el Enum un parámetro de tipo de clase se omite. De hecho, los tipos enumerados SeasonEnum debe extenderse a Enum <SeasonEnum>. Si las constantes de enumeración aparecen antes que el otro, devuelve un valor negativo, y si esto == otra, devuelve 0; de lo contrario los resultados positivos se dan en el orden de declaración de enumeración constante de enumeración.
7. Debido a la reescritura iguales, métodos hashcode son modificados final, no se puede enumerar (sólo puede heredar), sin embargo, se puede reemplazar el método toString.
Echemos un vistazo en el uso básico de enumeración de Java
Si fijamos la temeridad de proporcionar un método (el mundo exterior puede cambiar sus propiedades de miembro), que parece un poco contrario a la intención original del diseño. Por lo tanto, debemos abandonar el método conjunto conserva el método get.
Lo enumeraciones son?
enumeración de Java es un tipo de azúcar sintáctico, se produce después de JDK 1.5, usado para representar un número fijo y finito de objetos. Por ejemplo, una temporada como la primavera, verano, otoño e invierno cuatro objetos; a la semana de lunes a domingo siete objetos. Estos claramente son fijos, y un número finito.
Diferencia clase enumeración y normal de clases
①, hereda clase de enumeración definido uso de enumeración defecto categorías java.lang.Enum, a saber, una clase de enumeración es una clase no puede ser heredada más. El valor por defecto de la clase padre común general es objetos
②, constructor de la clase de enumeración solo puede usar la definición privada, pero la clase ordinaria también puede ser modificado con el público
③, todas las instancias de la clase debe mostrar la enumeración se enumeran en la clase de enumeración (partición; final), los ejemplos de los sistemas enumerados añadirá automáticamente la estática público predeterminado modificada definitiva
④, todos proporcionan unos valores de clase de enumeración () método se puede utilizar para valor de enumeración iterate
clase de uso de enumeración para representar la temporada:
public enum SeasonEnum {
//必须在第一行写出有哪些枚举值
SPRING("春天", "春暖花开"),
SUMMER("夏天", "炎炎盛夏"),
FALL("秋天", "秋高气爽"),
WINTER("冬天", "大雪纷飞");
private final String name;
private final String desc;
private SeasonEnum(String name, String desc) {
this.name = name;
this.desc = desc;
}
public static void main(String[] args) {
System.out.println(SeasonEnum.SPRING); //SPRING
//用 values() 来获取所有的枚举值
for(SeasonEnum s : SeasonEnum.values()){
System.out.println(s);
}
}
}
la clase de enumeración puede implementar una interfaz:
Definir una interfaz mediante la devolución de la temporada del mes
public interface SeasonEnumImpl {
//用来返回季节的月份
String getMonth();
}public enum SeasonEnum implements SeasonEnumImpl{
//必须在第一行写出有哪些枚举值
SPRING("春天", "春暖花开"){
@Override
public String getMonth() {
return "12-2";
}
},
SUMMER("夏天", "炎炎盛夏"){
@Override
public String getMonth() {
return "3-5";
}
},
FALL("秋天", "秋高气爽"){
@Override
public String getMonth() {
return "6-8";
}
},
WINTER("冬天", "大雪纷飞"){
@Override
public String getMonth() {
return "9-11";
}
};
private final String name;
private final String desc;
private SeasonEnum(String name, String desc) {
this.name = name;
this.desc = desc;
}
public static void main(String[] args) {
System.out.println(SeasonEnum.SPRING); //SPRING
//用 values() 来获取所有的枚举值
for(SeasonEnum s : SeasonEnum.values()){
System.out.println(s.getMonth());
}
}
}
Antes de instrucción switch jdk1.6 sólo admite int, char, tipo de enumeración, enumeración, que nuestro código sea más legible.
public enum Fruit {
APPLE, BANANA, ORANGE, WATERMELON;
}public class EnumTest {
public static void main(String[] args)
{
for(Fruit fruit : Fruit.values())
{
test(fruit);
}
}
public static void test(Fruit fruit)
{
switch (fruit)
{
case APPLE:
System.out.println("This is an apple");
break;
case BANANA:
System.out.println("This is a banana");
break;
case ORANGE:
System.out.println("This is an orange");
break;
case WATERMELON:
System.out.println("This is a watermelon");
break;
default:
break;
}
}
}
fuente clase de enumeración
public interface Enumeration<E> {
boolean hasMoreElements();
E nextElement();
}clase de enumeración de recorrido
Map map = request.getParameterMap();
java.util.Enumeration enum=this.getRequest().getParameterNames();
while(enum.hasMoreElements()){
String paramName=(String)enum.nextElement();
String[] values=request.getParameterValues(paramName);
for(int i=0;i<values.length;i++){
System.out.println("["+i+"] "+paramName+" "+values[i]);
}
}
//形成键值对应的map
map.put(paramName, paramValue);
}
enumeración mybatis
