Prólogo: En el camino a seguir, no tienes miedo de ser bloqueado por miles de personas, pero tienes miedo de rendirte; la vela de la vida no teme a los fuertes vientos ni a las olas, pero tú tienes miedo de tu falta de coraje.
I. Descripción general
El uso más básico de las clases de enumeración es lograr la seguridad de tipos. Las clases de enumeración están decoradas con la palabra clave enum:
enum class Direction {
//使用 enum 关键字修饰，在类头 class 前
NORTH, SOUTH, WEST, EAST
}
Cada constante de enumeración es un objeto y las constantes de enumeración están separadas por comas.
fun test() {
Direction.NORTH
Direction.SOUTH
Direction.WEST
Direction.EAST
}
Se puede acceder a las constantes de enumeración sin crear una instancia de la clase de enumeración, llamando 枚举类.常量名.
Debido a que cada enumeración es una instancia de la clase enum, se pueden inicializar.
enum class Color(val rgb: Int) {
RED(0xFF0000),
GREEN(0x00FF00),
BLUE(0x0000FF)
}
A través del constructor de la clase de enumeración, cada enumeración tiene este constructor y necesita inicializar el valor. Por ejemplo, lo anterior RED(rgb: Int)necesita inicializar el valor.
2. Clase anónima para constantes de enumeración.
Las constantes de enumeración también pueden declarar sus propias clases anónimas con sus métodos correspondientes, así como anular los métodos base.
enum class ConsoleColor(var argb: Int) {
RED(0xFF0000) {
override fun print() {
//必须重写的
println("枚举常量 RED")
}
},
WHITE(0xFFFFFF) {
override fun print() {
println("枚举常量 WHITE")
}
},
BLACK(0x000000) {
override fun print() {
println("枚举常量 BLACK")
}
},//枚举常量之间使用逗号“,”分隔，最后一个常量必须使用分号“;”分隔
GREEN(0x00FF00) {
override fun print() {
println("枚举常量 GREEN")
}
};
abstract fun print()//抽象方法，定义在枚举类内部，而且必须在枚举常量后面
}
- Las comas se utilizan para separar las constantes de enumeración
,. Si se define algún miembro (variables y métodos), se utilizan puntos y comas para;separar la definición constante y la definición del miembro; - Se debe proporcionar un método abstracto, definido dentro de la clase de enumeración y debe estar detrás de la constante de enumeración.
fun test() {
ConsoleColor.BLACK
}
Los datos de impresión son los siguientes:
枚举常量 BLACK
Nota: Las clases de enumeración no pueden contener tipos anidados que no sean clases internas.
Tercero, implemente la interfaz en la clase de enumeración.
Al igual que Java, las clases enum de Kotlin pueden implementar interfaces. Una clase de enumeración puede implementar una interfaz, proporcionar una implementación de miembro de interfaz única para todas las constantes de enumeración o proporcionar una implementación de miembro de interfaz separada para cada entrada en su clase anónima. Esto se logra agregando la interfaz a la declaración de clase de enumeración. como sigue:
interface ShareListener {
fun invite()
}
enum class State : ShareListener {
NORMAL {
override fun invite() {
println("实现接口 NORMAL")
}
},
ERROR;
override fun invite() {
println("实现接口 enum")
}
}
Las clases de enumeración de Kotlin pueden implementar métodos de interfaz predeterminados, y los miembros constantes de la clase de enumeración también pueden implementar sus propios métodos de interfaz. Primero se llaman los métodos implementados por los miembros constantes de la clase de enumeración, seguidos por los métodos implementados por la clase de enumeración.
fun test() {
State.NORMAL
State.ERROR
}
Los datos de impresión son los siguientes:
实现接口 NORMAL
实现接口 enum
Cuarto, el uso de constantes de enumeración.
Cada constante de enumeración tiene atributos para obtener su nombre y posición en la declaración de clase de enumeración, incluidos name（枚举常量名）y ordinal（枚举常量位置）.
enum class State {
NORMAL,
ERROR
}
fun test() {
val normal = State.NORMAL.name //常量名
val normalIndex = State.NORMAL.ordinal //常量下标
val error = State.ERROR.name
val errorIndex = State.ERROR.ordinal
println("枚举常量的使用：name == $normal | ordinal == $normalIndex ")
println("枚举常量的使用：name == $error | ordinal == $errorIndex ")
}
Los datos de impresión son los siguientes:
枚举常量的使用：name == NORMAL | ordinal == 0
枚举常量的使用：name == ERROR | ordinal == 1
Las clases de enumeración en Kotlin tienen métodos compuestos que permiten enumerar constantes de enumeración definidas y obtener constantes de enumeración por nombre. Las firmas de estos métodos son las siguientes:
EnumClass.valueOf(value: String): EnumClass
EnumClass.values(): Array<EnumClass>
Si el nombre especificado no coincide con ninguna constante de enumeración definida en la clase, valueOf()el método generará una excepción IllegalArgumentException; si values()la posición del subíndice no coincide, se generará una excepción de subíndice fuera de rango.
fun test() {
val normalName = State.valueOf("NORMAL") //指定名称常量
val errorOrdinal = State.values()[1] //指定下标位置常量
println("枚举常量的使用：name == $normalName")
println("枚举常量的使用：name == $errorOrdinal")
}
Los datos de impresión son los siguientes:
枚举常量的使用：name == NORMAL
枚举常量的使用：name == ERROR
A partir de Kotlin 1.1, puedes usar enumValues<T>()y enumValueOf<T>()combinar con genéricos para acceder a constantes en clases de enumeración:
fun test() {
val stateName = enumValues<State>().joinToString {
it.name } //打印所有常量
val stateError = enumValueOf<State>("ERROR") //单个常量
println("枚举常量的使用：stateName == $stateName")
println("枚举常量的使用：stateError == $stateError")
}
Los datos de impresión son los siguientes:
枚举常量的使用：stateName == NORMAL, ERROR
枚举常量的使用：stateError == ERROR
Las constantes de enumeración también implementan la interfaz Comparable y su orden natural es el orden en que se definen en la clase de enumeración.
Dirección de origen: https://github.com/FollowExcellence/KotlinDemo-master
Presta atención, no te pierdas.
Bueno, todos, lo anterior es todo el contenido de este artículo, las personas que pueden ver aquí son todos talentos .
Lo asumo, gracias por tu apoyo y reconocimiento, tus me gusta son la mayor motivación para mi creación, ¡nos vemos en el próximo artículo!
Si hay algún error en este blog, por favor critica y aconseja, ¡muchas gracias!
Si quieres convertirte en un excelente desarrollador de Android, aquí tienes el marco de conocimientos que debes dominar y avanzar hacia tu sueño paso a paso. ¡Sigue moviendote!