1. Antecedentes
javaAntes de que se introdujeran los tipos de enumeración en el lenguaje, el patrón común para representar tipos de enumeración era declarar un grupo con constantes int. Anteriormente, generalmente usamos public final staticel método para definir el código de la siguiente manera, usando 1 para representar la primavera, 2 para representar el verano, 3 para representar el otoño y 4 para representar el invierno.
public class Season {
public static final int SPRING = 1;
public static final int SUMMER = 2;
public static final int AUTUMN = 3;
public static final int WINTER = 4;
}
Este enfoque se denomina modo de enumeración int. Pero, ¿cuál es el problema con este modelo? Lo hemos estado usando durante tanto tiempo, por lo que debería estar bien. Usualmente el código que escribimos considerará su seguridad , facilidad de uso y legibilidad . Primero, consideremos su tipo seguridad . Por supuesto, este patrón no es de tipo seguro . Por ejemplo, diseñamos una función que requiere pasar un cierto valor de primavera, verano, otoño e invierno. Pero usando el tipo int, no podemos garantizar que el valor pasado sea legal. El código se ve así:
private String getChineseSeason(int season){
StringBuffer result = new StringBuffer();
switch(season){
case Season.SPRING :
result.append("春天");
break;
case Season.SUMMER :
result.append("夏天");
break;
case Season.AUTUMN :
result.append("秋天");
break;
case Season.WINTER :
result.append("冬天");
break;
default :
result.append("地球没有的季节");
break;
}
return result.toString();
}
public void doSomething(){
System.out.println(this.getChineseSeason(Season.SPRING));//这是正常的场景
System.out.println(this.getChineseSeason(5));//这个却是不正常的场景，这就导致了类型不安全问题
}
Los programas getChineseSeason(Season.SPRING)son nuestros métodos de uso previstos. Pero getChineseSeason(5)obviamente no, y la compilación pasará, no sabemos qué pasará en tiempo de ejecución. Obviamente, esto no se ajusta a Javala seguridad de tipo del programa.
A continuación, consideremos la legibilidad de este patrón . La mayoría de las veces que uso enumeraciones, necesito poder obtener fácilmente una expresión de cadena del tipo de enumeración. Si intimprimimos las constantes de enumeración, todo lo que vemos es un conjunto de números, lo cual no es muy útil. Podríamos pensar en usar Stringconstantes en lugar de intconstantes. Si bien proporciona cadenas imprimibles para estas constantes, puede causar problemas de rendimiento porque se basa en operaciones de comparación de cadenas, por lo que este modo tampoco es deseable. Teniendo en cuenta tanto la seguridad de tipo como la legibilidad del programa , se revelan las deficiencias intdel modo de enumeración. StringAfortunadamente, desde Java1.5el lanzamiento, se ha propuesto una solución alternativa que evita intlas Stringdesventajas del patrón de enumeración y brinda muchos beneficios adicionales. Ese es el tipo de enumeración ( enum type). Los siguientes capítulos presentarán la definición, características, escenarios de aplicación, ventajas y desventajas de los tipos enumerados.
2 definiciones
Un tipo enumerado ( enum type) se refiere a un tipo legal compuesto por un conjunto fijo de constantes. JavaUn tipo de enumeración se define mediante palabras clave enum. La siguiente es javala definición del tipo de enumeración.
public enum Season {
SPRING, SUMMER, AUTUMN, WINTER;
}
3 características
JavaLa declaración que define un tipo enumerado es concisa. Tiene las siguientes características:
- Use palabras clave
enum2) escriba el nombre, como aquíSeason3) una cadena de valores permitidos, como las cuatro estaciones de primavera, verano, otoño e invierno definidas anteriormente 4) la enumeración se puede definir solo en un archivo o incrustarse en otrasJavaclases
Además de estos requisitos básicos, los usuarios tienen otras opciones
- La enumeración puede implementar una o más interfaces (Interfaz) 6) Se pueden definir nuevas variables 7) Se pueden definir nuevos métodos 8) Se pueden definir clases que varían según valores de enumeración específicos
4 escenarios de aplicación
Tomando el ejemplo de seguridad de tipo mencionado en el fondo, reescriba ese código con un tipo de enumeración. el código se muestra a continuación:
public enum Season {
SPRING(1), SUMMER(2), AUTUMN(3), WINTER(4);
private int code;
private Season(int code){
this.code = code;
}
public int getCode(){
return code;
}
}
public class UseSeason {
/**
* 将英文的季节转换成中文季节
* @param season
* @return
*/
public String getChineseSeason(Season season){
StringBuffer result = new StringBuffer();
switch(season){
case SPRING :
result.append("[中文：春天，枚举常量:" + season.name() + "，数据:" + season.getCode() + "]");
break;
case AUTUMN :
result.append("[中文：秋天，枚举常量:" + season.name() + "，数据:" + season.getCode() + "]");
break;
case SUMMER :
result.append("[中文：夏天，枚举常量:" + season.name() + "，数据:" + season.getCode() + "]");
break;
case WINTER :
result.append("[中文：冬天，枚举常量:" + season.name() + "，数据:" + season.getCode() + "]");
break;
default :
result.append("地球没有的季节 " + season.name());
break;
}
return result.toString();
}
public void doSomething(){
for(Season s : Season.values()){
System.out.println(getChineseSeason(s));//这是正常的场景
}
//System.out.println(getChineseSeason(5));
//此处已经是编译不通过了，这就保证了类型安全
}
public static void main(String[] arg){
UseSeason useSeason = new UseSeason();
useSeason.doSomething();
}
}
[Chino: primavera, constante de enumeración: PRIMAVERA, datos: 1] [Chino: verano, constante de enumeración: VERANO, datos: 2] [Chino: otoño, constante de enumeración: OTOÑO, datos: 3] [Chino: invierno, constante de enumeración: INVIERNO, datos: 4]
Aquí hay una pregunta, ¿por qué agregaría campos a un tipo de enumeración? El propósito es asociar datos con sus constantes. Por ejemplo, 1 representa primavera y 2 representa verano.
5 resumen
Entonces, ¿cuándo debería usar enumeraciones? Siempre que se requiera un conjunto fijo de constantes, como días de la semana, estaciones del año, etc. O una colección de todos los valores que contiene conocidos antes de que lo compilemos. La enumeración de Java 1.5 puede cumplir con los requisitos de la mayoría de los programadores, y sus características concisas y fáciles de usar son muy destacadas.
6 Uso
Uso 1: Constante
public enum Color {
RED, GREEN, BLANK, YELLOW
}
Uso 2: cambiar
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;
}
}
}
Uso tres: agregar nuevos métodos a la enumeración
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 4: Anular métodos de enumeración
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 la interfaz
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);
}
}
Sexto uso: usar interfaces para organizar enumeraciones
public interface Food {
enum Coffee implements Food{
BLACK_COFFEE,DECAF_COFFEE,LATTE,CAPPUCCINO
}
enum Dessert implements Food{
FRUIT, CAKE, GELATO
}
}