Patrons de conception/Médiateur
Le patron de conception Médiateur fournit une interface unifiée pour un ensemble d'interfaces d'un sous-système. Il est utilisé pour réduire les dépendances entre plusieurs classes.
Lorsqu'un logiciel est composé de plusieurs classes, les traitements et les données sont répartis entre toutes ces classes. Plus il y a de classes, plus le problème de communication entre celles-ci peut devenir complexe. En effet, plus les classes dépendent des méthodes des autres classes plus l'architecture devient complexe. Cela ayant des impacts sur la lisibilité du code et sa maintenabilité dans le temps.
Le modèle de conception Médiateur résout ce problème. Pour ce faire, le Médiateur est la seule classe ayant connaissance des interfaces des autres classes. Lorsqu'une classe désire interagir avec une autre, elle doit passer par le médiateur qui se chargera de transmettre l'information à la ou les classes concernées.
Exemples.
Java.
// Interface Collègue
interface Command
 void execute();
// Médiateur concret
class Mediator
 BtnView btnView;
 BtnSearch btnSearch;
 BtnBook btnBook;
 LblDisplay show;
 void registerView(BtnView v)
 btnView = v;
 void registerSearch(BtnSearch s)
 btnSearch = s;
 void registerBook(BtnBook b)
 btnBook = b;
 void registerDisplay(LblDisplay d)
 show = d;
 void book()
 btnBook.setEnabled(false);
 btnView.setEnabled(true);
 btnSearch.setEnabled(true);
 show.setText("booking...");
 void view()
 btnView.setEnabled(false);
 btnSearch.setEnabled(true);
 btnBook.setEnabled(true);
 show.setText("viewing...");
 void search()
 btnSearch.setEnabled(false);
 btnView.setEnabled(true);
 btnBook.setEnabled(true);
 show.setText("searching...");
// Un collègue concret
class BtnView extends JButton implements Command
 Mediator med;
 BtnView(ActionListener al, Mediator m)
 super("View");
 addActionListener(al);
 med = m;
 med.registerView(this);
 public void execute()
 med.view();
// Un collègue concret
class BtnSearch extends JButton implements Command
 Mediator med;
 BtnSearch(ActionListener al, Mediator m)
 super("Search");
 addActionListener(al);
 med = m;
 med.registerSearch(this);
 public void execute()
 med.search();
// Un collègue concret
class BtnBook extends JButton implements Command
 Mediator med;
 BtnBook(ActionListener al, Mediator m)
 super("Book");
 addActionListener(al);
 med = m;
 med.registerBook(this);
 public void execute()
 med.book();
class LblDisplay extends JLabel
 Mediator med;
 LblDisplay(Mediator m)
 super("Just start...");
 med = m;
 med.registerDisplay(this);
 setFont(new Font("Arial", Font.BOLD, 24));
class MediatorDemo extends JFrame implements ActionListener
 Mediator med = new Mediator();
 MediatorDemo()
 JPanel p = new JPanel();
 p.add(new BtnView(this, med));
 p.add(new BtnBook(this, med));
 p.add(new BtnSearch(this, med));
 getContentPane().add(new LblDisplay(med), "North");
 getContentPane().add(p, "South");
 setSize(400, 200);
 setVisible(true);
 public void actionPerformed(ActionEvent ae)
 Command comd = (Command) ae.getSource();
 comd.execute();
 public static void main(String[] args)
 new MediatorDemo();

Spectrométrie de fluorescence X
Le but de ce wikilivre est d'héberger des informations de référence sur la spectrométrie de fluorescence X.
Raies caractéristiques des éléments dans le domaine des rayons X.
Pour la notation des raies, voir "Notation de Siegbahn".
Cristaux analyseurs utilisés en fluorescence X.
Pour la relation entre la longueur d'onde diffractant et la distance interréticulaire, voir "Loi de Bragg".

Patrons de conception/Mémento
Le patron mémento est un patron de conception qui fournit la manière de renvoyer un objet à un état précédent (retour arrière) sans violer le principe d'encapsulation.
Le mémento est utilisé par deux objets : le créateur et le gardien.
Le créateur est un objet ayant un état interne (état à sauvegarder).
Le gardien agira sur le créateur, tout en conservant la possibilité de revenir en arrière.
Le gardien demande alors au créateur l'objet mémento pour enregistrer son état actuel.
Il effectue l'opération (ou séquence d'opérations) souhaitée.
Afin de permettre le retour arrière dans l'état d'avant les opérations, le mémento est retourné au créateur.
L'objet mémento même est opaque (le gardien ne peut, ou ne devrait pas, le modifier).
Lors de l'utilisation de ce patron, une attention toute particulière doit être prise si le créateur modifie d'autres objets ou ressources : Le patron mémento n'opère que sur un seul objet.
Il faut souligner que le fait de sauvegarder l'état interne de l'objet créateur doit s'effectuer sans casser le principe d'encapsulation.
Cela n'est pas toujours possible (exemple : SmallTalk ne le permet pas de façon directe).
Des exemples classiques du patron mémento incluent le générateur de nombres pseudo-aléatoires, la machine à états finis, la fonction "Annulation" / "Undo".
Diagramme de classes.
Le patron de conception Mémento peut être représenté par le diagramme de classes UML suivant :
Exemples.
Java.
Cet exemple illustre l'usage du patron Mémento pour réaliser une commande de type annuler.
import java.util.*;
class Originator
 private String state;
 public void set(String state)
 System.out.println("Originator : état affecté à : "+state);
 this.state = state;
 public Object saveToMemento()
 System.out.println("Originator : sauvegardé dans le mémento.");
 return new Memento(state);
 public void restoreFromMemento(Object m)
 if (m instanceof Memento)
 Memento memento = (Memento)m;
 state = memento.getSavedState();
 System.out.println("Originator : État après restauration : "+state);
 private static class Memento
 private String state;
class Caretaker
 private ArrayList savedStates = new ArrayList();
class MementoExample
 public static void main(String[] args)
 Caretaker caretaker = new Caretaker();
 Originator originator = new Originator();
 originator.set("State1");
 originator.set("State2");
 caretaker.addMemento( originator.saveToMemento() );
 originator.set("State3");
 caretaker.addMemento( originator.saveToMemento() );
 originator.set("State4");
 originator.restoreFromMemento( caretaker.getMemento(1) );
Ce programme affiche :
 Originator : état affecté à : State1
 Originator : état affecté à : State2
 Originator : sauvegarde dans le memento.
 Originator : état affecté à : State3
 Originator : sauvegarde dans le memento.
 Originator : état affecté à : State4
 Originator : État après restauration : State3
Cet exemple utilise la classe String pour l'état (state dans l'exemple), or cette classe est un type immuable en Java.
Lorsque l'état n'est pas un objet immuable, il devra être cloné avant d'être ajouté dans le memento. 
private Memento(State state)
 // state doit être cloné avant d'être ajouté au memento,
 // sinon plusieurs memento retournerons tous une référence sur le même objet
 this.mementoState = state.clone();