Icono play
Java
Técnica de consolidate conditional

Consolidate conditional  es una de los procedimientos o técnicas para refactorizar código que hemos creado. Esto es necesario cuando nuestros proyectos comienzan a crecer y posiblemente se va haciendo más complicado comprender que hace cada fragmento del mismo. 

En el caso de la técnica consolidate conditional su objetivo es combinar varias estructuras condicionales en una expresión condicional y extraerla.

¿Cuándo aplicar la técnica consolidate conditional?

Cuanto tengamos varias estructuras condicionales combinadas que arrojan un mismo resultado y que a simple vista duplican el flujo de control del proyecto, es decir, repiten un proceso para obtener un mismo resultado.

Si esto está sucediendo, es el momento de aplicar la técnica consolidate condicional para mejorar el código, hacerlo más legible y eficiente.

¿Por qué utilizar la técnica consolidate conditional?

  • Para ofrecer un código mucho más limpio y fácil de entender. Cuando consolidamos una serie de condicionales en una estructura más sencilla, será más fácil determinar cuál es la actividad específica que ese fragmento está realizando.
  • Para crear código que sea manejable, puesto que podemos aislar una expresión que era compleja en un método nuevo que sea fácil de comprender, comprobar y/o modificar.

Pasos para usar la técnica consolidate conditional

  • En primer lugar, debemos revisar que las estructuras condicionales que queremos consolidar no modifiquen el funcionamiento del resto del programa, esto evitará que causemos fallos al hacer el cambio.
  • Una vez cubierto el paso anterior, es hora de definir la manera en la que haremos la consolidación, según sea el caso, podremos emplear los operadores and u or. 
  • Finalmente, es la hora de generar un método nuevo que tenga un nombre que refleje la finalidad que este cumple.

Ahora veremos un ejemplo que ilustra la manera correcta de usar la técnica consolidate conditional para refactorizar el código:

En primer lugar, veremos un código que calcula un bono que se otorgará dependiendo de si se cumplen o no una serie de condiciones:

package consolidarCondicionales;

class Condicional  {

    int salario;
    int horas;
    int antiguedad;

    public Condicional(int salario, int horas, int antiguedad) {
        this.antiguedad = antiguedad;
        this.salario = salario;
        this.horas = horas;
    }

    int calculoSalario() {
        int pagoFinal = 0;

        /*Hay una serie de condicionales que sirven
         * para determinar si el trabajador recibirá un bono
         * o no califica para él
         */
        if (salario > 1500) {
            return salario;
        }

        if (horas < 140) {
            return salario;
        }

        if (antiguedad < 3) {
            return salario;
        }

        pagoFinal = salario + 200;
        return pagoFinal;

    }

    public static void main(String[] args) {
        Condicional obj1 = new Condicional(800, 150, 6);
        System.out.println("Su salario es: " + obj1.calculoSalario());
    }

}

Ahora vemos este código con una modificación que consolida las estructuras condicionales que tenía el anterior:

package consolidarCondicionales;

class Condicional {
    int salario;
    int horas;
    int antiguedad;

    public Condicional(int salario, int horas, int antiguedad) {
        this.antiguedad = antiguedad;
        this.salario = salario;
        this.horas = horas;
    }

    int calculoSalario() {
        int pagoFinal = 0;

        /*en este condicional hemos consolidado los que eran 3 
         * en el código anterior, esto hace más legible el código
         */
        if ((salario > 1500) || (horas < 140) || (antiguedad < 3))
            return salario;
        pagoFinal = salario + 200;
        return pagoFinal;
    }



    public static void main(String[] args) {
        Condicional obj1 = new Condicional(800, 150, 6);
        int resultado = obj1.calculoSalario();
        System.out.println("Su salario es: " + resultado);
    }

}

Finalmente, en el siguiente fragmento se construye un método de tipo boolean que reúne y evalúa las condiciones que antes estaban separadas, logrando un código mejor estructurado gracias a aplicar la técnica consolidate conditional.

package consolidarCondicionales;

class Condicional {
    int salario;
    int horas;
    int antiguedad;

    public Condicional(int salario, int horas, int antiguedad) {
        this.antiguedad = antiguedad;
        this.salario = salario;
        this.horas = horas;
    }

    int calculoSalario() {
        int pagoFinal = 0;
        if (bono()) {
            return salario;
        }

        pagoFinal = salario + 200;
        return pagoFinal;
    }

    /*hemos creado un método booleano que evalua
     * las sentencias condicionales 
     * y entrega su resultado al método que calcula el 
     * salario
     */

    boolean bono() {
        return salario > 1500 || horas < 140 || antiguedad < 3;
    }

    public static void main(String[] args) {
        Condicional obj1 = new Condicional(800, 150, 6);
        System.out.println("Su salario es: " + obj1.calculoSalario());

    }

}
¿Todavía no te has apuntado a nuestro Bootcamp?
Tenemos muchos cursos para ofrecerte y ¡TOTALMENTE GRATIS! Estos son algunos de ellos: