Patrón Abstract Factory

from abc import ABC, abstractmethod


# Los productos: cada uno tiene una versión por tema
class BotonClaro:
    def pintar(self, texto):
        return f"[ {texto} ]"


class CasillaClara:
    def pintar(self, texto, marcada):
        return ("[x] " if marcada else "[ ] ") + texto


class BotonOscuro:
    def pintar(self, texto):
        return f"<< {texto.upper()} >>"


class CasillaOscura:
    def pintar(self, texto, marcada):
        return ("(*) " if marcada else "( ) ") + texto


class FabricaUI(ABC):
    """La fábrica abstracta: crea una familia entera de productos que encajan entre sí."""
    @abstractmethod
    def crear_boton(self): ...

    @abstractmethod
    def crear_casilla(self): ...


class TemaClaro(FabricaUI):
    def crear_boton(self):
        return BotonClaro()

    def crear_casilla(self):
        return CasillaClara()


class TemaOscuro(FabricaUI):
    def crear_boton(self):
        return BotonOscuro()

    def crear_casilla(self):
        return CasillaOscura()


class Formulario:
    """El cliente: monta el formulario sin saber de qué tema son las piezas, y nunca mezcla dos temas."""
    def __init__(self, fabrica):
        self.boton = fabrica.crear_boton()
        self.casilla = fabrica.crear_casilla()

    def mostrar(self):
        print(self.casilla.pintar("Acepto las condiciones", True))
        print(self.casilla.pintar("Quiero recibir novedades", False))
        print(self.boton.pintar("Enviar"))


temas = {"claro": TemaClaro(), "oscuro": TemaOscuro()}
for nombre, fabrica in temas.items():
    print(f"Tema {nombre}:")
    Formulario(fabrica).mostrar()

// Los productos: cada uno tiene una versión por tema
class BotonClaro { pintar(texto) { return `[ ${texto} ]`; } }
class CasillaClara { pintar(texto, marcada) { return (marcada ? "[x] " : "[ ] ") + texto; } }
class BotonOscuro { pintar(texto) { return `<< ${texto.toUpperCase()} >>`; } }
class CasillaOscura { pintar(texto, marcada) { return (marcada ? "(*) " : "( ) ") + texto; } }

// Las fábricas concretas: cada una crea una familia entera de productos que encajan entre sí
class TemaClaro {
    crearBoton() { return new BotonClaro(); }
    crearCasilla() { return new CasillaClara(); }
}

class TemaOscuro {
    crearBoton() { return new BotonOscuro(); }
    crearCasilla() { return new CasillaOscura(); }
}

/** El cliente: monta el formulario sin saber de qué tema son las piezas, y nunca mezcla dos temas. */
class Formulario {
    constructor(fabrica) {
        this.boton = fabrica.crearBoton();
        this.casilla = fabrica.crearCasilla();
    }

    mostrar() {
        console.log(this.casilla.pintar("Acepto las condiciones", true));
        console.log(this.casilla.pintar("Quiero recibir novedades", false));
        console.log(this.boton.pintar("Enviar"));
    }
}

const temas = new Map([["claro", new TemaClaro()], ["oscuro", new TemaOscuro()]]);
for (const [nombre, fabrica] of temas) {
    console.log(`Tema ${nombre}:`);
    new Formulario(fabrica).mostrar();
}

using System;
using System.Collections.Generic;

// Los productos: cada uno tiene una versión por tema
interface IBoton { string Pintar(string texto); }
interface ICasilla { string Pintar(string texto, bool marcada); }

class BotonClaro : IBoton { public string Pintar(string texto) => 
quot;[ {texto} ]"; }
class CasillaClara : ICasilla { public string Pintar(string texto, bool marcada) => (marcada ? "[x] " : "[ ] ") + texto; }
class BotonOscuro : IBoton { public string Pintar(string texto) => 
quot;<< {texto.ToUpperInvariant()} >>"; }
class CasillaOscura : ICasilla { public string Pintar(string texto, bool marcada) => (marcada ? "(*) " : "( ) ") + texto; }

// La fábrica abstracta: crea una familia entera de productos que encajan entre sí.
interface IFabricaUI {
    IBoton CrearBoton();
    ICasilla CrearCasilla();
}

class TemaClaro : IFabricaUI {
    public IBoton CrearBoton() => new BotonClaro();
    public ICasilla CrearCasilla() => new CasillaClara();
}

class TemaOscuro : IFabricaUI {
    public IBoton CrearBoton() => new BotonOscuro();
    public ICasilla CrearCasilla() => new CasillaOscura();
}

// El cliente: monta el formulario sin saber de qué tema son las piezas, y nunca mezcla dos temas.
class Formulario {
    private readonly IBoton boton;
    private readonly ICasilla casilla;

    public Formulario(IFabricaUI fabrica) {
        boton = fabrica.CrearBoton();
        casilla = fabrica.CrearCasilla();
    }

    public void Mostrar() {
        Console.WriteLine(casilla.Pintar("Acepto las condiciones", true));
        Console.WriteLine(casilla.Pintar("Quiero recibir novedades", false));
        Console.WriteLine(boton.Pintar("Enviar"));
    }
}

class Program {
    static void Main() {
        var temas = new List<(string Nombre, IFabricaUI Fabrica)> { ("claro", new TemaClaro()), ("oscuro", new TemaOscuro()) };
        foreach (var (nombre, fabrica) in temas) {
            Console.WriteLine(
quot;Tema {nombre}:");
            new Formulario(fabrica).Mostrar();
        }
    }
}

<?php
// Los productos: cada uno tiene una versión por tema
interface Boton { public function pintar(string $texto): string; }
interface Casilla { public function pintar(string $texto, bool $marcada): string; }

class BotonClaro implements Boton {
    public function pintar(string $texto): string { return "[ $texto ]"; }
}
class CasillaClara implements Casilla {
    public function pintar(string $texto, bool $marcada): string { return ($marcada ? "[x] " : "[ ] ") . $texto; }
}
class BotonOscuro implements Boton {
    public function pintar(string $texto): string { return "<< " . mb_strtoupper($texto) . " >>"; }
}
class CasillaOscura implements Casilla {
    public function pintar(string $texto, bool $marcada): string { return ($marcada ? "(*) " : "( ) ") . $texto; }
}

/** La fábrica abstracta: crea una familia entera de productos que encajan entre sí. */
interface FabricaUI {
    public function crearBoton(): Boton;
    public function crearCasilla(): Casilla;
}

class TemaClaro implements FabricaUI {
    public function crearBoton(): Boton { return new BotonClaro(); }
    public function crearCasilla(): Casilla { return new CasillaClara(); }
}

class TemaOscuro implements FabricaUI {
    public function crearBoton(): Boton { return new BotonOscuro(); }
    public function crearCasilla(): Casilla { return new CasillaOscura(); }
}

/** El cliente: monta el formulario sin saber de qué tema son las piezas, y nunca mezcla dos temas. */
class Formulario {
    private Boton $boton;
    private Casilla $casilla;

    public function __construct(FabricaUI $fabrica) {
        $this->boton = $fabrica->crearBoton();
        $this->casilla = $fabrica->crearCasilla();
    }

    public function mostrar(): void {
        echo $this->casilla->pintar("Acepto las condiciones", true), "\n";
        echo $this->casilla->pintar("Quiero recibir novedades", false), "\n";
        echo $this->boton->pintar("Enviar"), "\n";
    }
}

$temas = ["claro" => new TemaClaro(), "oscuro" => new TemaOscuro()];
foreach ($temas as $nombre => $fabrica) {
    echo "Tema $nombre:\n";
    (new Formulario($fabrica))->mostrar();
}

# La familia se elige una vez, al arrancar; el resto del programa solo ve la fábrica.
fabrica = TemaOscuro() if config.get("tema") == "oscuro" else TemaClaro()
formulario = Formulario(fabrica)

# La DB-API funciona igual: la conexión de sqlite3 crea cursores de sqlite3; con psycopg
# (PostgreSQL) todas las piezas serían de psycopg y este código no cambiaría.
with sqlite3.connect("instituto.db") as con:
    cur = con.cursor()
    cur.execute("SELECT nombre FROM alumno WHERE ciclo = ?", ("DAM",))
    for (nombre,) in cur.fetchall():
        print(nombre)

// La familia se elige una vez, al arrancar; el resto del programa solo ve la fábrica.
const oscuro = matchMedia("(prefers-color-scheme: dark)").matches;
const fabrica = oscuro ? new TemaOscuro() : new TemaClaro();
const formulario = new Formulario(fabrica);

// document también crea familias: los elementos de un mismo espacio de nombres (SVG aquí)
// encajan entre sí; con createElement saldrían elementos HTML.
const SVG = "http://www.w3.org/2000/svg";
const dibujo = document.createElementNS(SVG, "svg");
const circulo = document.createElementNS(SVG, "circle");
dibujo.append(circulo);

// La familia se elige una vez, al arrancar; el resto del programa solo ve la fábrica.
IFabricaUI fabrica = config["tema"] == "oscuro" ? new TemaOscuro() : new TemaClaro();
var formulario = new Formulario(fabrica);

// ADO.NET tiene la fábrica abstracta con nombre propio: DbProviderFactory. Con la de SQLite
// todas las piezas son de SQLite; con la de SQL Server, todas de SQL Server.
DbProviderFactory db = SqliteFactory.Instance;
using DbConnection con = db.CreateConnection()!;
con.ConnectionString = "Data Source=instituto.db";
con.Open();
using DbCommand cmd = con.CreateCommand();
cmd.CommandText = "SELECT nombre FROM alumno";
using DbDataReader lector = cmd.ExecuteReader();

<?php
// La familia se elige una vez, al arrancar; el resto del programa solo ve la fábrica.
$fabrica = ($config["tema"] ?? "claro") === "oscuro" ? new TemaOscuro() : new TemaClaro();
$formulario = new Formulario($fabrica);

// PDO funciona igual: según el DSN, la conexión y las sentencias que crea son de MySQL,
// de PostgreSQL o de SQLite, y este código no cambia.
$pdo = new PDO("mysql:host=localhost;dbname=instituto", $usuario, $clave);
$st = $pdo->prepare("SELECT nombre FROM alumno WHERE ciclo = ?");
$st->execute(["DAM"]);
foreach ($st as $fila) echo $fila["nombre"], "\n";