¿Cómo asegurarse de que una clase genere únicamente un objeto instanciado? La solución consiste en restringir el acceso al constructor. Dado que cada objeto se crea mediante la invocación del constructor, si este no está disponible para uso externo, no será posible crear instancias desde fuera. En Java, esto se logra declarando el constructor como private, lo que limita su acceso solo al interior de la clase. Por ejemplo: ```

class Singleton { private Singleton() { }

public void mostrar() {
    System.out.println("Hola, Mundo!");
}

}

public class Ejemplo { public static void main(String[] args) { Singleton instancia = null; instancia = new Singleton(); // Error: constructor privado } }

Este código fallará al compilar porque el constrcutor es inaccesible desde fuera. Para resolverlo, se puede crear una instancia dentro de la propia clase. Sin embargo, si se declara como miembro normal, no podrá ser accedida sin instanciar la clase. La solución es usar `static` para garantizar que el atribuot sea compartido y accesible sin necesidad de instanciar la clase. ```

package modelo;

class Singleton {
    private static Singleton instancia = new Singleton();
    
    private Singleton() { }
    
    public void mostrar() {
        System.out.println("Hola, Mundo!");
    }
    
    public static Singleton obtenerInstancia() {
        return instancia;
    }
}

public class Prueba {
    public static void main(String[] args) {
        Singleton s = Singleton.obtenerInstancia();
        s.mostrar();
    }
}

Ahora se puede acceder a la instancia sin crear objetos adicionales. Aunque funciona, aún hay un problema: si se permite modificar la referencia interna, podría crearse una nueva instancia. Para evitarlo, se debe usar final junto con static: ```

private static final Singleton INSTANCIA = new Singleton();

Con esta declaración, la variable no puede ser reasignada, asegurando así que siempre haya una sola instancia. Multiton: Controlar múltiples instancias predefinidas
-----------------------------------------------------

Mientras que Singleton limita a una única instancia, Multiton permite definir un número fijo de instancias predeterminadas. Un caso común es representar valores cuyos casos son conocidos y finitos, como géneros humanos o días de la semana. Ejemplo: Clase que representa el sexo humano con solo dos instancias posibles. ```

package modelo;

class Sexo {
    private static final Sexo HOMBRE = new Sexo("Hombre");
    private static final Sexo MUJER = new Sexo("Mujer");
    
    private String nombre;
    
    private Sexo(String nombre) {
        this.nombre = nombre;
    }
    
    public String getNombre() {
        return nombre;
    }
    
    public static Sexo obtenerSexo(int opcion) {
        switch (opcion) {
            case 1: return HOMBRE;
            case 2: return MUJER;
            default: return null;
        }
    }
}

public class DemoMultiton {
    public static void main(String[] args) {
        Sexo sexo = Sexo.obtenerSexo(1);
        System.out.println(sexo.getNombre());
    }
}

Este patrón garantiza que solo existan las instancias definidas, evitando cualquier creación adicional fuera de los casos permitidos.