Curso de Java SE Orientado a Objetos

Curso de Java SE Orientado a Objetos

Anahí Salgado Díaz de la Vega

Anahí Salgado Díaz de la Vega

Enumerations

18/38

Lectura

Los enumerations son tipos de datos muy especiales pues este, es el único en su tipo que sirve para declarar una colección de constantes, al ser así estaremos obligados a escribirlos con mayúsculas.

Usaremos enum cada vez que necesitemos representar un conjunto fijo de constantes. Por ejemplo los días de la semana.

Así podemos declarar un enumeration usando la palabra reservada enum.

public enum Day {
	SUNDAY, MONDAY, TUESDAY, WEDNESDAY,
	THURSDAY, FRIDAY, SATURDAY
}

Puedo crear referencias de enumerations de la siguiente forma:

Day day;
switch (day) {
	case MONDAY:
		System.out.println(“Mondays are good.”);
		break;
	case FRIDAY:
		System.out.println(“Fridays are nice”);
		break;
	case SATURDAY: case: SUNDAY:
		System.out.println(“Weekends are the best”);
		break;
	default:
		System.out.println(“Midweek are so-so”);
		break;

}

Y puedo llamar un valor del enumeration así:

Day.MONDAY;
Day.FRIDAY;
Day.SATURDAY

Los enumerations pueden tener atributos, métodos y constructores, como se muestra:

public enum Day {
  MONDAY("Lunes");
  TUESDAY("Jueves");
  FRIDAY("Viernes");
  SATURDAY("Sábado");
  SUNDAY("Domingo");

  private String spanish;
  private Day(String s) {
    spanish = s;
  }

  private String getSpanish() {
    return spanish;
  }
}

Y para utilizarlo lo podemos hacer así:

System.out.println(Day.MONDAY);

Imprimirá: MONDAY

System.out.println(Day.MONDAY.getSpanish());

Imprimirá: Lunes

Aportes 84

Preguntas 0

Ordenar por:

Los aportes, preguntas y respuestas son vitales para aprender en comunidad. Regístrate o inicia sesión para participar.

Comparto aqui un código para poder iterar, a través de los valores, con fori y con forEach 😄!

import com.sun.xml.internal.ws.api.model.wsdl.WSDLOutput;

public class Password {
    //Here we have a num , a type date which declare a collection of constants

        public static enum Numero {
            UNO("One","Huk","Um"),
            DOS("Two","Iskay","Dois"),
            TRES("Three","Kinsa","Três"),
            CUATRO("Four","Tawa","Quatro"),
            CINCO("Five","Pisqa","Cinco"),
            SEIS("Six","Soqta","Seis"),
            SIETE("Seven","Qanchis","Sete"),
            OCHO("Eight","Pusaq","Oito"),
            NUEVE("Nine","Isqon","Nove"),
            DIEZ("Ten","Chunka","Dez");

            private String english;
            private String quechua;
            private String portugues;

            private Numero(String e,String q, String p){
                english = e;
                quechua = q;
                portugues = p;
            }

            public String getEnglish() {
                return english;
            }

            public String getQuechua() {
                return quechua;
            }

            public String getPortugues() {
                return portugues;
            }
        }

    public static void main(String[] args) {

        for (int i = 0; i < Numero.values().length; i++) {
            System.out.println(Numero.values()[i].getQuechua()+ ","+ Numero.values()[i].getEnglish()+ ","+ Numero.values()[i].getPortugues());
        }

        System.out.println("\nhora en distintos idiomas :D! y con ForEach\n");
        for (Numero numero: Numero.values()) {
            System.out.println(numero.getQuechua() +","+ numero.getEnglish() +","+ numero.getPortugues() );
        }

Datos curiosos sobre los enum:

  1. Puedes crear enums dentro de clases, no solo como un archivo aparte:
  2. Los enums son en realidad constantes estáticas
    Este código:

    Es lo mismo que este código:
  3. Para acceder a os atributos de los enum hacemos lo siguiente (como hizo Anahí con el método getSpanish()):
    a. Agregamos dentro de paréntesis el valor del atributo que deseemos, por ejemplo, añadiremos las palabras Domingo y Lunes a sus respectivos enums en inglés:

    b. En seguida necesitaremos agregar un constructor privado con un parámetro. Puedes nombrarlo como gustes, lo importante es que lleve el mismo tipo del atributo, en este caso String:

    NOTA: Puedes tener atributos de cualquier tipo, primitivos u objetos.
    c. La variable s es la que contiene el valor de nuestro primer atributo, así que para recuperarla y utilizarla hacemos los siguiente:
    1. Agregamos una variable privada String llamada spanish (o como gusten llamarla una vez más, español, traduccion_al_español, etc).
    2. Asignamos nuestra variable nueva a la variable s dentro del constructor.
    3. Agregamos un getter que nos permita recuperar el valor de nuestra variable spanish con el valor recuperado de la variable s.

Listo, el cómo mandar a llamar nuestro nuevo método ya lo explicó anncode, sólo quería dejar en claro algunos puntos que pudieron haberse explicado de mejor forma y con más profundidad, atando todo lo que hemos venido aprendiendo. El punto 3 es el que más me costó entender, espero no haber dejado más perdido a alguien con mi explicación.

Se hubiera agradecido una clase explicando mejor esto…

if someone wants to know how to use it

https://www.youtube.com/watch?v=hrEF3M2LCrc

Me dejo un poco confundido, ya que tuesday es martes en ingles y no jueves

Para poder entender Enum es conveniente tener presente esto:

// internamente enum Day se convierte en
class Day {
     public static final Day SUNDAY = new Day();
     public static final Day MONDAY= new Day();
     public static final Day TUESDAY= new Day();
    // etc...
}

Se deben colocar los enumerados separados por coma, al finalizar de la definición de todos los posibles valores un punto y coma. Ademas los métodos deben ser públicos.

public enum Day {
  MONDAY("Lunes","Lundí"),
  TUESDAY("Martes", "Mardí"),
  WEDNESDAY("Miercoles","Mercredi"),
  THURSDAY("Juees", "Jeudi"),
  FRIDAY("Viernes","vandredi" ),
  SATURDAY("sabado", "Samedi"),
  SUNDAY("Domingo", "dimanche");

  private String spanish;
  private String french;
  private Day(String s, String f) {
    spanish = s;
    french = f;
  }

  public String getSpanish() {
    return spanish;
  }
  public String getFrench() {
    return french;
  }
}```

Estaba analizando el enum y decidí agregarle indices a los días para probar únicamente. Me di cuenta que el constructor de esta clase es privado y al principio no entendía por qué… Pero entendí que si fuera público se podrían cambiar las constantes, que obviamente no queremos que se cambien, desde afuera y es por eso que da error si lo ponemos como público.

public enum Day { 
    MONDAY("Lunes",1),
    TUESDAY("Jueves",2),
    FRIDAY("Viernes",3),
    SATURDAY("Sábado",4),
    SUNDAY("Domingo",5);

    private String spanish;

    private Day(String s,int a) { //<<Constructor Privado
        spanish = s;
    }

    public String getSpanish() {
        return spanish;
    }
}

recreando el ejercicio, pude notar que en los enumerados el separador debe ser “,” de lo contrario genera error.

DICE:
MONDAY(“Lunes”);TUESDAY(“Martes”);WEDNESDAY(“Miércoles”);THURSDAY(“Jueves”);FRIDAY(“Viernes”);SATURDAY(“Sábado”);SUNDAY(“Domingo”);

DEBE DECIR:
MONDAY(“Lunes”),TUESDAY(“Martes”),WEDNESDAY(“Miércoles”),THURSDAY(“Jueves”),FRIDAY(“Viernes”),SATURDAY(“Sábado”),SUNDAY(“Domingo”);

Es un poco enredado entender como inicializar los Enum, y como el constructor nunca se usa realmente por que al ser constantes todo esta Hardcodeado, pero espero que esta implementacion junta sirva para algo

<code>
public class Test {

    public enum Day {

        SATURDAY("Sabado", "土曜日");

        private String spanish;
        private String japanese;

        private Day( String s, String j){
            spanish = s;
            japanese = j;
        }

        public String getJapanese() {
            return japanese;
        }

        public String getSpanish() {
            return spanish;
        }
    }

    public static void main(String[] args) {

        Day day = Day.SATURDAY;

        switch (day) {
            case SATURDAY:
                System.out.println("Spanish: " + day.getSpanish() + ", Japanse: " + day.getJapanese();
                break;
            default:
                System.out.println("Midweek are so-so");
                break;
        }
    }
}

Si quieren complementar esta clase ya que no tiene video, les recomiendo esta clase universitaria para comprender la utilización de los enums de manera profesional 😉
https://www.youtube.com/watch?v=hwlOxVDZ7kw&list=PLhU2otMFcLuCQPcEcRQfi3UQQ-ms5YH0L&index=16&t=484s



No me queda para nada claro lo de los tipos enumerados, tendré que ir a otro curso en otra plataforma para saber como y para qué se utilizan.

Hay muchas partes que no entendí, pero básicamente es como usar otra clase pero con la diferencia de que son constantes. En mi caso cree una clase nueva (lo hice dentro del package que tenia solamente mantenerlo “oculto”):

Primero creamos unas constantes en mayúscula y entre paréntesis puse el día en español. Creamos una variable, después el constructor que recibe el día que queremos y al final un getter que nos regresa el día en español.

En el archivo Main:

Lo que hago es llamar la clase, operador punto y el día que queremos para que nos imprima el día en ingles. Si lo queremos es el día en español agregamos un nuevo operador punto seguido del getter

no entiendo como le funciono a los compañeros si hay que cambiar varias cositas, solo Jose Oscar da una pista de que se debe hacer, los demás entendieron aunque ni siquiera lo ejecutaron.

 enum  Day{
    SUNDAY,MONDAY,TUESDAY,WEDNESDAY,
    THURSDAY,FRIDAY, SATURDAY
}

public static void saveValor(){
    for (Day myVar:
         Day.values ())
    {
        System.out.println (myVar);

    }
}



public static void main(String[] args) {


MesDelAnio.saveValor ();
}

}

estas constantes deverian ir separadas con " , " en vez de " ; "

	MONDAY("Lunes");
  TUESDAY("Jueves");
  FRIDAY("Viernes");
  SATURDAY("Sábado");
  SUNDAY("Domingo");

así

 		MONDAY("Lunes"),
    TUESDAY("Jueves"),
    FRIDAY("Viernes"),
    SATURDAY("Sábado"),
    SUNDAY("Domingo");

Si a alguien le falla el switch, es por los dos puntos en el case.
Debe de ser así:

case SATURDAY: case SUNDAY:

y no:

case SATURDAY: case: SUNDAY:

Para obtener el valor de un enum desde un String y sin necesida de iterar se usa el valueOf()

import java.lang.*;

enum Mobile {
   SAMSUNG(400), IPHONE(250),MOTOROLA(325);
  
   int price;
   Mobile(int p) {
      price = p;
   }
   int showPrice() {
      return price;
   } 
}

public class EnumMobileDemo {
   
   public static void main(String args[]) {
      Mobile mobileIphone= Mobile.valueOf("IPHONE"); 
      System.out.println("Mobile: " + mobileIphone);                              
   }
} 

Nota: El String desde el cual se desea obtener el valor del enum debe ser exactamente igual (mayusculas y minusculas)

📦 Los enumerations nos permiten utilizar una colección de constantes.

Todo bien pero mondays are NOT good 😃 😃

<h4>Difference between Enums and Classes</h4>

An enum can, just like a class, have attributes and methods. The only difference is that enum constants are public, static and final (unchangeable - cannot be overridden).

An enum cannot be used to create objects, and it cannot extend other classes (but it can implement interfaces).

<h4>Why And When To Use Enums?</h4>

Use enums when you have values that you know aren’t going to change, like month days, days, colors, a deck of cards, etc.

Reference: https://www.w3schools.com/java/java_enums.asp

  • Example 1:

    enum Measure {
        LOW, MEDIUM, HIGH
    }
    
    /**
     * TestEnums
     */
    public class TestEnums {
    
        public static void main(String[] args) {
            Measure myVar = Measure.LOW;
    
            switch (myVar) {
                case LOW:
                    System.out.printf("Var is low\n");
                    break;
                case MEDIUM:
                    System.out.printf("Var is medium\n");
                    break;
                case HIGH:
                    System.out.printf("Var is high\n");
                    break;
                default:
                    System.out.printf("var is nothing");
                    break;
            }
        }
    }
    
  • Example 2:

    enum Level {
      LOW,
      MEDIUM,
      HIGH
    }
    
    public class TestEnumsTwo {
      public static void main(String[] args) {
        Level myVar = Level.MEDIUM;
    
        switch(myVar) {
          case LOW:
            System.out.println("Low level");
            break;
          case MEDIUM:
             System.out.println("Medium level");
            break;
          case HIGH:
            System.out.println("High level");
            break;
        }
      }
    }
    

Una pregunta. El enumeration se llama Day, pero el objeto de ese enumeration se llama day. No deberia llamarse al objeto en vez del enumeration en ‘Day.MONDAY’ asi ‘day.MONDAY’?

Nunca habia visto enums con constructores y metodos, esto es nuevo para mi

El constructor Day si es privado solo se puede acceder desde la clase, algo que si llamamos al constructor desde el Main, sería imposible y del mismo modo el metodo getSpanish

Genialísimo!, llevaba años manejando las enumeraciones pero desconocía que se pudieran aplicar métodos a las mismas! algo nuevo! muchísimas gracias!!!

No funciona así tal como está.

No entiendo ¿en un enum podria hacer una especie de diccionario de longitud definida? ¿Por que no se declaran los tipos de variables adentro?

Estuvo bueno no conocía esto.

System.out.println(EnumTest.Objects.TAZA.getColor());
        System.out.println(EnumTest.Objects.RATON.getSize());
public class EnumTest {
    public enum Objects {
        TAZA("Blanco", "Estandar"),
        AUDIFONOS("Blanco", "Grandes"),
        RATON("Negro", "Mediano"),
        MESA("Marron", "Grande"),
        SILLA("Azul", "Estandar");

        private String color;
        private String size;
        private Objects(String c, String s){
            color = c;
            size = s;
        }

        public String getColor(){
            return color;
        }

        public String getSize(){
            return size;
        }
    }
}

TypeScript eres tu?

En el enum de dias donde se ponen en español, usando java 17 da error en la sintaxis, los días van separados por una coma y al final lleva un ; al igual que el metodo que retorna el valor en español debe ser public

Use enumerations para el menú agregando su texto en inglés y español, también para su valor. Además implemente un static method para mostrar el menú en un idioma. Otro static methods para obtener los valores del menú y poder evaluarlos en el if.

Implementando el if

import ui.UIMenus;

public class Main {
    public static void main(String[] args) {
        UIMenus.ShowMenu("spanish");
        UIMenus.ShowMenu("english");
        System.out.println("Doctor: " + UIMenus.getDoctorValue());
        System.out.println("Patient: " + UIMenus.getPatientValue());
        System.out.println("Exit: " + UIMenus.getExitValue());
        int user = 0;

        if (user==UIMenus.getDoctorValue()){
            System.out.println("user choose Doctor");
        }else if(user==UIMenus.getPatientValue()){
            System.out.println("user choose Patient");
        }else if(user==UIMenus.getExitValue()){
            System.out.println("Bye");
        }else{
            System.out.println("Invalid option");
        }
    }
}

horas del dia
imprimiendo uno a uno , y todo la lista

public class horasDia {

    public enum Horas{
        ONE("uno"),
        TWO("dos"),
        THREE("tres"),
        FOUR("cuatro"),
        FIVE("cinco"),
        SIX("seis"),
        SEVEN("siete"),
        EIGHT("ocho"),
        NINE("nueve"),
        TEN("diez"),
        ELEVEN("once"),
        TWELVE("doce");

        private String spanish;

        private Horas(String s) {
            spanish = s;
        }

        private String getSpanish() {
            return spanish;
        }

    }
    public static void main(String[] args) {

        //imprimiendo un valor de enum
        Horas hour = Horas.TWELVE;
        System.out.println(hour);
        //imprimiendo enum
        for (Horas ann : Horas.values()) {
            System.out.println(ann);
        }
        System.out.println(" español ");
        for (Horas ann : Horas.values()) {
            System.out.println(ann.getSpanish());
        }
        //
        System.out.println(Horas.EIGHT.getSpanish());
        System.out.println(Horas.values());
    }
}

Comparto aquí un link de un video, donde se entiende bastante bien.
https://www.youtube.com/watch?v=-Q1f3eCPsfY

Uuy interesante aunque no entendí porque imprime el día en español

Los enums son un tipo especial de clase que puede tener un constructor, métodos y variables. En el código :

public enum Day {
  MONDAY("Lunes"),
  TUESDAY("Jueves"),
  FRIDAY("Viernes"),
  SATURDAY("Sábado"),
  SUNDAY("Domingo");

  private String spanish;
  private Day(String s) {
    spanish = s;
  }

  private String getSpanish() {
    return spanish;
  }
}
  • Los valores enum deben estar separados por coma. El punto y coma debe ir con el último valor:

  • Los valores enum pueden tener argumentos que se pasan al constructor. El tipo de los argumentos se define en el constructor.

  • El constructor corre por cada valor declarado en el enum. En el código de arriba el constructor corre 5 veces, uno para cada día declarado.

  • Si se quiere tener diferentes tipos de argumentos en los valores, se puede sobrecargar el constructor. Por ejemplo:

MONDAY("Lunes"),
MONDAY_DAY_NUMBER(1);

private String spanish;
private int dayNumber;

//Constructors
private Day(String s){
	spanish = s;
}

private Day(int dayNumber){
	this.dayNumber = dayNumber;
}

Que error del curso, este tema es bien importante y no le dedican un video -.-"

No entiendo una cosa… para qué se declaro la función privada Day… “constructor”… si no lo estoy utilizando…?

Gracias

Ejemplo:

enum Day {
	    	MONDAY("Lunes"),
        TUESDAY("Jueves"),
        FRIDAY("Viernes"),
        SATURDAY("Sábado"),
        SUNDAY("Domingo");
        
        // atributos
        private String spanish;
        
        // constructores
        Day(String s) {
            spanish = s;
        }
        
        // metodos
        public String getSpanish() {
            return spanish;
        }
}

class Main {  
    public static void main(String args[]) { 
        System.out.println(Day.SUNDAY.getSpanish());
    }
}

excelente ejemplo

Interesante, buena forma de ordenar la información.

Super!!

Me llamó la atención esto : “al ser así estaremos obligados a escribirlos con mayúsculas.”. Intenté con minúsculas y funciono de todos modos. Aunque entiendo que por convención es mejor constantes en mayúsculas.

Excelente, para la aplicación en conjuntos y subconjuntos de datos.

Muy bien explicado con el ejemplo!

¿Que funcionalidad y en que momentos puedo utilizar este recurso?, es que como tal no le veo que tenga un objetivo claro.
😃 😃

Interesante, no lo conocia.

public class Pruebas {

     public enum Vocales{
         A("Valor A"),
         E("Valor E"),
         I("Valor I"),
         O("Valor O"),
         U("Valor U");
         
         private String ValorInterno;
         private Vocales(String vocal){
         ValorInterno=vocal;
         }
         public String getValorInterno(){
         return "Vocal: "+ValorInterno;
         }
      
     }
     
    public static void main(String[] args) {
        
        System.out.println(Vocales.A.getValorInterno());
        System.out.println(Vocales.E.getValorInterno());
        Vocales vocal=Vocales.A;
      
    }```

Interesante

EL método de getSpanish() para que funcione no debe ser private, deberá ser public y ya está

En el ejemplo donde utiliza un “enum” dentro de un switch, cuando se ejecuta pide inicializar la variable, pero si le damos un valor por defecto no tendría mucho sentido crear un enum, puesto que al final nosotros le damos el valor. Entonces, ¿hay una forma de utilizar utilizar el enum en el switch sin inicializar la variable?

Excelente explicación, muy buena, muy útil los métodos dentro de los enums

Muy buen aporte, explica en que momento podemos utilizar constante

que sencillo es

Estupenda manera de organizar un grupo de constantes y la manera de cómo pueden ser utilizadas.

Bien!
Me hubiera gustado ver otro ejemplo.

Es muy útil para el uso de colección de constantes.

Bien, no conocía los enumerations 😉

Es bueno saberlo 😃

muy útiles 😃

Interesante!

Es una forma bastante sencilla y creativa para crear Arreglos de constantes

Super bien, miraba esto en tutos en youtube y no sabía para que era!

aporte: el metodo private String getSpanish() deberia estar dentro del enumeration day, ya que el atributo spanish es privado

Claro

veo que declará un enum con el estilo Upper Camel Case, es así como se sugiere declarar? a simple vista podría confundir con una clase estática.

esto nunca lo habia scuchado 😦 q locura

Super interesante 😃

Bueno este es un código donde se declara un tipo enum llamado Libro con constructor y campos de instancia.

Posteriormente se prueba este tipo enum desde otra clase normal como las que venimos trabajando.

public enum Libro {

    //Declara constantes de tipo enum
    JHTP("Java How to Program", "2015"),
    CHTP("C How to Program", "2013"),
    IW3HTP("Internet & World Wide Web How to Program", "2012"),
    CPPHTP("C++ How to Program", "2014"),
    VBHTP("Visual Basic  How to Program", "2014"),
    CSHARPHTP("Visual C# How to program", "2014");

    //Campos de instancia
    private  String titulo;
    private String anioCopyRight;


    //Constructor de enum
    Libro(String titulo, String anioCopyRight) {
        this.titulo = titulo;
        this.anioCopyRight = anioCopyRight;
    }

    //Método de acceso para el campo título
    public String getTitulo(){

        return titulo;
    }

//Método de acceso para el campo anioCopyRight
    public String getAnioCopyRight(){

        return anioCopyRight;
    }
}
import java.util.EnumSet;

public class PruebaEnum {

    public static void main(String[] args) {

        System.out.println("Todos los libros:");

        //Imprime todos los libros en enum Libro
        for (Libro libro: Libro.values())
            System.out.printf("%-10s%-45s%s%n", libro, libro.getTitulo(), libro.getAnioCopyRight());

        System.out.println("Mostrar un rango de constantes enum:");

        //Imprime los primeros cuatro libros
        for (Libro libro: EnumSet.range(Libro.JHTP, Libro.CPPHTP))
            System.out.printf("%-10s%-45s%s%n", libro, libro.getTitulo(), libro.getAnioCopyRight());





    }
} 

Un tutorial mejor explicado de enum en español

https://www.youtube.com/watch?v=DwriSApbm50&ab_channel=pildorasinformaticas

buena explicación gracias

public enum Day {
    MONDAY("Lunes"),
    TUESDAY("Martes"),
    WEDNESDAY("Miércoles"),
    THURSDAY("Jueves"),
    FRIDAY("Viernes"),
    SATURDAY("Sábado"),
    SUNDAY("Domingo");

    private String spanish;

    private Day(String s) {
        spanish = s;
    }

    public String getSpanish() {
        return spanish;
    }
}
public enum Day {
	
	SUNDAY("Domingo"), 
	MONDAY("Lunes"), 
	TUESDAY("Martes"),
	WEDNESDAY("Miercoles"),
	THURSDAY("Jueves"),
	FRIDAY("Viernes"),
	SATURDAY("Sábado");
	
	private String spanish;
	
	private Day(String s) {
		spanish = s;
	}
	
	private String getSpanish() {
		return spanish;
	}

}```

No entendí absolutamente nada desde “Los enumerations pueden tener atributos, métodos y constructores, como se muestra:” hacia abajo 😕

super, será muy útil.

Muy buena explicación, ahora me ha quedado mas claro.

Excelente explicación en pocos ejemplos.

excelente resumen

mu bien explicado, conocia de esto, pero no sabia muy bien su uso, ahora ya lo entiendo 😄

buena clase interesante