Quels modèles de conception connaissez-vous?

Générateurs:

Singleton: Garantit qu'une seule instance d'une classe existe et fournit un point d'accès global à cette instance.
Factory Method: Définit une interface pour créer un objet, mais laisse aux sous-classes le soin de décider quelle classe instancier.
Abstract Factory: Fournit une interface pour créer des familles d'objets liés ou dépendants sans spécifier leurs classes concrètes.
Builder: Divise la construction d'un objet complexe en étapes, permettant de créer différentes représentations de l'objet en utilisant le même processus de construction.
Prototype: Crée des objets en dupliquant une instance existante (prototype), plutôt qu'en effectuant le processus de construction à nouveau.

Structuraux:

Adapter: Convertit l'interface d'une classe en une autre interface que les clients attendent. Permet à des classes avec des interfaces incompatibles de travailler ensemble.
Bridge: Sépare l'abstraction de sa mise en œuvre, permettant à chacune de varier indépendamment.
Composite: Compose des objets en structures arborescentes pour représenter des hiérarchies partie-tout. Permet aux clients de traiter de manière uniforme des objets individuels et des compositions d'objets.
Decorator: Ajoute dynamiquement des responsabilités à un objet en l'enveloppant dans un objet décorateur.
Facade: Fournit une interface unifiée à un ensemble d'interfaces dans un sous-système. Définit une interface de niveau supérieur qui facilite son utilisation.
Flyweight: Utilise l'état partagé entre de nombreux petits objets pour réduire la mémoire utilisée et améliorer la performance.
Proxy: Fournit un représentant ou un substitut pour un autre objet qui contrôle l'accès à celui-ci.

Comportementaux:

Chain of Responsibility: Transmet la requête le long d'une chaîne de gestionnaires. Chaque gestionnaire décide s'il doit traiter la requête ou la transmettre au suivant.
Command: Encapsule une requête en tant qu'objet, permettant de paramétrer des clients avec différentes requêtes, de mettre en file d'attente des requêtes ou de suivre leur exécution.
Interpreter: Définit la grammaire d'un langage et fournit un interprète pour interpréter les expressions dans ce langage.
Iterator: Fournit un moyen d'accéder séquentiellement à tous les éléments d'une collection sans révéler sa représentation interne.
Mediator: Définit des objets qui contrôlent l'interaction entre un ensemble d'objets. Favorise un faible couplage en permettant aux objets d'interagir via un médiateur.
Memento: Permet de sauvegarder et de restaurer l'état interne d'un objet sans violer son encapsulation.
Observer: Définit une dépendance un-à-plusieurs entre objets, de sorte que lorsque l'état d'un objet change, tous ses dépendants sont notifiés et mis à jour automatiquement.
State: Permet à un objet de changer son comportement lorsqu'il change d'état interne. L'objet semblera changer de classe.
Strategy: Définit une famille d'algorithmes, en encapsule chacun et les rend interchangeables. Permet de choisir l'algorithme au moment de l'exécution.
Template Method: Définit la structure d'un algorithme dans une opération, en laissant certains pas aux sous-classes. Permet aux sous-classes de redéfinir certains pas de l'algorithme sans changer sa structure.
Visitor: Représente une opération qui doit être effectuée sur les éléments d'une structure d'objets. Permet de définir de nouvelles opérations sans changer les classes des éléments sur lesquels elle agit.

En développement iOS, on rencontre aussi fréquemment:

Model-View-Controller (MVC): Patron architectural qui divise l'application en trois composants liés : Modèle (données et logique métier), Vue (interface utilisateur) et Contrôleur (liaison entre Modèle et Vue).
Delegate: Patron qui permet à un objet d'agir au nom ou de coordonner les actions d'un autre objet.
Observer (NotificationCenter): Système de diffusion de notifications permettant aux objets de recevoir des messages sans relation directe entre eux.
Target-Action: Mécanisme utilisé pour envoyer des messages depuis des éléments de contrôle (par exemple, des boutons) à un objet cible.
Coordinator: Patron pour gérer les flux de navigation dans une application, séparant la logique de navigation des contrôleurs.
Dependency Injection: Patron dans lequel les dépendances d'un objet sont injectées de l'extérieur plutôt que créées par l'objet lui-même.

// Exemple Singleton
class SettingsManager {
    static let shared = SettingsManager() // Instance unique

    private init() {
        // Constructeur privé pour empêcher la création externe
    }

    var appVersion: String {
        return Bundle.main.infoDictionary?["CFBundleShortVersionString"] as? String ?? "Inconnu"
    }
}

// Utilisation
let settings = SettingsManager.shared
print("Version de l'app: \(settings.appVersion)")

// Exemple Delegate (simple)
protocol ButtonDelegate: AnyObject {
    func buttonWasTapped(_ button: UIButton)
}

class MyButton: UIButton {
    weak var delegate: ButtonDelegate? // Propriété déléguée

    override func touchesEnded(_ touches: Set<UITouch>, with event: UIEvent?) {
        super.touchesEnded(touches, with: event)
        delegate?.buttonWasTapped(self) // Appel de la méthode du délégué
    }
}

class ViewController: UIViewController, ButtonDelegate {
    override func viewDidLoad() {
        super.viewDidLoad()
        let myButton = MyButton(frame: CGRect(x: 50, y: 50, width: 100, height: 40))
        myButton.setTitle("Touche-moi", for: .normal)
        myButton.backgroundColor = .blue
        myButton.delegate = self // Définir le délégué
        view.addSubview(myButton)
    }

    func buttonWasTapped(_ button: UIButton) {
        print("El botón fue tocado en ViewController")
    }
}