====Réduire le nombre de if/switch====

[[https://code.joejag.com/2016/anti-if-the-missing-patterns.html|Anti-If: The missing patterns]] {{ lang:recommandation:condition:anti-if_the_missing_patterns_2020-03-02_19_26_37_.html |Archive du 09/06/2016 le 02/03/2020}}

===Code différent si un paramètre est différent===

Dans ce cas, il faut séparer le code en deux fonctions.

  * Avant :

<code java>
public static void createFile(String name, String contents, boolean temporary) {
  if(temporary) {
    // save temp file
  } else {
    // save permanent file
  }
}
</code>

  * Après :

<code java>
public static void createFile(String name, String contents) {
  // save permanent file
}

public static void createTemporaryFile(String name, String contents) {
  // save temp file
}
</code>

===Polymorphisme===

  * Avant :

<code java>
public class Bird {
  public double getSpeed() {
    switch (type) {
      case EUROPEAN:
        return getBaseSpeed();
      case AFRICAN:
        return getBaseSpeed() - getLoadFactor();
      case NORWEGIAN_BLUE:
        return isNailed ? 0 : getBaseSpeed();
      default:
        return 0;
    }
  }
}
</code>

  * Après :

<code java>
public abstract class Bird {
  public abstract double getSpeed();
}

public class EuropeanBird extends Bird {
  public double getSpeed() {
    return getBaseSpeed();
  }
}

public class AfricanBird extends Bird {
  public double getSpeed() {
    return getBaseSpeed() - getLoadFactor();
  }
}

public class NorwegianBird extends Bird {
  public double getSpeed() {
    return isNailed ? 0 : getBaseSpeed();
  }
}
</code>

===Pattern Command / Abstract factory===

Il est possible d'appliquer différents patterns pour éviter les conditions.

[[https://www.developer.com/java/data/seven-ways-to-refactor-java-switch-statements.html|Seven Ways to Refactor Java switch Statements]] {{ lang:recommandation:condition:seven_ways_to_refactor_java_switch_statements_-_developer.com_2020-03-02_20_46_42_.html |Archive du 10/11/2017 le 02/03/2020}}

  * [[helloworld:design_pattern:command|Command]] : cette méthode est proche du paragraphe [[lang:recommandation:condition#polymorphisme|Polymorphisme]].

On crée la même classe partout et on met dans une instance composite la méthode à exécuter. Si la méthode à exécuter peut varier dans le temps, on peut aussi mettre les différentes méthodes à exécuter dans une map. C'est plus rapide et plus facile à lire qu'un ''switch''.

  * [[helloworld:design_pattern:etat|État]] : c'est comme le pattern [[helloworld:design_pattern:command|command]] mais c'est après chaque modification de l'état que la classe command est automatiquement remplacée par la nouvelle classe.

  * [[helloworld:design_pattern:fabrique_abstraite|Fabrique abstraite]] : utilisable si le switch est pour l'allocation d'une ressource.

===Préférer une liste vide à un null===

  * Avant :

<code java>
public void example() {
  sumOf(null);
}

public static int sumOf(List<Integer> numbers) {
  if(numbers == null) {
    return 0;
  }

  return numbers.stream().mapToInt(i -> i).sum();
}
</code>

  * Après :

<code java>
public void example() {
  sumOf(new ArrayList<>());
}

public static int sumOf(List<Integer> numbers) {
  return numbers.stream().mapToInt(i -> i).sum();
}
</code>

===Combiner les conditions===

  * Avant :

<code java>
public boolean horrible(boolean foo, boolean bar, boolean baz) {
  if (foo) {
    if (bar) {
      return true;
    }
  }

  if (baz) {
    return true;
  } else {
    return false;
  }
}
</code>

  * Après :

<code java>
public boolean horrible(boolean foo, boolean bar, boolean baz) {
  return foo && bar || baz;
}
</code>