L'objectiu d'aquest CodeLab és conèixer les possibilitats de refactorització de codi que ofereix IntelliJ.

La refactorització de codis és el procés de reestructuració del codi informàtic existent: canviar el factoratge, sense canviar el seu comportament extern. La refactorització pretén millorar els atributs no funcionals del programari. Els avantatges inclouen una millor llegibilitat de codi i una complexitat reduïda ; poden millorar la capacitat de manteniment del codi font i crear una arquitectura interna o un model d'objectes més expressius per millorar l' extensibilitat.

Inicia IntelliJ i crea un nou projecte anomenat "Refactoring".

IntelliJ ofereix una gran varitetat de formes de refactorització de codi.

Per a veure les possibilitats que ens ofereix per a refactoritzar una part del codi en particular, cal posar el cursos a sobre o seleccionar la part que volem refactoritzar i polsar Ctrl+Alt+Mayus+T

En aquest CodeLab veurem aquestes interessants refactoritzacions:

Canviar la signatura d'un mètode

Permet afegir paràmetres a un mètode

Extraure mètodes

Permet crear un mètode a partir del codi seleccionat

Encapuslar camps

Substitueix l'accés directe a un camp per mètodes getters o setters

Extraure variables

Permet emmagatzemar expressions en una variable per a reutilitzar-les

Afegir paràmetres

Imagina que tenim un codi semblant a aquest:

public class Main {
   public static void main(String[] args) {
       Scanner scanner = new Scanner(System.in);

       int a = scanner.nextInt();
       mostrar(a);
       mostrar(a);
       mostrar(a);
       mostrar(a);
       mostrar(a);
   }

   private static void mostrar(int a) {
       System.out.println("La variable a és " +  a);
   }
}

És a dir, un codi on tenim un mètode que cridem molts cops al nostre codi.

Ara imagina que volem llegir una altra variable i passar-la al mètode per a que també la mostri. Ens hauria de quedar un codi així:

public class Main {
   public static void main(String[] args) {
       Scanner scanner = new Scanner(System.in);

       int a = scanner.nextInt();
       int b = scanner.nextInt();
       mostrar(a, b);
       mostrar(a, b);
       mostrar(a, b);
       mostrar(a, b);
       mostrar(a, b);
   }

   private static void mostrar(int a, int b) {
       System.out.println("La variable a és " +  a);
       System.out.println("La variable b és " +  b);
   }
}

Fer un simple canvi com aquest seria bastant pesat de fer a mà, ja que hi ha que canviar moltes línies de codi. Usant la refactorització farem el canvi de forma automàtica.

Imagina que tenim el següent codi d'exemple, que determina si un nombre és primer o no.

public class Main {
   public static void main(String[] args) {
       Scanner scanner = new Scanner(System.in);

       int a = scanner.nextInt();

       boolean isPrime = true;

       if (a==0 || a==1){
           isPrime = false;
       } else {
           for (int i = 2; i < a / 2; i++) {
               if (a % i == 0) {
                   isPrime = false;
                   break;
               }
           }
       }

       System.out.println(isPrime);
   }
}

Podem extraure automàticament el codi en un mètode: seleccionem el codi que volem extraure i polsem Ctrl+Alt+M

Una operació molt habitual és la d'encapsular els camps de forma que l'accés es fa a través de mètodes (getters i setters).

Amb el refactoring ho podem fer en un obrir i tancar d'ulls:

Quan utilitzem una expressió vàries vegades, és més convinent emmagatzemar el resultat i reutilitzar-lo, que re-calcular l'expressió cada cop.

Imagina aquest exemple:

public class Main {
   public static void main(String[] args) {
       float valor1 = 10;
       float valor2 = 5;
      
       System.out.println("SUMA:" + (valor1+valor2));
       System.out.println("MITJA:" + (valor1+valor2)/2);
   }
}

Estem calculant la suma dels valors dues vegades. Podem emmagatzemar el resultat en una variable i reutilitzar-lo. Només cal seleccionar l'expressió i polsar Ctrl+Alt+V