Maneiras de garantir instâncias exclusivas de uma classe?

Estou procurando maneiras diferentes de garantir que cada instância de uma determinada classe seja uma instância identificável exclusivamente.

Por exemplo, eu tenho uma Nameclasse com o campo name. Depois de ter um Nameobjeto nameinicializado para John Smith, não quero instanciar um objeto diferente.Name objeto também com o nome John Smith, ou, se ocorrer instanciação, desejo que uma referência ao objeto original seja passada de volta. do que um novo objeto.

Estou ciente de que uma maneira de fazer isso é ter uma fábrica estática que contenha Maptodos os objetos Name atuais e a fábrica verifique se um objeto com John Smith como o nome ainda não existe antes de retornar uma referência a umName objeto.

Outra maneira que eu poderia pensar é ter um mapa estático na Nameclasse e quando o construtor é chamado lançando uma exceção se o valor passado namejá estiver em uso em outro objeto, no entanto, estou ciente lançar exceções em um construtor é geralmente uma má ideia .

Existem outras maneiras de conseguir isso?

Na verdade você já respondeu sua pergunta. Seu primeiro caminho deve ser mais eficaz aqui. Usar static factoryé sempre preferível do que constructoronde você acha que pode. Portanto, você pode evitar o uso Constructorneste caso, caso contrário, você teriathrow some exception se uma instância já existir com o nome fornecido.

Portanto, você pode criar um método estático de fábrica: - getInstanceWithName(name)que obterá a instância já disponível com esse nome e, se não existir, criará uma nova instância e tornará sua constructorprivada, como geralmente deve ser feito ao lidar com static factories.

Além disso, para isso, é necessário manter uma estática Listou Maptodas as instâncias exclusivas criadas, em sua Factoryclasse.

EDIT : -

Você certamente deve passar por - Java Efetivo - Item # 1: Considere fábricas estáticas em vez de construtores . Você não pode obter uma explicação melhor do que esse livro.

As menções ao Java efetivo parecem agregar muita credibilidade, portanto, esta resposta se baseia:

• Item efetivo de Java 8: Obedeça ao contrato geral ao substituir igual
• Item efetivo do Java 9: ​​sempre substitua o hashCode ao substituir igual
• Item 15 efetivo do Java: minimizar a mutabilidade

Eu daria um passo para trás e perguntaria por que você se importa se houver mais de uma instância desse objeto de nome.

Eu raramente preciso fazer esse tipo de pool de objetos. Acho que o OP está fazendo isso para que eles possam simplesmente comparar seus Nameobjetos ==. Ou use os Nameobjetos dentro de um HashMapou similar como a chave.

Se assim for, isso é algo que pode ser resolvido através da implementação adequada deequals() .

Igual a:

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();
  }
}

Feito isso, o seguinte é verdadeiro:

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

Estou adivinhando o seu objetivo, mas dessa forma você pode usar a Nameclasse em mapas de hash, etc., e eles não precisam ser exatamente a mesma instância.

• Faça Nameuma interface
• Crie uma interface NameFactorycom um métodoName getByName(String)
• Crie uma implementação de NameFactory com um Map<String,WeakReference<Name>>dentro dele
• synchronize no mapa pelo nome dentro do getByName método antes de criar novas instâncias deName
• Opcionalmente, use uma implementação privada estática da Nameinterface dentro de sua implementação doNameFactory

Essa abordagem permitiria garantir que:

• Somente uma única instância Nameexiste a qualquer momento,
• Não há vazamento de memória "Lingerer" em sua classe, quando ele Namefica mais tempo do que o necessário,
• O design permanece testável com objetos simulados, porque você usa interfaces.

você deve tornar os construtores privados e criar métodos como getNameInstance(String), se já existir um objeto com o mesmo nome (com base em uma classe estática 'hastable por exemplo), você retornar essa referência, caso contrário, criar um novo objeto usando seu construtor privado e adicioná-lo para a hashtable

Tente seguir. Você precisa acompanhar cada objeto que criar. Para esse fim, estou usando a Lista. E tornou o construtor de classe privado, para que a pré-verificação possa ser aplicada antes de criar uma instância

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;
        }
    }