JDK1.5 introduce un nuevo tipo - enumeración. En Java, aunque se considera una característica "pequeño", di mi desarrollo ha traído "grande" conveniencia.
Gran Hermano agrego mi propio entendimiento, para ayudarle a entender la misma.
Utilice a: constante
Antes JDK1.5, definimos las constantes son: public static final ..... Ahora bien, con las constantes de enumeración que puede estar relacionado con un tipo de enumeración grupo, la enumeración y proporciona más de método constante.
código Java
public enum Color {
RED, GREEN, BLANK, YELLOW
} El uso de dos: Interruptor
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.
código Java
enum Signal {
GREEN, YELLOW, RED
}
public class TrafficLight {
Signal color = Signal.RED;
public void change() {
switch (color) {
case RED:
color = Signal.GREEN;
break;
case YELLOW:
color = Signal.RED;
break;
case GREEN:
color = Signal.YELLOW;
break;
}
}
} Utilizar tres: añadir un nuevo método para la enumeración
Si va a personalizar su propio camino, y por último añadir un punto y coma para ser serializado en la instancia de enumeración. Los requisitos deben ser definidos y Java enumeración ejemplo.
código Java
public enum Color {
RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);
// 成员变量
private String name;
private int index;
// 构造方法
private Color(String name, int index) {
this.name = name;
this.index = index;
}
// 普通方法
public static String getName(int index) {
for (Color c : Color.values()) {
if (c.getIndex() == index) {
return c.name;
}
}
return null;
}
// get set 方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getIndex() {
return index;
}
public void setIndex(int index) {
this.index = index;
}
} Uso de cuatro: cubriendo método de enumeración
He aquí un ejemplo del método cubierta toString ().
código Java
public enum Color {
RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);
// 成员变量
private String name;
private int index;
// 构造方法
private Color(String name, int index) {
this.name = name;
this.index = index;
}
//覆盖方法
@Override
public String toString() {
return this.index+"_"+this.name;
}
} Uso cinco: implementar una interfaz
Todas las clases de enumeración heredan de java.lang.Enum. Debido a que Java no soporta herencia múltiple, por lo objeto enumerable no puede heredar de otras clases.
código Java
public interface Behaviour {
void print();
String getInfo();
}
public enum Color implements Behaviour{
RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);
// 成员变量
private String name;
private int index;
// 构造方法
private Color(String name, int index) {
this.name = name;
this.index = index;
}
//接口方法
@Override
public String getInfo() {
return this.name;
}
//接口方法
@Override
public void print() {
System.out.println(this.index+":"+this.name);
}
}
Uso de seis: Uso Interfaz organización enumeración
código Java
public interface Food {
enum Coffee implements Food{
BLACK_COFFEE,DECAF_COFFEE,LATTE,CAPPUCCINO
}
enum Dessert implements Food{
FRUIT, CAKE, GELATO
}
}
/**
* 测试继承接口的枚举的使用（by 大师兄 or 大湿胸。）
*/
private static void testImplementsInterface() {
for (Food.DessertEnum dessertEnum : Food.DessertEnum.values()) {
System.out.print(dessertEnum + " ");
}
System.out.println();
//我这地方这么写，是因为我在自己测试的时候，把这个coffee单独到一个文件去实现那个food接口，而不是在那个接口的内部。
for (CoffeeEnum coffee : CoffeeEnum.values()) {
System.out.print(coffee + " ");
}
System.out.println();
//搞个实现接口，来组织枚举，简单讲，就是分类吧。如果大量使用枚举的话，这么干，在写代码的时候，就很方便调用啦。
//还有就是个“多态”的功能吧，
Food food = Food.DessertEnum.CAKE;
System.out.println(food);
food = CoffeeEnum.BLACK_COFFEE;
System.out.println(food);
}
Los resultados operativos
Uso siete: Utilice una enumeración en el set
java.util.EnumSet y java.util.EnumMap dos enumeraciones. EnumSet asegurar la colección de elementos no se repite; EnumMap enum tipo es la clave, pero puede ser cualquier tipo de valor. Sobre el uso de los dos conjuntos no va a entrar aquí, puede hacer referencia a la documentación del JDK.
Sobre los principios de enumeración y detalles de implementación, consulte:
Referencia: "ThinkingInJava" Cuarta Edición
http://softbeta.iteye.com/blog/1185573
Mi artículo, ya que se reproduce, puede ser básicamente sin cambios, en consecuencia alguien le pisó el pie. Que no cumpla con mi gran carácter hermano. Ahora entiendo su uso para resolver.
Pero también porque, ya que estaba empezando a aprenderlo. El por lo general creemos que sabemos todo lo que acaba de conocer un poco, después de todo, o creemos saber, de hecho, se ha ido no sabemos lo que es.
Fuera de aprendizaje, no se usa para mirar el código cómo puede hacerlo?
Aquí está mi propio código de prueba.
package com.lxk.enumTest;
/**
* Java枚举用法测试
* <p>
* Created by lxk on 2016/12/15
*/
public class EnumTest {
public static void main(String[] args) {
forEnum();
useEnumInJava();
}
/**
* 循环枚举,输出ordinal属性；若枚举有内部属性，则也输出。(说的就是我定义的TYPE类型的枚举的typeName属性)
*/
private static void forEnum() {
for (SimpleEnum simpleEnum : SimpleEnum.values()) {
System.out.println(simpleEnum + " ordinal " + simpleEnum.ordinal());
}
System.out.println("------------------");
for (TYPE type : TYPE.values()) {
System.out.println("type = " + type + " type.name = " + type.name() + " typeName = " + type.getTypeName() + " ordinal = " + type.ordinal());
}
}
/**
* 在Java代码使用枚举
*/
private static void useEnumInJava() {
String typeName = "f5";
TYPE type = TYPE.fromTypeName(typeName);
if (TYPE.BALANCE.equals(type)) {
System.out.println("根据字符串获得的枚举类型实例跟枚举常量一致");
} else {
System.out.println("大师兄代码错误");
}
}
/**
* 季节枚举(不带参数的枚举常量)这个是最简单的枚举使用实例
* Ordinal 属性，对应的就是排列顺序，从0开始。
*/
private enum SimpleEnum {
SPRING,
SUMMER,
AUTUMN,
WINTER
}
/**
* 常用类型(带参数的枚举常量，这个只是在书上不常见，实际使用还是很多的，看懂这个，使用就不是问题啦。)
*/
private enum TYPE {
FIREWALL("firewall"),
SECRET("secretMac"),
BALANCE("f5");
private String typeName;
TYPE(String typeName) {
this.typeName = typeName;
}
/**
* 根据类型的名称，返回类型的枚举实例。
*
* @param typeName 类型名称
*/
public static TYPE fromTypeName(String typeName) {
for (TYPE type : TYPE.values()) {
if (type.getTypeName().equals(typeName)) {
return type;
}
}
return null;
}
public String getTypeName() {
return this.typeName;
}
}
}
A continuación, los resultados de la prueba gráfico:
Un ejemplo sencillo, que básicamente han utilizado, básicamente, no entiendo el segundo ejemplo. Se puede observar en el segundo ejemplo, seguido de un parámetro, de hecho, puede ser entendido.
enum palabra clave, puede entenderse como casi como clase, que es también una clase separada. Puede ser visto, no son propiedades del ejemplo anterior, el método tiene una estructura, hay getters, el colocador puede tener también, pero generalmente están configurados para pasar parámetros. Hay otros métodos personalizados. Así que frente a estas cosas, separados por comas, y finalmente termina con un punto y coma, esta parte se llama, una instancia de esta enumeración. También se puede entender como, clase nueva instancia de la fuera objeto. Este tiempo suficiente para entender. Sólo, clase, nuevo objeto, que puede poseer cualquier nueva, son pocos los que quieren unos pocos, y esta palabra clave enum, que no lo haría, instancia de un objeto, que sólo puede ser reflejada en la enumeración de él. En otras palabras, ejemplos de su correspondencia es limitado. Esta es una enumeración de los beneficios, y limita el alcance de algunas cosas, dan castañas: Durante todo el año, sólo puede haber temporadas, si representación de cadena, entonces se fue a la mar, sin embargo, con el uso tipo enumerado, entonces usted tiene todas las opciones, todo vino, entonces la propiedad de esta temporada, los valores correspondientes se enumeran en la enumeración dentro de llaves, sólo se puede recoger en su interior. No se puede tener la otra.
Mi ejemplo anterior se basa en typeName, se puede recoger en el ejemplo de los que están dentro de las instancias Enumerar solo tipo TIPO --TYPE.BALANCE. Nota Método
tipo TYPE = TYPE.fromTypeName (typeName);
tipo de retorno es un tipo enumerado de la TIPO este método.
Esta vez, como de entender, se trata de cómo el trabajo enumeración en la barra de
A continuación, añadir:
Ejemplos del tipo enumerado anteriormente con parámetros que en realidad son tres propiedades, además de la typeName mi costumbre, hay dos sistema viene. Ver fuente figura a continuación:
Después de ver esto, no sé si se puede entender las palabras de las instrucciones en el siguiente cuadro: Las siguientes imágenes ilustran el uso principal de la enumeración, normas y estándares. La esperanza puede ser usado en el tiempo de desarrollo real
Por último, añadir lo siguiente:
Tal vez usted sabe sobre él, pero tal vez usted no sabe nada al respecto? Realmente no sé, sólo después de la prueba! ! !
Comparación entre el valor de los objetos de tipo enumerados, == se utiliza directamente para comparar los valores, ya sea iguales, no es necesario utilizar el método equals yo.
En particular, consulte los siguientes enlaces:
java enumeración comparación clase es igual o ==?
11/07/2017 actualización
Un poco de hierro viejo, cómo escribir este caso el interruptor, que se verá en la siguiente largo aliento.
private static void testSwitchCase() {
String typeName = "f5";
//这几行注释呢，你可以试着三选一，测试一下效果。
//String typeName = "firewall";
//String typeName = "secretMac";
TypeEnum typeEnum = TypeEnum.fromTypeName(typeName);
if (typeEnum == null) {
return;
}
switch (typeEnum) {
case FIREWALL:
System.out.println("枚举名称(即默认自带的属性 name 的值)是：" + typeEnum.name());
System.out.println("排序值(默认自带的属性 ordinal 的值)是：" + typeEnum.ordinal());
System.out.println("枚举的自定义属性 typeName 的值是：" + typeEnum.getTypeName());
break;
case SECRET:
System.out.println("枚举名称(即默认自带的属性 name 的值)是：" + typeEnum.name());
System.out.println("排序值(默认自带的属性 ordinal 的值)是：" + typeEnum.ordinal());
System.out.println("枚举的自定义属性 typeName 的值是：" + typeEnum.getTypeName());
break;
case BALANCE:
System.out.println("枚举名称(即默认自带的属性 name 的值)是：" + typeEnum.name());
System.out.println("排序值(默认自带的属性 ordinal 的值)是：" + typeEnum.ordinal());
System.out.println("枚举的自定义属性 typeName 的值是：" + typeEnum.getTypeName());
break;
default:
System.out.println("default");
}
}
Entonces, es tiro racha de resultados.
hierro viejo que, después de leer esta enumeración, hay que entender un concepto, es decir, esta enumeración, que es un objetivo, tal y como lo define la clase del estudiante, clase de la persona, por lo que algunas de las clases.
Tienen tal concepto. Mientras una clase, que puede tener un constructor puede tener atributos, hay maneras.
A continuación, se ve, este lugar tiene dos atributos por defecto, un nombre, una es ordinal, estos dos atributos como el nombre y la edad que definir la clase del estudiante y como la clase de persona,
Sin embargo, este es el sistema viene con dos propiedades, que no tiene que definirlo.
También puede dar a las clases enumeradas, es decir para enumerar su propia declaración, tratará de propiedad aumento.
Tengo los ejemplos de código anteriores dentro TypeEnum que la enumeración, es tan seco, es muy sencillo para añadir un atributo personalizado typeName,
A pesar de que tiene su propio nombre, a continuación, tentativamente me llamó este atributo personalizado denominado alias ella.
Puedo ver que soy un ejemplo de los cuales es a través del método de construcción para escribir el valor inicial de esta propiedad a mi costumbre.
Por otra parte, este método de construcción no es, ni se está ejecutando pública, no creo que se puede tratar.
Además, no se puede atribuir el sistema viene con el nombre, en la asignación de función constructora, no hay por qué es.
