Clase Java.lang.Enum en Java

Posted on by Rudeus Greyrat

La clase Enum está presente en el paquete java.lang. Es la clase base común de todos los tipos de enumeración del lenguaje Java. Para obtener información sobre las enumeraciones, consulte la enumeración en Java

Declaración de clase

public abstract class Enum<E extends Enum>
extends Object
implements Comparable, Serializable

Como podemos ver, Enum es una clase abstracta , por lo que no podemos crear objetos de la clase Enum.

Métodos en la clase Enum

La clase Enum proporciona 10 métodos útiles. La mayoría de ellos se anulan desde la clase Object . Estos métodos se declaran como finales en la clase Enum, por lo que el programador no puede modificar ninguna de las constantes de enumeración.

  1. final String name() : este método devuelve el nombre de esta constante de enumeración, que es exactamente como se declaró en su declaración de enumeración. 
    Syntax : 
public final String name()
Parameters : 
NA
Returns :
the name of this enum constant

    // Java program to demonstrate name() method
    enum Color
    {
        RED, GREEN, BLUE;
    }
       
    public class Test
    {
        // Driver method
        public static void main(String[] args)
        {
            Color c1 = Color.RED;
            System.out.print("Name of enum constant: ");
      
            // name method
            System.out.println(c1.name());
        }
    }

    Producción:

    Name of enum constant: RED
  2. final int ordinal() : este método devuelve el índice de esta constante de enumeración. 
    Syntax : 
public final int ordinal()
Parameters : 
NA
Returns :
the ordinal of this enumeration constant

    // Java program to demonstrate ordinal() method
    enum Color
    {
        RED, GREEN, BLUE;
    }
       
    public class Test
    {
        // Driver method
        public static void main(String[] args)
        {
            Color c1 = Color.GREEN;
            System.out.print("ordinal of enum constant "+c1.name()+" : ");
      
            // ordinal method
            System.out.println(c1.ordinal());
        }
    }

    Producción:

    ordinal of enum constant GREEN : 1
  3. String toString() : este método devuelve un objeto String que representa esta constante de enumeración. Este método es el mismo que el método name(). 
    Syntax : 
public String toString()
Parameters : 
NA
Returns :
a string representation of this enumeration constant
Overrides :
toString in class Object

    // Java program to demonstrate toString() method
    enum Color
    {
        RED, GREEN, BLUE;
    }
       
    public class Test
    {
        // Driver method
        public static void main(String[] args)
        {
            Color c1 = Color.GREEN;
              
            // getting string representation of enum
            // using toString() method
            String str = c1.toString();
              
            System.out.println(str);
        }
    }

    Producción:

    GREEN
  4. final boolean equals(Object obj) : este método devuelve verdadero si el objeto especificado es igual a esta constante de enumeración; de lo contrario, devuelve falso. 
    Syntax : 
public final boolean equals(Object obj)
Parameters : 
obj - the object too be compared for equality with this enum.
Returns :
true if the specified object is equal to this enum constant. 
false otherwise
Overrides :
equals in class Object

    // Java program to demonstrate equals() method
    enum Color
    {
        RED, GREEN, BLUE;
    }
       
    public class Test
    {
        // Driver method
        public static void main(String[] args)
        {
            Color c1 = Color.RED;
            Color c2 = Color.GREEN;
            Color c3 = Color.RED;
              
            // checking equality between enums
            // using equals() method
              
            boolean b1 = c1.equals(c2);
            boolean b2 = c1.equals(c3);
            boolean b3 = c2.equals(null);
              
            System.out.println("is c1 equal to c2 : " + b1);
            System.out.println("is c1 equal to c3 : " + b2);
            System.out.println("is c2 equal to null : " + b3);
        }
    }

    Producción:

    is c1 equal to c2 : false
is c1 equal to c3 : true
is c2 equal to null : false
  5. final int hashCode() : este método devuelve un código hash para esta constante de enumeración. En realidad, este método contiene solo una declaración, que es «return super.hashCode()», que a su vez llama al método hashCode() de la clase Object. 
    Syntax : 
public final int hashCode()
Parameters : 
NA
Returns :
a hash code for this enum constant.
Overrides :
hashCode in class Object

    // Java program to demonstrate hashCode() method
    enum Color
    {
        RED, GREEN, BLUE;
    }
       
    public class Test
    {
        // Driver method
        public static void main(String[] args)
        {
            Color c1 = Color.RED;
            System.out.print("hashcode of enum constant "+ c1.name() +" : ");
      
            // hashcode method
            System.out.println(c1.hashCode());
              
            Color c2 = Color.GREEN;
            System.out.print("hashcode of enum constant "+ c2.name() +" : ");
      
            // hashcode method
            System.out.println(c2.hashCode());
        }
    }

    Producción:

    hashcode of enum constant RED : 366712642
hashcode of enum constant GREEN : 1829164700
  6. final int compareTo(E obj) : este método «compara» esta enumeración con el objeto especificado para order . Las constantes de enumeración solo son comparables con otras constantes de enumeración del mismo tipo de enumeración. 
    Syntax : 
public int compareTo(E obj)
Parameters : 
obj - the object to be compared.
Returns :
a negative integer if this object is at less ordinal than the specified object
zero if this object is at equal ordinal than the specified object
a positive integer if this object is at greater ordinal than the specified object
Throws :
NullPointerException - if the argument is null

    // Java program to demonstrate compareTo() method
    enum Color
    {
        RED, GREEN, BLUE;
    }
       
    public class Test
    {
        // Driver method
        public static void main(String[] args)
        {
            Color c1 = Color.RED;
            Color c2 = Color.GREEN;
            Color c3 = Color.RED;
            Color c4 = Color.BLUE;
              
            System.out.print("Comparing "+c1.name()+" with "+ c2.name() +" : ");
              
            // compareTo method
            System.out.println(c1.compareTo(c2));
              
            System.out.print("Comparing "+c1.name()+" with "+ c3.name() +" : ");
              
            // compareTo method
            System.out.println(c1.compareTo(c3));
              
            System.out.print("Comparing "+c4.name()+" with "+ c2.name() +" : ");
              
            // compareTo method
            System.out.println(c4.compareTo(c2));
              
            // The following statement throw NullPointerException
            // as argument of compareTo method is null
            // System.out.println(c4.compareTo(null));
             
        }
    }

    Producción:

    Comparing RED with GREEN : -1
Comparing RED with RED : 0
Comparing BLUE with GREEN : 1
  7. static <T extends Enum> T valueOf(Class enumType,String name) : este método devuelve la constante de enumeración del tipo de enumeración especificado con el nombre especificado. El nombre debe coincidir exactamente con un identificador utilizado para declarar una constante de enumeración en este tipo. 
    Syntax : 
public static <T extends Enum> T valueOf(Class enumType,String name)
TypeParameters : 
T - The enum type whose constant is to be returned
Parameters : 
enumType - the Class object of the enum type from which to return a constant
name - the name of the constant to return
Returns :
the enum constant of the specified enum type with the specified name
Throws :
IllegalArgumentException - if the specified enum type has no 
constant with the specified name or the specified class object
does not represent an enum type
NullPointerException - if enumType or name is null

    // Java program to demonstrate valueOf() method
    enum Color
    {
        RED, GREEN, BLUE;
    }
       
    public class Test
    {
        // Driver method
        public static void main(String[] args)
        {
            // getting value of enum with specified String
            // using valueOf method
            Color c1 = Color.valueOf("RED");
            Color c2 = Color.valueOf("GREEN");
              
            // name method
            System.out.println(c1.name());
            System.out.println(c2.name());
              
            // The following statement throw IllegalArgumentException
            // as GrEEN is not an enum constant
            //  Color c3 = Color.valueOf("GrEEN");
               
            // The following statement throw NullPointerException
            // as argument of valueOf method is null
           // Color c4 = Color.valueOf(null);
        }
    }

    Producción:

    RED
GREEN
  8. final Class <E> getDeclaringClass() : este método devuelve el objeto Class correspondiente al tipo de enumeración de esta constante de enumeración. Cualesquiera dos constantes de enumeración e1 y e2 son del mismo tipo de enumeración si este método devuelve el mismo objeto de clase para ambos. 
    Syntax : 
public final Class <E> getDeclaringClass()
Parameters : 
NA
Returns :
the Class object corresponding to this enum constant's enum type

    // Java program to demonstrate getDeclaringClass() method
    enum Color
    {
        RED, GREEN, BLUE;
    }
      
    enum Day
    {
        MONDAY, TUESDAY ;
    }
      
    public class Test
    {
        // Driver method
        public static void main(String[] args)
        {
            // getting value of enum with specified String
            // using valueOf method
            Color c1 = Color.valueOf("RED");
            Color c2 = Color.valueOf("GREEN");
            Day d1 = Day.valueOf("MONDAY");
            Day d2 = Day.valueOf("TUESDAY");
              
            System.out.print("Class corresponding to "+ c1.name() +" : ");
          
            // getDeclaringClass method
            System.out.println(c1.getDeclaringClass());
              
            System.out.print("Class corresponding to "+ c2.name() +" : ");
              
            // getDeclaringClass method
            System.out.println(c2.getDeclaringClass());
              
            System.out.print("Class corresponding to "+ d1.name() +" : ");
              
            // getDeclaringClass method
            System.out.println(d1.getDeclaringClass());
              
            System.out.print("Class corresponding to "+ d2.name() +" : ");
              
            // getDeclaringClass method
            System.out.println(d2.getDeclaringClass());
        }
    }

    Producción:

    Class corresponding to RED : class Color
Class corresponding to GREEN : class Color
Class corresponding to MONDAY : class Day
Class corresponding to TUESDAY : class Day
  9. final Object clone() : este método garantiza que las enumeraciones nunca se clonen, lo cual es necesario para preservar su estado de «singleton». El compilador lo usa internamente para crear constantes Enum. 
    Syntax : 
public final Object clone() throws CloneNotSupportedException
Parameters : 
NA
Returns :
NA
Overrides :
clone in class Object
Throws :
CloneNotSupportedException-if the object's class does not support the Cloneable interface.

    // Java program to demonstrate clone() method
    enum Color
    {
        RED, GREEN, BLUE;
    }
      
    public class Test
    {
        // Driver method
        public static void main(String[] args) 
                throws CloneNotSupportedException
        {
            System.out.println("Enums are never cloned");
            Test t = new Test()
            {
                // final clone method
                protected final Object clone() 
                        throws CloneNotSupportedException 
                {
                    return new CloneNotSupportedException();
                }
            };  
              
            System.out.println(t.clone());
        }
    }

    Producción:

    Enums are never cloned
java.lang.CloneNotSupportedException
  10. final void finalize() : este método garantiza que las clases de enumeración no pueden tener métodos de finalización. 
    Syntax : 
protected final void finalize()
Parameters : 
NA
Returns :
NA
Overrides :
finalize in class Object

    // Java program to demonstrate finalize() method
    enum Color
    {
        RED, GREEN, BLUE;
    }
      
    public class Test
    {
        // Driver method
        public static void main(String[] args) throws Throwable 
        {
            System.out.println("enum classes cannot have finalize methods");
            Test t = new Test()
            {
                // final finalize method
                protected final void finalize() throws Throwable 
                {
                       // empty implementation
                };          
            };
        }
    }

    Producción:

    enum classes cannot have finalize methods

Este artículo es una contribución de Gaurav Miglani . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.

Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.

Publicación traducida automáticamente

Artículo escrito por GeeksforGeeks-1 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *