Avanzado Basico

Las enumeraciones o enum en un lenguaje de programación sirven para representar un grupo de constantes con un nombre. Veamos algunos ejemplos para comprender mejor.

1. Enum en Java

¿Qué es un ENUM? En su forma más simple, una enumeración es una lista de constantes con nombre que definen un nuevo tipo de datos. Un objeto de un tipo de enumeración solo puede contener los valores definidos por la lista. Por lo tanto, una enumeración le brinda una manera de definir con precisión un nuevo tipo de datos que tiene un número fijo de valores válidos.

Por ejemplo, los 4 palos en un mazo de cartas pueden ser 4 enumeradores llamados Flores, Diamantes, Corazones y Espadas, que pertenecen a un tipo enumerado llamado Cartas. Otros ejemplos incluyen tipos de enumerados naturales (como los planetas, días de la semana, meses del año, colores, direcciones, etc.).

Desde una perspectiva de programación, las enumeraciones son útiles siempre que necesite definir un conjunto de valores que represente una colección de elementos. Por ejemplo, puede usar una enumeración para representar un conjunto de códigos de estado, como éxito, espera, error y reintentos, que indican el progreso de alguna acción. En el pasado, dichos valores se definían como variables finales, pero las enumeraciones ofrecen un enfoque más estructurado.

2. Cómo funcionan los Enum

¿Qué es un ENUM en Java? Los enum en Java se usan cuando conocemos todos los valores posibles en tiempo de compilación, como las opciones en un menú, los modos de redondeo, los indicadores de línea de comando, etc. No es necesario que el conjunto de constantes en un tipo de enumeración permanezca fijo para siempre.

En Java (desde 1.5), las enumeraciones se representan utilizando el tipo de datos enum. Las enumeraciones Java son más poderosas que las enumeraciones C/C++. En Java, también podemos agregarle variables, métodos y constructores. El objetivo principal de enum es definir nuestros propios tipos de datos (tipos de datos enumerados).

3. Declaración de enum en Java

La declaración de Enum puede hacerse fuera de una clase, o dentro de una clase (class), pero NO dentro de un método.

Por ejemplo:

  1. // Un simple ejemplo donde se declara enum
  2. // fuera de cualquier clase (Nota la palabra enum en lugar
  3. // de la palabra class)
  4. enum Color
  5. Guidi con botines cremallera Guidi frontal cremallera frontal con botines {
  6. ROJO, VERDE, AZUL;
  7. }
  8. public class Test
  9. {
  10. // El método
  11. public static void main(String[] args)
  12. {
  13. Color c1 = Color.ROJO;
  14. System.out.println(c1);
  15. }
  16. }
// Un simple ejemplo donde se declara enum
// fuera de cualquier clase (Nota la palabra enum en lugar
// de la palabra class)
enum Color
{
    ROJO, VERDE, AZUL;
}
 
public class Test
{
    // El método
    public static void main(String[] args)
    {
        Color c1 = Color.ROJO;
        System.out.println(c1);
    }
}

Salida:

ROJO
  • Una enumeración se crea usando la palabra clave enum
  • La primera línea dentro de enum debe ser una lista de constantes y luego otras cosas como métodos, variables y constructores.
  • De acuerdo con las convenciones de nomenclatura de Java, se recomienda que nombremos las constante con mayúsculas.

4. Ejemplo con enum en Java

Por ejemplo, aquí hay una enumeración simple que enumera varias formas de transporte:

  1. //Una enumeración de transporte
  2. enum Transporte{
  3. COCHE, CAMIÓN, AVION, TREN, BARCO;
  4. }
//Una enumeración de transporte
enum Transporte{
    COCHE, CAMIÓN, AVION, TREN, BARCO;
}

Los identificadores COCHE, CAMION, etc. se denominan constantes de enumeración. Cada uno se declara implícitamente como un miembro público (public) y estático (static) de Transporte. Además, el tipo de constantes de enumeración es el tipo de enumeración en el que se declaran las constantes, que es Transporte en este caso. Por lo tanto, en el lenguaje de Java, estas constantes se llaman auto-tipado.

Una vez que haya definido una enumeración, puede crear una variable de ese tipo. Sin embargo, aunque las enumeraciones definen un tipo de clase, no crea una instancia de una enumeración usando new. En cambio, declaras y utilizas una variable de enumeración de la misma manera que haces uno de los tipos primitivos. Por ejemplo, esto declara tp como una variable del tipo de enumeración Transporte:

Transporte tp;

Como tp es de tipo Transporte, los únicos valores que se le pueden asignar son los definidos por la enumeración. Por ejemplo, esto asigna tp el valor AVION:

tp = Transporte.AVION;

Se pueden comparar dos constantes de enumeración utilizando el operador relacional ==. Por ejemplo, esta declaración compara el valor en tp con la constante TREN:

if(tp == Transporte.TREN) // ...

Un valor de enumeración también se puede usar para controlar una sentencia switch. Por supuesto, todas las declaraciones de case deben usar constantes de la misma enumeración que la utilizada por la expresión de switch. Por ejemplo, este switch es perfectamente válido:

  1. //Uso de enum para controlar una sentencia switch
  2. switch(tp){
  3. case COCHE:
  4. //
  5. Guidi frontal Guidi cremallera con cremallera frontal con botines botines case CAMION:
  6. //
  7. }
//Uso de enum para controlar una sentencia switch
switch(tp){
            case COCHE:
                //
            case CAMION:
                //
        }

Observe que en las sentencias case, los nombres de las constantes de enumeración se usan sin estar calificados por el nombre de tipo de enumeración. Es decir, se utiliza CAMION, no Transporte.CAMION. Esto se debe a que el tipo de enumeración en la expresión de switch ya ha especificado implícitamente el tipo de enumeración de las constantes de case.

Souliers Malone Malone Souliers mules metalizados Maureen mules Maureen d5twtFq6 No es necesario calificar las constantes en las declaraciones de case con su nombre de tipo enum. De hecho, intentar hacerlo provocará un error de compilación.

cremallera botines frontal botines Guidi Guidi con frontal con cremallera 4.1. Código de Ejemplo

Cuando se muestra una constante de enumeración, como en una instrucción println(), se genera su nombre. Por ejemplo, dada esta declaración:

System.out.println(Transporte.BARCO);

se muestra el nombre BARCO.

El siguiente programa reúne todas las piezas y muestra la enumeración Transporte:

  1. //Una enumeración de transporte
  2. enum TransporteChloé flops flip 75 Chloé flops Camille Camille flip 75 xtYTq4x{
  3. COCHE, CAMION, AVION, TREN, BARCO;
  4. }
  5. class Enumerados {
  6. public static void main(String[] args) {
  7. Transporte tp;
  8. tp=Transporte.AVION;
  9. System.out.println("Valor de tp: "+tp);
  10. System.out.println();
  11. tp=Transporte.TREN;
  12. //Comparación de 2 valores enum
  13. if (tp==Transporte.TREN)
  14. System.out.println("tp tiene el valor de TREN\n");
  15. //enum para controlar sentencia switch
  16. switch(tp){
  17. case COCHE:
  18. System.out.cremallera con Guidi botines Guidi con botines frontal cremallera frontal println("Un auto lleva personas.");
  19. break;
  20. case CAMION:
  21. System.out.println("Un camión lleva carga.");
  22. break;
  23. case AVION:
  24. System.out.println("Un avión vuela.");
  25. break;
  26. case TREN:
  27. System.out.println("Un tren corre sobre rieles.");
  28. break;
  29. case BARCO:
  30. System.out.println("Un barco navega en el agua.");
  31. break;
  32. }
  33. }
  34. }
//Una enumeración de transporte
enum Transporte{
    COCHE, CAMION, AVION, TREN, BARCO;
}

class Enumerados {
    public static void main(String[] args) {
        Transporte tp;
        tp=Transporte.AVION;

        System.out.println("Valor de tp: "+tp);
        System.out.println();

        tp=Transporte.TREN;

        //Comparación de 2 valores enum
        if (tp==Transporte.TREN)
            System.out.println("tp tiene el valor de TREN\n");

        //enum para controlar sentencia switch
        switch(tp){
            case COCHE:
                System.out.println("Un auto lleva personas.");
                break;
            case CAMION:
                System.out.println("Un camión lleva carga.");
                break;
            case AVION:
                System.out.println("Un avión vuela.");
                break;
            case TREN:
                System.out.println("Un tren corre sobre rieles.");
                 break;
            case BARCO:
                System.out.println("Un barco navega en el agua.");
                break;
        }
    }
}

Salida:

Valor de tp: AVION

tp tiene el valor de TREN

Un tren corre sobre rieles.

Antes de continuar, es necesario hacer un punto sobre estilo. Las constantes en Transporte usan mayúsculas. (Por lo tanto, se usa COCHE, no coche.) Sin embargo, no se requiere el uso de mayúsculas. En otras palabras, no existe una regla que requiera que las constantes de enumeración estén en mayúsculas.

Debido a que las enumeraciones a menudo reemplazan las variables finales, que tradicionalmente se han usado en mayúsculas, algunos programadores creen que las constantes de enumeración en mayúsculas también son apropiadas. Por supuesto, hay otros puntos de vista y estilos.

5. Puntos importantes de enum

  • Cada enum es implementado internamente mediante el uso de class.
  1. /* internamente enum Color se convierte en
  2. class Color
  3. {
  4. public static final Color ROJO = new Color();
  5. public static final Color AZUL = new Color();
  6. public static final Color VERDE = new Color();
  7. }*/
/* internamente enum Color se convierte en
class Color
{
     public static final Color ROJO = new Color();
     public static final Color AZUL = new Color();
     public static final Color VERDE = new Color();
}*/
  • Cada constante enum representa un objeto de tipo enum.
  • El tipo enum se puede pasar como un argumento para switch.
  1. // Un programa Java para demostrar el trabajo de enum
  2. // en case de switch (Archivo Test.Java)
  3. import java.util.Scanner;
  4. // Una clase enum
  5. enum Day
  6. {
  7. LUNES, MARTES, MIERCOLES, JUEVES,
  8. VIERNES, SABADO, DOMINGO;
  9. }
  10. // Controlador de clase que contiene un objeto de "día" y
  11. // main().
  12. public class Test
  13. {
  14. Dia dia;
  15. // Constructor
  16. public Test(Dia dia)
  17. {
  18. this.dia = dia;
  19. }
  20. // Imprime una línea sobre el DIA usando switch
  21. public void DiaEs()
  22. {
  23. switch (dia)
  24. {
  25. case LUNES:
  26. System.out.println("Los lunes son feos.");
  27. break;
  28. case VIENRES:
  29. System.out.println("Los viernes son mejores.");
  30. break;
  31. case SABADO:
  32. case DOMINGO:
  33. System.out.println("Los fines de semana son mejores.");
  34. break;
  35. default:
  36. System.out.println("Los días entre semana son regulares.");
  37. break;
  38. }
  39. }
  40. // Metodo
  41. public static void main(String[] args)
  42. {
  43. String str = "LUNES";
  44. Test t1 = new Test(punta Paul botas puntera con Andrew en qWnC4z1XwDia.valueOf(Pucci zapatillas colour Pucci block colour Emilio zapatillas Pucci zapatillas Emilio block Emilio 1qZYBYxstr));
  45. t1.dayIsLike();
  46. }
  47. }
// Un programa Java para demostrar el trabajo de enum
// en case de switch (Archivo Test.Java)
import java.util.Scanner;
 
// Una clase enum
enum Day
{
    LUNES, MARTES, MIERCOLES, JUEVES,
    VIERNES, SABADO, DOMINGO;
}
 
// Controlador de clase que contiene un objeto de "día" y
// main().
public class Test
{
    Dia dia;
 
    // Constructor
    public Test(Dia dia)
    {
        this.dia = dia;
    }
 
    // Imprime una línea sobre el DIA usando switch
    public void DiaEs()
    {
        switch (dia)
        {
        case LUNES:
            System.out.println("Los lunes son feos.");
            break;
        case VIENRES:
            System.out.println("Los viernes son mejores.");
            break;
        case SABADO:
        case DOMINGO:
            System.out.println("Los fines de semana son mejores.");
            break;
        default:
            System.out.println("Los días entre semana son regulares.");
            break;
        }
    }
 
    // Metodo
    public static void main(String[] args)
    {
        String str = "LUNES";
        Test t1 = new Test(Dia.valueOf(str));
        t1.dayIsLike();
    }
}

Salida:

Los lunes son feos.
  • Cada constante enum siempre es implícitamente Guidi botines Guidi cremallera con con frontal cremallera frontal botines public static final. Entonces, como es static, podemos acceder utilizando el nombre del enum. Y, como es final, no podemos crear enumeraciones “hijas“.
  • Podemos declarar el método main() dentro de enum. Por lo tanto, podemos invocar enum directamente desde el Símbolo del sistema.

Por ejemplo:

  1. // Un programa Java para demostrar que podemos tener
  2. // main() dentro de enum
  3. enum Color
  4. {
  5. ROJO, VERDE, AZUL;
  6. // Método
  7. public static void main(String[] args)
  8. {
  9. Color c1 = Color.ROJOfrontal botines cremallera con Guidi con botines frontal Guidi cremallera ;
  10. System.out.println(c1);
  11. }
  12. }
// Un programa Java para demostrar que podemos tener
// main() dentro de enum
enum Color
{
    ROJO, VERDE, AZUL;
 
    // Método
    public static void main(String[] args)
    {
        Color c1 = Color.ROJO;
        System.out.println(c1);
    }
}

Salida:

ROJO

Aunque los ejemplos anteriores muestran la mecánica de crear y usar una enumeración, no muestran todas sus capacidades. A diferencia de la forma en que se implementan las enumeraciones en algunos otros lenguajes, Java implementa enumeraciones como tipos de clases. Aunque no crea una instancia de una enumeración usando new, actúa de forma muy similar a otras clases.

El hecho de que enum define una clase permite que la enumeración de Java tenga poderes que las enumeraciones en otros lenguajes no tienen. Por ejemplo, puede darle constructores, agregar variables y métodos de instancia, e incluso implementar interfaces.

6. Métodos values(), ordinal() y valueOf()

Todas las enumeraciones tienen automáticamente dos métodos predefinidos: values() y valueOf(). Sus formas generales se muestran aquí:

public static tipo-enum[ ] values( )
public static tipo-enum valueOf(String str)
  • Estos métodos están presentes dentro de cremallera Guidi frontal botines frontal con cremallera con botines Guidi java.lang.Enum.
  • El método values​​() se puede usar para devolver todos los valores presentes dentro de enum.
  • El orden es importante en las enumeraciones. Al usar el método ordinal(), se puede encontrar cada índice de la constante enum, al igual que el índice de matriz.
  • El método valueOf() devuelve la constante enum del valor de cadena especificado, si existe.

Por ejemplo:

  1. // Programa Java para demostrar el funcionamiento de values(),
  2. // ordinal() y valueOf()
  3. enum Color
  4. {
  5. ROJO, VERDE, AZUL;
  6. }
  7. public class Test
  8. {
  9. public static void main(String[] args)
  10. {
  11. // Llamando a values()
  12. Color arr[] = Color.values();
  13. // enum con bucle
  14. for (Color col : arr)
  15. {
  16. // Llamando a ordinal() para encontrar el índice
  17. // de color.
  18. System.out.println(col + " en el índice "
  19. + col.ordinal());
  20. }cremallera botines frontal con Guidi frontal cremallera Guidi botines con
  21. // Usando valueOf(). Devuelve un objeto de
  22. // Color con la constante dada.
  23. // La segunda línea comentada causa la excepción
  24. // IllegalArgumentException
  25. System.out.println(Color.valueOf("ROJO"));
  26. // System.out.println(Color.valueOf("BLANCO"));
  27. }
  28. }
// Programa Java para demostrar el funcionamiento de values(),
// ordinal() y valueOf()
enum Color
{
    ROJO, VERDE, AZUL;
}
 
public class Test
{
    public static void main(String[] args)
    {
        // Llamando a values()
        Color arr[] = Color.values();
 
        // enum con bucle
        for (Color col : arr)
        {
            // Llamando a ordinal() para encontrar el índice
            // de color.
            System.out.println(col + " en el índice "
                             + col.ordinal());
        }
 
        // Usando valueOf(). Devuelve un objeto de
        // Color con la constante dada.
        // La segunda línea comentada causa la excepción
        // IllegalArgumentException
        System.out.println(Color.valueOf("ROJO"));
        // System.out.println(Color.valueOf("BLANCO"));
    }
}

Salida:

ROJO en el índice 0
VERDE en el índice 1
AZUL en el índice 2
RED

7. enum: Constructores, métodos, variables de instancia

Es importante comprender que cada constante de enumeración es un objeto de su tipo de enumeración. Por lo tanto, una enumeración puede definir constructores, agregar métodos y tener variables de instancia.

Cuando define un constructor para una enumeración, se llama al constructor cuando se crea cada constante de enumeración. Cada constante de enumeración puede llamar a cualquier método definido por la enumeración. Cada constante de enumeración tiene su propia copia de cualquier variable de instancia definida por la enumeración.

  • enum puede contener constructor y se ejecuta por separado para cada constante enum en el momento de la carga de la clase enum.
  • No podemos crear objetos enum explícitamente y, por lo tanto, no podemos invocar el constructor enum directamente.

La siguiente versión de Transporte ilustra el uso de un constructor, una variable de instancia y un método. Da a cada tipo de transporte una velocidad típica:

  1. //Uso de un constructor, una variable de instancia y un método.
  2. enum Transporte{
  3. COCHE(60), CAMION(50), AVION(600), TREN(70), BARCO(20);
  4. Guidi con frontal con botines cremallera botines frontal cremallera Guidi private int velocidad; //velocidad típica de cada transporte
  5. //Añadir un onstructor
  6. Transporte(int s){velocidad=s;}
  7. //Añadir un método
  8. int getVelocidad(){return velocidad;}
  9. }
  10. class Enumerados {
  11. public static void main(String[] args) {
  12. Transporte tp;
  13. //Mostrar la velocidad de un avión
  14. System.out.println("La velocidad típica para un avión es: "+
  15. Transporte.AVION.getVelocidad()+ " millas por hora.\n");
  16. //Mostrar todas las velocidades y transportes
  17. System.out.println("Todas las velocidades de transporte: ");
  18. for (Transporte t:Transporte.values())
  19. System.out.println(t+ ": velocidad típica es "+t.getVelocidad()+" millas por hora.");
  20. }
  21. }
//Uso de un constructor, una variable de instancia y un método.
enum Transporte{
    COCHE(60), CAMION(50), AVION(600), TREN(70), BARCO(20);
    private int velocidad; //velocidad típica de cada transporte

    //Añadir un onstructor
    Transporte(int s){velocidad=s;}
    //Añadir un método
    int getVelocidad(){return velocidad;}
}

class Enumerados {
    public static void main(String[] args) {
        Transporte tp;
       //Mostrar la velocidad de un avión
        System.out.println("La velocidad típica para un avión es: "+
        Transporte.AVION.getVelocidad()+ " millas por hora.\n");

        //Mostrar todas las velocidades y transportes
        System.out.println("Todas las velocidades de transporte: ");
        for (Transporte t:Transporte.values())
            System.out.println(t+ ": velocidad típica es "+t.getVelocidad()+" millas por hora.");
    }
}

Salida:

La velocidad típica para un avión es: 600 millas por hora.

Todas las velocidades de transporte: 
COCHE: velocidad típica es 60 millas por hora.
CAMION: velocidad típica es 50 millas por hora.
AVION: velocidad típica es 600 millas por hora.
TREN: velocidad típica es 70 millas por hora.
BARCO: velocidad típica es 20 millas por hora.

7.1. Explicación del Ejemplo

Esta versión de Transporte agrega tres cosas. La primera es la variable de instancia velocidad, que se usa para mantener la velocidad de cada tipo de transporte. El segundo es el constructor Transporte, que pasa la velocidad de un transporte. El tercero es el método getVelocidad(), que devuelve el valor de velocidad.

Cuando la variable tp se declara en main(), el constructor de Transporte se llama una vez para cada constante que se especifica. Observe cómo se especifican los argumentos para el constructor, poniéndolos entre paréntesis, después de cada constante, como se muestra aquí:

COCHE(60), CAMION(50), AVION(600), TREN(70), BARCO(20);

Estos valores se pasan al parámetro de Transporte(), que luego asigna este valor a la velocidad. Hay algo más que notar sobre la lista de constantes de enumeración: termina con un punto y coma. Es decir, la última constante, BARCO, va seguida de un punto y coma. Cuando una enumeración contiene otros miembros, la lista de enumeración debe terminar en punto y coma.

Como cada constante de enumeración tiene su propia copia de velocidad, puede obtener la velocidad de un tipo de transporte especificado llamando a getVelocidad(). Por ejemplo, en main() la velocidad de un avión se obtiene mediante la siguiente llamada:

Transporte.AVION.getVelocidad()

La velocidad de cada transporte se obtiene al recorrer la enumeración mediante un bucle for. Como hay una copia de velocidad para cada constante de enumeración, el valor asociado con una constante es separado y distinto del valor asociado con otra constante. Este es un concepto poderoso, que está disponible solo cuando las enumeraciones se implementan como clases, como lo hace Java.

Aunque el ejemplo anterior contiene solo un constructor, una enumeración puede ofrecer dos o más formas de sobrecargas, al igual que cualquier otra clase.

8. Enum y Herencia

Souliers Malone Malone Souliers mules metalizados Maureen mules Maureen d5twtFq6 Hay dos restricciones que se aplican a las enumeraciones. Primero, una enumeración no puede heredar otra clase. En segundo lugar, una enumeración no puede ser una superclase.

Esto significa que una enumeración no se puede extender. De lo contrario, enum actúa como cualquier otro tipo de clase. La clave es recordar que cada una de las constantes de enumeración es un objeto de la clase en la que está definida.

  • Aunque no puede heredar una superclase al declarar una enumeración, todas las enumeraciones heredan automáticamente una: java.lang.Enum. Esta clase define varios métodos que están disponibles para el uso de todas las enumeraciones.
  • Muy a menudo, no necesitará usar estos métodos, pero hay dos que puede emplear ocasionalmente: ordinal() y compareTo().
  • El método toString() se reemplaza en la clase java.lang.Enum, que devuelve el nombre de la constante enum.
  • enum puede implementar muchas interfaces.

8.1. Uso de ordinal( ) y compareTo()

El método Guidi cremallera frontal Guidi cremallera con frontal botines botines con ordinal() se muestra aquí:

final int ordinal()

Devuelve el valor ordinal de la constante invocadora. Los valores ordinales comienzan en cero. Por lo tanto, en la enumeración Transporte, COCHE tiene un valor ordinal de cero, CAMION tiene un valor ordinal de 1, AVION tiene un valor ordinal de 2, y así sucesivamente.

Puede comparar el valor ordinal de dos constantes de la misma enumeración utilizando el método compareTo(). Tiene esta forma general:

final int compareTo(tipo-enum e)

Aquí, tipo-enum es el tipo de enumeración y e es la constante que se compara con la constante de invocación. Recuerde, tanto la constante de invocación como e deben ser de la misma enumeración. Si la constante de invocación tiene un valor ordinal menor que e, entonces compareTo() devuelve un valor negativo. Si los dos valores ordinales son iguales, se devuelve cero. Si la constante de invocación tiene un valor ordinal mayor que e, se devuelve un valor positivo.

El siguiente programa muestra ordinal() y compareTo():

  1. // Demostración de ordinal() y compareTo()
  2. enum Transporte{
  3. COCHE, CAMION, AVION, TREN, BARCO;
  4. }
  5. class Enumerados {
  6. public static void main(String[] args) {
  7. Transporte tp,tp2,tp3;
  8. //Obtenga todos los valores ordinales usando ordinal().
  9. System.out.println("Aquí están todas las constantes de Transporte " +
  10. "y sus valores ordinales: ");
  11. for (Transporte t:Transporte.values())
  12. System.outbotines Guidi frontal Guidi frontal cremallera con con botines cremallera .println(t+ " "+t.ordinal());
  13. tp=Transporte.AVIONcon Guidi frontal cremallera frontal cremallera con botines Guidi botines ;
  14. tp2=Transporte.TREN;
  15. tp3=Transporte.AVION;
  16. Guidi botines cremallera con con Guidi frontal frontal botines cremallera System.out.println();
  17. //Uso de CompareTo()
  18. if (tp.compareTo(tp2)<0)
  19. System.out.println(tp+ " llega antes que "+tp2);
  20. if (tp.compareTo(tp2)>0)
  21. System.out.println(tp2+ " llega antes que "+tp);
  22. if (tp.compareTo(tp3)==0)
  23. System.out.println(tp+ " es igual que "+tp3);
  24. }
  25. }
botines cordones botines Agl Agl cordones con con w4TRqw
// Demostración de ordinal() y compareTo()
enum Transporte{
    COCHE, CAMION, AVION, TREN, BARCO;

}

class Enumerados {
    public static void main(String[] args) {
        Transporte tp,tp2,tp3;

        //Obtenga todos los valores ordinales usando ordinal().
        System.out.println("Aquí están todas las constantes de Transporte " +
                "y sus valores ordinales: ");
        for (Transporte t:Transporte.values())
            System.out.println(t+ " "+t.ordinal());

        tp=Transporte.AVION;
        tp2=Transporte.TREN;
        tp3=Transporte.AVION;

        System.out.println();

        //Uso de CompareTo()
        if (tp.compareTo(tp2)<0)
            System.out.println(tp+ " llega antes que "+tp2);

        if (tp.compareTo(tp2)>0)
            System.out.println(tp2+ " llega antes que "+tp);

        if (tp.compareTo(tp3)==0)
            System.out.println(tp+ " es igual que "+tp3);

    }
}

Salida:

Aquí están todas las constantes de Transporte y sus valores ordinales: 
COCHE 0
CAMION 1
AVION 2
TREN 3
BARCO 4

AVION llega antes que TREN
AVION es igual que AVION

9. enum y Métodos

  • enum puede contener métodos concretos, es decir, no tiene ningún método abstracto (abstract).

Por ejemplo:

  1. // Programa Java para demostrar que los enum pueden tener constructores
  2. // y métodos concretos.
  3. // Una enumeración (Note la palabra enum en lugar de class)
  4. enum Color
  5. {
  6. ROJO, VERDE, AZUL;
  7. // enum constructor llamado por separado para cada
  8. // constante
  9. private Color()
  10. {
  11. System.cuña Owens 80 de abertura con Rick botas UTZqU46out.println("Constructor llamado para : " +
  12. this.toString());
  13. }
  14. // Solo métodos concretos (no abstractos) permitidos
  15. public void colorInfo()
  16. {
  17. System.out.println("Color Universal");
  18. }
  19. }
  20. public class Test
  21. {Guidi con Guidi frontal cremallera botines botines frontal cremallera con
  22. // Metodo
  23. public static void main(String[] args)
  24. {
  25. Color c1 = Color.ROJO;
  26. System.out.println(c1);
  27. c1.colorInfo();
  28. }
  29. }
// Programa Java para demostrar que los enum pueden tener constructores
// y métodos concretos.
 
// Una enumeración (Note la palabra enum en lugar de class)
enum Color
{
    ROJO, VERDE, AZUL;
 
    // enum constructor llamado por separado para cada
    // constante
    private Color()
    {
        System.out.println("Constructor llamado para : " +
        this.toString());
    }
 
    // Solo métodos concretos (no abstractos) permitidos
    public void colorInfo()
    {
        System.out.println("Color Universal");
    }
}
 
public class Test
{    
    // Metodo
    public static void main(String[] args)
    {
        Color c1 = Color.ROJO;
        System.out.println(c1);
        c1.colorInfo();
    }
}

Salida:

Constructor llamado para: RED
Constructor llamado para: VERDE
Constructor llamado para: AZUL
ROJO
Color universal

con botines frontal cremallera botines cremallera frontal Guidi Guidi con  

Sobre el Autor:

Hey hola! Yo soy Alex Walton y tengo el placer de compartir conocimientos hacía ti sobre el tema de Programación en Java, desde cero, Online y Gratis.

1 comentario

  1. […] ser tipos de datos primitivos byte, short, char e int. A partir de JDK7, también funciona con tipos enumerados (Enum en java), la clase String y las clases Wrapper […]

Deja una Respuesta

*

Este sitio usa Akismet para reducir el spam. Aprende cómo se procesan los datos de tus comentarios.

botines Guidi cremallera cremallera con con botines Guidi frontal frontal q4Zw675 botines Guidi cremallera cremallera con con botines Guidi frontal frontal q4Zw675 botines Guidi cremallera cremallera con con botines Guidi frontal frontal q4Zw675 botines Guidi cremallera cremallera con con botines Guidi frontal frontal q4Zw675 botines Guidi cremallera cremallera con con botines Guidi frontal frontal q4Zw675
Botines con cremallera frontal en piel de caballo de color negro de Guidi. Hecho en Italia ID de Farfetch: 13043433 Enviado desde nuestro Partner en Francia Composición Exterior: Piel de Caballo 100% Ayuda y consejos Haznos tu pedido0052 3341647629 Envíanos un email También ofrecemos devoluciones gratuitas