¿Formas de garantizar instancias únicas de una clase?

Estoy buscando diferentes formas de garantizar que cada instancia de una clase determinada sea una instancia identificable de forma única.

Por ejemplo, tengo una Nameclase con el campo name. Una vez que tengo un Nameobjeto nameinicializado a John Smith, no quiero poder crear una instancia de un Nameobjeto diferente también con el nombre de John Smith, o si se produce una instanciación, quiero que se devuelva una referencia al objeto original. que un nuevo objeto

Soy consciente de que una forma de hacerlo es tener una fábrica estática que contenga Maptodos los objetos de Nombre actuales y la fábrica verifica que un objeto con John Smith como nombre ya no exista antes de devolver una referencia a un Nameobjeto.

Otra forma de pensar en la parte superior de mi cabeza es tener un Mapa estático en la Nameclase y cuando se llama al constructor lanzando una excepción si el valor pasado nameya está en uso en otro objeto, sin embargo, soy consciente de lanzar excepciones en un constructor es generalmente una mala idea .

¿Hay otras formas de lograr esto?

En realidad ya has respondido tu pregunta. Su primera forma debería ser más efectiva aquí. Usar static factoryes siempre preferible que constructordonde creas que puedes. Por lo tanto, puede evitar el uso Constructoren este caso, de lo contrario lo haría throw some exceptionsi ya existiera una instancia con el nombre dado.

Por lo tanto, puede crear un método de fábrica estático: getInstanceWithName(name)que obtendrá la instancia ya disponible con ese nombre, y si no existe, creará una nueva instancia y la hará constructorprivada, como debería hacerse principalmente cuando se trata de static factories.

Además, para eso necesita mantener una estática Listo Mapde todas las instancias únicas creadas, en su Factoryclase.

EDITAR : -

Sin duda, debe pasar por: Java efectivo: elemento n. ° 1: considere las fábricas estáticas sobre los constructores . No se puede obtener una mejor explicación que ese libro.

Las menciones de Java efectivo parecen agregar mucha credibilidad, por lo que esta respuesta se basa en:

• Artículo 8 de Java efectivo: Obedecer el contrato general cuando se anula igual
• Elemento de Java efectivo 9: anular siempre el hashCode cuando anule iguales
• Artículo eficaz de Java 15: minimizar la mutabilidad

Daría un paso atrás y le preguntaría por qué le importa si hay más de una instancia de este objeto de nombre.

Raramente necesito hacer este tipo de agrupación de objetos. Supongo que el OP está haciendo esto para que simplemente puedan comparar sus Nameobjetos ==. O use los Nameobjetos dentro de a HashMapo similar como la clave.

Si es así, esto es algo que se puede resolver mediante la implementación adecuada deequals() .

Al igual que:

public final class Name {
  private final String name;

  public Name(String name) {
    if (name == null) {
      name = ""; //or exception if you like
    }
    this.name = name;
  }

  public String getName() {
    return name;
  }

  @Override
  public boolean equals(Object o) {
    if (!(o instanceof Name)) {
      return false;
    }
    Name other = (Name) o;
    return other.name.equals(name);
  }

  @Override
  public int hashCode() {
    return name.hashCode();
  }
}

Una vez hecho esto, lo siguiente es cierto:

Name a = new Name("weston");
Name b = new Name("weston");
assert(a.equals(b)); //same but:
assert(a!=b); //not the same instance
//test out the Name instances in a hashmap:
HashMap<Name,Object> map = new HashMap<Name,Object>();
Object detailsIn = new Object();
map.put(a,detailsIn);
Object detailsOut = map.get(b);
assert(detailsIn==detailsOut); //the map returned the same details object
//even though we put with `a` and got with `b` thanks to our correct equals implementation

Supongo que su objetivo, pero de esta manera puede usar la Nameclase en mapas hash, etc., y no tienen que ser exactamente la misma instancia.

• Hacer Nameuna interfaz
• Crea una interfaz NameFactorycon un métodoName getByName(String)
• Crea una implementación NameFactorycon un Map<String,WeakReference<Name>>interior
• synchronizeen el mapa por nombre dentro del getByNamemétodo antes de hacer nuevas instancias deName
• Opcionalmente, use una implementación privada estática de la Nameinterfaz dentro de su implementación delNameFactory

Este enfoque le permitiría asegurarse de que:

• Solo Nameexiste una única instancia de en cualquier momento,
• No hay pérdida de memoria "Lingerer" en su clase, cuando se Namequedan más tiempo del necesario,
• El diseño sigue siendo comprobable con los objetos simulados, ya que utiliza interfaces.

debe hacer que los constructores sean privados y crear métodos como getNameInstance(String), si un objeto con el mismo nombre ya existe (basado en una clase estática 'hastable por ejemplo), devuelve esa referencia, de lo contrario, crea un nuevo objeto usando su constructor privado y lo agrega a la tabla hash

Intenta seguir. Debe realizar un seguimiento de cada objeto que cree. Para este propósito estoy usando List. E hizo que el constructor de clases fuera privado, de modo que la verificación previa se pueda aplicar antes de crear una instancia

class UniqueName
    {
        private string Name;
        public int ID;
        private static int Count=0;
        static List<UniqueName> lt=new List<UniqueName>();

        private UniqueName(string Name)
        {
            this.Name = Name;
            ID = ++Count;
        }

        public static UniqueName GetUniqueueInstance(string Name)
        {
            foreach (UniqueName un in lt)
            {
                if ( string.Compare( un.Name,Name,StringComparison.InvariantCultureIgnoreCase)==0)
                    return un;
            }

            UniqueName temp=new UniqueName(Name);
            lt.Add(temp);
            return temp;
        }
    }