java - the - Es un interruptor en una enumeración dentro de un buen estilo de bucle

switch java

Question

Tengo un problema relacionado con la implementación de algo en Java y creo que los Enums son parte de esto (o tal vez soy yo quien los formó como parte del problema.

Entonces, el problema es que tengo una clase modelo, digamos que tiene 3 campos:

class ConferenceInfo {
    String name;
    Date date;
    String location;

    public boolean compareByName(ConferenceInfo other) {
        return getName().equals(other.getName());
    }

    public boolean compareByDate(ConferenceInfo other) {
        return getDate().compareTo(other.getDate()) == 0;
    }

    public boolean compareByLocation(ConferenceInfo other) {
        return getLocation().equals(other.getLocation());
    }
}

Tengo una lista de pares de esos objetos que tengo que comparar:

List<Pair<ConferenceInfo, ConferenceInfo>> 

Ahora, esto sería bastante fácil, si pudiera anular un método equals, pero en este caso es un poco diferente. Tengo que comparar esos objetos por valores de sus campos y dar salida al número de ellos que difieren. Para hacerlo, he creado una enumeración:

public enum FieldType {
    NAME,
    DATE,
    LOCATION
}

y creó un método (en mi clase Measurement, que tiene una lista de pares mencionada) que toma FieldType como parámetro y hace algo como esto:

for (Pair<ConferenceInfo, ConferenceInfo> result : results) {
    ConferenceInfo first = result.getFirst();
    ConferenceInfo second = result.getSecond();

    switch (field) {
    case NAME:
        if (!first.compareByName(second)) {
            differentValues++;
        }
        break;
    case DATE:
        if (!first.compareByDate(second)) {
            differentValues++;
        }
        break;
    case LOCATION:
        if (!first.compareByLocation(second)) {
            differentValues++;
        }
        break;
    }
}

Funciona, pero me pregunto si la forma en que lo codifiqué es una buena práctica o debería escribirlo de otra manera ... No me gusta cambiar dentro de un ciclo, pero tal vez soy solo yo :)

Answer 1

No estoy seguro de si omito algo, pero en este caso implementaría un método en la clase de modelo simple y verificaría los diferentes valores:

class SimpleModel  {
     ...

    int differentFields(SimpleModel obj){
        int differentValues = 0;
        if (!this.compareByName(obj)) {
            differentValues++;
        }
        if (!first.compareByDate(second)) {
             differentValues++;
        }
        if (!first.compareByLocation(second)) {
            differentValues++;
        }
        return differentValues;
    }
}

y en el método que compara los pares, utilízalo

for (Pair<ConferenceInfo, ConferenceInfo> result : results) {
    ConferenceInfo first = result.getFirst();
    ConferenceInfo second = result.getSecond();
    first.differentFields(second);
}

Answer 2

Puede usar polimorfismo en lugar de su interruptor:

public enum FieldType {
    NAME {
        @Override
        public boolean areEqual(ConferenceInfo c1, ConferenceInfo c2) {
            return c1.compareByName(c2);
        }
    },
    DATE {
        @Override
        public boolean areEqual(ConferenceInfo c1, ConferenceInfo c2) {
            return c1.compareByDate(c2);
        }
    },
    LOCATION {
        @Override
        public boolean areEqual(ConferenceInfo c1, ConferenceInfo c2) {
            return c1.compareByLocation(c2);
        }
    };

    public abstract boolean areEqual(ConferenceInfo c1, ConferenceInfo c2);
}

Y luego, en tu código:

for (Pair<ConferenceInfo, ConferenceInfo> result : results) {
    ConferenceInfo first = result.getFirst();
    ConferenceInfo second = result.getSecond();
    if (!field.areEqual(first, second)) {
        differentValues++;
    }
}

Esto tiene la ventaja adicional de que, si aparece un nuevo valor enum, no correrá el riesgo de olvidarse de agregar un caso al cambio.