Enumerations

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.

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() );
        }

Se hubiera agradecido una clase explicando mejor esto…

if someone wants to know how to use it

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

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;
  }
}```

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

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”);

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

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;
        }
    }
}

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");

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 ();
}

}

https://docs.oracle.com/javase/tutorial/java/javaOO/enum.html

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

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

        public String getSpanish() {
            return spanish;
        }
    }

}

// Main.java
        for (Days.Day day:Days.Day.values()) {
            System.out.println(day+":"+day.getSpanish());
        }

Hice esta clase, como practica, aunque es muy baso en lo que esta en los ejemplos de la clase y de los aportes

<code> public class Enums {

    public enum Months{
        JANUARY("Enero","Janvier"),
        FEBRUARY("Febrero", "Février"),
        MARCH("Marzo","Mars"),
        APRIL("Abril","Avril"),
        MAY("Mayo","Mai");

        private String spanish;
        private String french;

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

        public String getSpanish() {
            return spanish;
        }

        public void setSpanish(String spanish) {
            this.spanish = spanish;
        }

        public String getFrench() {
            return french;
        }

        public void setFrench(String french) {
            this.french = french;
        }


    }
    public static void Months1(Months months){

        switch (months){

            case JANUARY:
                System.out.println(" January is the finish vacation");
                break;
            case FEBRUARY:
                System.out.println("February is the star class");
                break;
            case MARCH:
                System.out.println(" This month is the evil");
                break;
            case APRIL:
                System.out.println(" Plese help me");
                break;
            case MAY:
                System.out.println(" I am dead,  studying is very bored");
                break;
        }
    }
}
</code>

Y de esta forma lo llame en el main de esta forma

<code> 
 public static void main(String[] args) {

        for (Enums.Months months: Enums.Months.values()
             ) {
            System.out.println(months.getFrench()+"  "+months.getFrench());

        }

        System.out.println(" What month are we in");
        Scanner Sc = new Scanner(System.in);
        String month = Sc.nextLine();
        Enums.Months1(Enums.Months.valueOf(month));
    }

Hola a todos!!! Si de algo puede servir, yo cree una clase aparte e hice respectivamente un método para llamarlo desde la clase _ “Main”,_ con una pequeña lógica que funciona como un sencillo traductor de inglés a español.

Lo que hice en código fue crear una clase llamada “Days”_ y dentro de ella hice el arreglo “enum”.

Cree las variables, con su constructor y los métodos Getters .

Luego cree un método estático llamado showDay, donde se le pregunta al usuario que escriba el día que desea traducir (en inglés), y el switch valida el día (en inglés) que ingresó el usuario y según el caso con el método get dentro del switch retorna el valor en español.

Una vez creado el método, lo llamo desde el método “main” en la clase que para mi caso se llama App, y corro el programa.

Espero que les sea de utilidad, yo se que es en principio un poco complicado de entender, yo también le dedique tiempo para llegar a este resultado y para comprender sobre todo como aplicarlo.

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 😃 😃

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).

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.

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

me costo ver que getSpanish tenia que ser public

Sufri bastante al darme cuenta que en lugar de

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

es

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

Hola a todos.
El metodo “getSpanish()” no puede ser private, si pretenden usar una clase para probar los enums.

Yo hice un bucle for, es solo para practicar jeje:

class Enum{
    public static void main(String[] args) {

        for (int i = 0; i < Day.values().length; i++) {
            Day dayWeek = Day.values()[i];

            switch (dayWeek) {
                case MONDAY -> System.out.println("The mondays are good");
                case FRIDAY -> System.out.println("The friday is very good");
                case SUNDAY -> System.out.println("I like the sundays");
                case TUESDAY -> System.out.println("The tuesday is good");
                case WEDNESDAY -> System.out.println("Middle week");
                case SATURDAY -> System.out.println("Start the weekend");
                case THURSDAY -> System.out.println("SO SO");
            }
        }
        
        System.out.println(Day.MONDAY);
    }
    public enum Day {
        SUNDAY, MONDAY, TUESDAY, WEDNESDAY,
        THURSDAY, FRIDAY, SATURDAY
    }
}

A mi me sirvió mucho este link para entender desde cero este tema, ya que aquí la verdad no se trata de la mejor manera, hizo falta una explicación en video.

https://javadesdecero.es/avanzado/enumerados-enum-ejemplos/

Algo que me recomendo el IDE de java fue que Cuando haciamos private String Spanish;
podiamos colocarlo como “FINAL” ya que es la forma de java de decir que algo es una constante y la verdad que es muy util para ayudarle al compilador a decirle que nuestro dias de “Day” son constantes y nunca van a cambiar

public enum Day {

    MONDAY("Lunes", "Monday"),
    TUESDAY("Martes", "Tuesday"),
    WEDNESDAY("Miercoles", "Wednesday"),
    THURSDAY("Jueves", "Thursday"),
    FRIDAY("Viernes", "Friday"),
    SATURDAY("Sabado", "Saturday"),
    SUNDAY("Domingo", "Sunday");

    private final String spanish;
    private final String english;

    private Day(String spanish, String english) {//<<Constructor Privado
        this.spanish = spanish;
        this.english = english;
    }

    public String getSpanish() {
        return spanish;
    }

    public String getDayEnglish() {
        return english;
    }

}

Para los que se quedaron con dudas aconsejo este video incluye como poner en UML
https://www.youtube.com/watch?v=HMOcwq5yXfs
y luego este
https://www.youtube.com/watch?v=F8HSRnFGhYM

Vengo del ecosistema de Js y para mi:

Listas en Java == Arreglos en JavaScript
Enumerations == Objetos en JavaScript

enum Level {
  LOW("bajo", 2),
  MEDIUM("medio", 3),
  HIGH("alto", 4);
  
  private String spanish;
  private int level;
  private Level(String s, int l) {
    spanish = s;
    level = l;
  }

  public String getSpanish() {
    return spanish;
  }

  public int getLevel() {
    return level;
  }
}

public class Main { 
  public static void main(String[] args) { 
    System.out.println(Level.MEDIUM.getSpanish()); 
    // imprime medio
    System.out.println(Level.MEDIUM.getLevel()); 
    // imprime 3
  } 
}
<code> 

Muy buena lectura

Mi Apunte:

Agregué y cambie algunas cosas de forma que yo las entendiera. SI ven algo en lo que me equivoqué no duden en decirmelo. Espero que les sea de utilidad.

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 {
	MONDAY,
  	TUESDAY,
  	WEDNESDAY,
  	THURSDAY,
	FRIDAY,
	SATURDAY,
  	SUNDAY;
}

Puedo crear referencias de enumerations de la siguiente forma:

DayOfTheWeek day = DayOfTheWeek.SATURDAY;
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 DayOfTheWeek {
    MONDAY("Lunes"),
    TUESDAY("Martes"),
    WEDNESDAY("Miercoles"),
    THURSDAY("Jueves"),
    FRIDAY("Viernes"),
    SATURDAY("Sabado"),
    SUNDAY("Domingo");

    private final String day; 
// day Debe ser constante para que no pueda ser modificada de otra clase.

    private DayOfTheWeek(String dayInSpanish) { // el Constructor debe ser privado para que no se puedan crear instancias
// dayInSpanish recibira como argumento el valor del atributo del dia en español (ej: si es MONDAY recibirá Lunes, TUESDAY -> martes...)
        day = dayInSpanish;
    }
    String getDayInSpanish(){
        return day;
    }
}

Y para utilizarlo lo podemos hacer así:

System.out.println( DayOfTheWeek.MONDAY );

Imprimirá: MONDAY

System.out.println( DayOfTheWeek.MONDAY.getDayInSpanish() );

Imprimirá: Lunes

Pueden tener más de 1 atributo

public enum DayOfTheWeek {
    MONDAY("Lunes", 1),
    TUESDAY("Martes", 2),
    WEDNESDAY("Miercoles", 3),
    THURSDAY("Jueves", 4),
    FRIDAY("Viernes", 5),
    SATURDAY("Sabado", 6),
    SUNDAY("Domingo", 7);

    private final String day; 
    private  final int indexOfTheDay;

    private DayOfTheWeek(String dayInSpanish, int index) { // Constructor
        day = dayInSpanish;
        indexOfTheDay = index;
    }

    String getDayInSpanish(){
        return day;
    }
    int getIndexOfTheDay() {
        return indexOfTheDay;
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println("Day: " + DayOfTheWeek.FRIDAY);
        System.out.println("Día: " + DayOfTheWeek.FRIDAY.getDayInSpanish());
        System.out.println("Indice: " + DayOfTheWeek.FRIDAY.getIndexOfTheDay());
    }
}
/* out:
>> Day: FRIDAY
>> Día: Viernes
>> Indice: 5
*/

Recorrer con un forEach utilizando el método .values()

for ( DayOfTheWeek day : DayOfTheWeek.values() ){
	System.out.println( day );
}
/* Out:
MONDAY
TUESDAY
WEDNESDAY
THURSDAY
FRIDAY
SATURDAY
SUNDAY
*/
for ( DayOfTheWeek day : DayOfTheWeek.values() ){
	System.out.println( day.getDayInSpanish() );
}
/* Out:
Lunes
Martes
Miercoles
Jueves
Viernes
Sabado
Domingo
*/

A profundidad

// internamente enum Day se convierte en
class Day {
     public static final Day MONDAY = new Day();
     public static final Day TUESDAY = new Day();
     public static final Day WEDNESDAY = new Day();
    // por cada campo...
		// cada campo son objetos, instancias, publicos y estáticos de la clases espacial enum Day. Por esto es que puedene tener Comportamiento y Estado.
}

APLICANDO LO PRENDIDO PARA MOSTRAR TODOS LOS DATOS DEL ENUMERATION EN UN foreach:

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

Eh actualizado el proyecto de MyMedicalAppointments y ahora en la clase Doctor.AvilableAppointment le cambie el getter de Date y ahora es así:

public String getDate() {
            Day[] days = Day.values();
            Month[] months = Month.values();

            return days[(date.getDay())].getEnglish() + ", " + months[date.getMonth()].getEnglish() + " " + date.getDate() + ", " + (date.getYear() + 1900);
        }

Tambien con unos archivos extras metidos en un paquete:

Day:

package day_month;

public enum Day {
    //Variables constantes
    ONE("Lun", "Mon"),
    TWO("Mar", "Tue"),
    THREE("Mie", "Wed"),
    FOUR("Jue", "Thu"),
    FIVE("Vie", "Fri"),
    SIX("Sab", "Sat"),
    SEVEN("Dom", "Sun");

    private String spanish;
    private String english;

    Day(String spanish, String english) {
        this.spanish = spanish;
        this.english = english;
    }

    public String getSpanish() {
        return spanish;
    }

    public String getEnglish() {
        return english;
    }
}  

Month:

package day_month;

public enum Month {
    //Variables constantes
    ONE("Enero", "January"),
    TWO("Febrero", "February"),
    THREE("Marzo", "March"),
    FOUR("Abril", "April"),
    FIVE("Mayo", "May"),
    SIX("Junio", "June"),
    SEVEN("Julio", "July"),
    EIGHT("Agosto", "August"),
    NINE("Septiembre", "September"),
    TEN("Octubre", "October"),
    ELEVEN("Noviembre", "November"),
    TWELVE("Diciembre", "December");

    private String spanish;
    private String english;

    Month(String spanish, String english) {
        this.spanish = spanish;
        this.english = english;
    }

    public String getSpanish() {
        return this.spanish;
    }

    public String getEnglish() {
        return this.english;
    }
}

Y así es como llevo mi proyecto 😄

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!

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.