¿Puede una enumeración tener métodos abstractos?

4 minutos de lectura

avatar de usuario
java_geek

¿Puede una enumeración tener métodos abstractos? Si es así, cuál es el uso y proporcione un escenario que ilustre este uso.

  • en que idioma y esto suena como una tarea, si es así, use la etiqueta de tarea

    – Cédric Julien

    14 de septiembre de 2011 a las 9:11

  • JAVA. Nunca he usado una enumeración con un método abstracto. Estoy tratando de entender los escenarios en los que puedo tener tal cosa.

    – java_geek

    14 de septiembre de 2011 a las 9:13

  • No, estás tratando de averiguar si puedes tener algo así. El compilador le dirá que no veo por qué necesita un foro.

    – usuario207421

    14 de septiembre de 2011 a las 10:45

avatar de usuario
lukastimo

Sí, pero es posible que prefiera una enumeración que implemente una interfaz. Mire aquí. Creo que se ve mucho mejor. Este es un ejemplo para el método abstracto:

public enum Animal {
    CAT {
        public String makeNoise() { return "MEOW!"; }
    },
    DOG {
        public String makeNoise() { return "WOOF!"; }
    };

    public abstract String makeNoise();
}

  • Siempre use Animal en ejemplos de código de polimorfismo =)

    – Stephan Henningsen

    21/09/2017 a las 20:59

  • ¿Qué versión de Java debo usar para esta sintaxis?

    – fotofoto

    17 de marzo a las 3:50

Sí, puedes definir abstract métodos en un enum declaración si y solo si todos los valores de enumeración tienen cuerpos de clase personalizados con implementaciones de esos métodos (es decir, ningún valor de enumeración concreto puede carecer de una implementación).

public enum Foo {
  BAR {
    public void frobnicate() {
      // do BAR stuff
    }
  },
  BAZ {
    public void frobnicate() {
      // do BAZ stuff
    }
  };

  public abstract void frobnicate();
}

  • También tenga en cuenta que la declaración del método abstracto debe realizarse después de definir los valores con implementaciones. De lo contrario, si el método abstracto se declara antes que los valores, habrá un error de sintaxis en tiempo de compilación.

    – Rohit Gaikwad

    30 de diciembre de 2021 a las 1:02

Al igual que la respuesta de @lukastymo, es posible implementar un método abstracto en una enumeración y se prefiere implementar una interfaz al agregar un método en una enumeración.

Desde Java 8 y superior, puede usar lambda para implementar métodos en una enumeración para código más pequeño. Estos lambda se pueden ejecutar fuera de la enumeración al exponer un método público que ejecuta el lambda dado.

public enum ScheduleRepeat {
  DAILY(date -> date.plusDays(1)),
  WEEKLY(date -> date.plusWeeks(1)),
  MONTHLY(date -> date.plusMonths(1)),
  QUARTERLY(date -> date.plusMonths(3)),
  BIANNUALLY(date -> date.plusMonths(6)),
  ANNUALLY(date -> date.plusYears(1)),
  ;

  private final Function<LocalDate, LocalDate> nextDateFunction; // or UnaryOperator<LocalDate>

  ScheduleRepeat(Function<LocalDate, LocalDate> nextDateFunction) {
    this.nextDateFunction = nextDateFunction;
  }

  public LocalDate calculateNextDate(LocalDate dateFrom) {
    return nextDateFunction.apply(dateFrom);
  }
}

Entonces la enumeración se puede usar como:

LocalDate today = LocalDate.of(2019, 9, 18); // 2019 Sep 18
ScheduleRepeat.DAILY.calculateNextDate(today); // 2019-09-19
ScheduleRepeat.MONTHLY.calculateNextDate(today); // 2019-10-19

Esto no es exactamente implementar un método abstracto desde la enumeración en sí o desde una interfaz, pero creo que este enfoque de agregar un método usando lambda parece limpio.

avatar de usuario
musa

Sí, la enumeración puede contener un método abstracto: puede usar este enfoque si tiene una implementación propia por constantes de enumeración. (o puede omitir el uso del método abstracto con el uso de valor personalizado por constante de enumeración Enum con valor personalizado en Java)

por ejemplo (implementaciones de métodos específicos de constantes)

enum TrafficSignal {

    RED{
        @Override
        public void action(){
            System.out.println("STOP");
        }
    }, 
    GREEN{
        @Override
        public void action(){
            System.out.println("GO");
        }
    }, 
    ORANGE{
        @Override
        public void action(){
            System.out.println("SLOW DOWN");
        }
    };


    public abstract void action();
}

Si este método es común para todas las constantes de enumeración, considere usar la interfaz. (Las enumeraciones de Java extienden la clase genérica java.lang.Enum implícitamente, por lo que sus tipos de enumeración no pueden extender otra clase (porque Java no admite la herencia múltiple) pero puede implementar la interfaz)

interface ColorInterface{
    void inLowerCase();
}

enum Color implements ColorInterface{

    RED, GREEN, ORANGE;

    @Override
    public void inLowerCase(){
        System.out.println(this.toString().toLowerCase());
    }
}

Uso:

public class TestEnums{

     public static void main(String []args){
        TrafficSignal signal = TrafficSignal.RED;
        signal.action();

        ColorInterface color = Color.RED;
        color.inLowerCase();
     }
}

Afuera:

STOP
red

Considere el patrón de enumeración de estrategia si algunas, pero no todas, las constantes de enumeración comparten comportamientos comunes. [Effective Java – Joshua Bloch – third edition. page 166]

¿Ha sido útil esta solución?