home
Design Pattern cheat sheet
Most popular in Java
print

Qu'est ce qu'un patron de conception ?

C'est une solution générique, personnalisable et réutilisable pour des problèmes que l'on rencontre dans la conception logiciel.

Quels sont les types de patron de conception ?

Ils sont classifiés selon 3 types principaux :

Créateurs

Ils fournissent des mécanismes de création d'objet augmentant la flexibilité, maintenabilité et réutilisabilité du code.

Structuraux

Ils permettent d'assembler les objets et de structurer les classes en utilisant le concept d'héritage.

Comportementaux

Ils permettent la mise en place d'algorithme pour le traitement des objets.

Qu'apportent les patrons de conception ?

  • Des solutions prouvées et testées pour de nombreux problèmes de programmation orientée objet

  • Un langage commun pour discuter des solutions à mettre en place

Il est approprié de les utiliser pour :

  • Optimiser des parties du code actuel
  • Résoudre un problème pour lequel un patron de conception existe

Il n'est pas approprié de les utiliser pour :

  • Placer un patron de conception juste pour en placer un
  • Modifier la structure du code pour coller exactement à un patron de conception

Patron de conception Créateur

Singleton

Avoir une seule instance de l'objet toujours appelée

public class MySingleton {
  private static MySingleton instance;
  private MySingleton(){}

  public final static MySingleton getInstance(){
      if (instance == null){
          return new MySingleton();
      }
      return instance;
  }  
}

Factory

Exposer une interface unique pour créer des objets de la même famille 

public interface Animal {
    void sound();
}
public class Dog implements Animal {
    @Override
    public void sound(){
        System.out.println("bark");
    }
}
public class Cat implements Animal {
    @Override
    public void sound(){
        System.out.println("meow");
    }
}
public class AnimalFactory{
    Animal getAnimal(String animal){
        return animal.equalsIgnoreCase("DOG")? 
            new Dog(): new Cat();
    }
}
public class DemoFactory {
    AnimalFactory factory = new AnimalFactory();
    public static void main(String[] args) {
        Animal animal = factory.getAnimal("DOG");
        Animal animal2 = factory.getAnimal("CAT");
        animal.sound(); // bark
        animal2.sound(); // meow
    }
}
Design Pattern cheat sheet

patron de conception Structural

Facade

Cache la complexité métier en fournissant une interface simplifié

public class Computer {
  public Computer (){
  }

  void addRAM(int RAM){}
  void addKeyboard(String keyboard){}
  void addMouse(String mouse){} 
}
public class Technician {
  public Technician(){
  }
  String[] compareKeyboard(){}
  String chooseBestKeyboard(String[] keyboards){}
  String chooseBestMouse(){}
}

public class StoreFacade {
  Computer computer;
  Technician technician;

  public StoreFacade(){
    this.technician = new Technician();
  }

  public Computer buildPerfectPC{
      Computer perfectPC = new Computer();
      String[] listOfKbds = this.technician.compareKeyboard();
      String theKbd = this.technician.chooseBestKeyboard(listOfKbds);
      String theMouse = this.technician.chooseBestMouse();
      int nbOfRAM = 16;

      perfectPC.addRAM(nbOfRAM);
      perfectPC.addKeyboard(theKeyboard);
      perfectPC.addMouse(theMouse);

      return perfectPC;
  }
  
}
public class DemoFacade {
    public static void main(String[] args) {
      StoreFacade storeFacade = new StoreFacade();
      storeFacade.buildPerfectPC();
    }
}

Patron de conception Comportemental

Strategy

Définition d'une famille d'algorithme dans des classes séparées pour les rendre interchangeable

public interface Strategy {
   public int doOperation(int num1, int num2);
}

public class OperationAdd implements Strategy{
   @Override
   public int doOperation(int num1, int num2) {
      return num1 + num2;
   }
}

public class OperationSubstract implements Strategy{
   @Override
   public int doOperation(int num1, int num2) {
      return num1 - num2;
   }
}

public class Context {
   private Strategy strategy;

   public Context(Strategy strategy){
      this.strategy = strategy;
   }

   public int executeStrategy(int num1, int num2){
      return strategy.doOperation(num1, num2);
   }
}

public class StrategyPatternDemo {
   public static void main(String[] args) {
      Context context = new Context(new OperationAdd());		
      context.executeStrategy(10, 5); // 15

      context = new Context(new OperationSubstract());		
      context.executeStrategy(10, 5); // 5

Exemple de librairie qui utilise le patron de conception : Dans le JDK, Collections.sort()