# Patrons de conception/Faible couplage

* Introduction
* Patrons du « Gang of Four »
** Patrons de création
*** Singleton
*** Prototype
*** Fabrique
*** Fabrique abstraite
*** Monteur
** Patrons de structure
*** Pont
*** Façade
*** Adaptateur
*** Objet composite
*** Proxy
*** Poids-mouche
*** Décorateur
** Patrons de comportement
*** Chaîne de responsabilité
*** Commande
*** Interpréteur
*** Itérateur
*** Médiateur
*** Mémento
*** Observateur
*** État
*** Stratégie
*** Patron de méthode
*** Visiteur
* Patrons GRASP
** Expert en information
** Créateur
** Faible couplage
** Forte cohésion
** Contrôleur
** Polymorphisme
** Fabrication pure
** Indirection
** Protection
* Patrons d'entreprise
** Logique du domaine
*** Script de transaction
*** Modèle du domaine
*** Module de table
*** Couche de service
** Architecture de source de données
*** Passerelle de table de données
*** Passerelle de ligne de données
*** Enregistrement actif
*** Gestion de données
** Comportement objet-relationnel
*** Unité de travail
*** Carte d'identité
*** Chargement différé
** Structure objet-relationnel
** Association méta-données objet-relationnel
** Présentation web
** Distribution
** Concurrence locale (hors-ligne)
** État de session (Session State Patterns)
** Patrons de base
*** Passerelle (Gateway)
*** Mapper
*** Type de base pour la couche
*** Interface séparée
*** Registre
*** Plugin
*** Objet valeur
*** Monnaie
*** Cas spécial
*** Service de substitution
*** Ensemble d'enregistrements
* Autres patrons
** Type fantôme
** Double-dispatch
** Post-Redirect-Get
** Map-Reduce
** Évaluation retardée
** Copie sur modification
** Injection de dépendance
** Inversion de contrôle
** Modèle-Vue-Contrôleur
** Modèle-Vue-Présentateur
** Écart de génération
** Objet nul
** Objets réutilisables
** Outbox
** Feature toggles
* Bibliographie et liens
* Introduction
* Patrons du « Gang of Four »
** Patrons de création
*** Singleton
*** Prototype
*** Fabrique
*** Fabrique abstraite
*** Monteur
** Patrons de structure
*** Pont
*** Façade
*** Adaptateur
*** Objet composite
*** Proxy
*** Poids-mouche
*** Décorateur
** Patrons de comportement
*** Chaîne de responsabilité
*** Commande
*** Interpréteur
*** Itérateur
*** Médiateur
*** Mémento
*** Observateur
*** État
*** Stratégie
*** Patron de méthode
*** Visiteur
* Patrons GRASP
** Expert en information
** Créateur
** Faible couplage
** Forte cohésion
** Contrôleur
** Polymorphisme
** Fabrication pure
** Indirection
** Protection
* Patrons d'entreprise
** Logique du domaine
*** Script de transaction
*** Modèle du domaine
*** Module de table
*** Couche de service
** Architecture de source de données
*** Passerelle de table de données
*** Passerelle de ligne de données
*** Enregistrement actif
*** Gestion de données
** Comportement objet-relationnel
*** Unité de travail
*** Carte d'identité
*** Chargement différé
** Structure objet-relationnel
** Association méta-données objet-relationnel
** Présentation web
** Distribution
** Concurrence locale (hors-ligne)
** État de session (Session State Patterns)
** Patrons de base
*** Passerelle (Gateway)
*** Mapper
*** Type de base pour la couche
*** Interface séparée
*** Registre
*** Plugin
*** Objet valeur
*** Monnaie
*** Cas spécial
*** Service de substitution
*** Ensemble d'enregistrements
* Autres patrons
** Type fantôme
** Double-dispatch
** Post-Redirect-Get
** Map-Reduce
** Évaluation retardée
** Copie sur modification
** Injection de dépendance
** Inversion de contrôle
** Modèle-Vue-Contrôleur
** Modèle-Vue-Présentateur
** Écart de génération
** Objet nul
** Objets réutilisables
** Outbox
** Feature toggles
* Bibliographie et liens
[ Modifier le sommaire ]
Le couplage mesure la dépendance entre des classes ou des modules.
Le faible couplage favorise :
* la faible dépendance entre les classes,
* la réduction de l'impact des changements dans une classe,
* la réutilisation des classes ou modules.
Pour affaiblir le couplage, il faut :
* diminuer la quantité de paramètres passés entre les modules,
* éviter d'utiliser des variables globales (par exemple, si une mauvaise valeur est assignée, détecter la fonction/classe incorrecte est plus difficile), il vaut mieux passer les valeurs en paramètres.

## Exemples
### Facturation

Dans un logiciel de gestion de vente, nous avons les classes suivantes :

#### Facture

    Contient un ensemble de produit facturé et est associée à un mode de paiement,

#### Paiement

    Décrit un mode de paiement (espèces, chèque, carte bancaire, à crédit, ...),

#### Client

    Effectue les commandes.
On ajoute une méthode payer à la classe Client. On étudie le couplage dans les deux cas suivants :
* La méthode payer crée une instance de Paiement et l'assigne à l'objet Facture.
* La méthode payer délègue l'action à la classe Facture qui crée une instance de Paiement et l'assigne.
Le couplage est plus faible dans le deuxième cas car la méthode payer de la classe Client n'a pas besoin de savoir qu'il existe une classe Paiement, c'est à dire qu'elle ne dépend pas de l'existence ou non de cette classe.