O que é a maneira correta de design / implementar dois (ou mais) classes que têm “tem um” relacionamento com o mesmo objeto?

Question

Suponha que eu tenho um projeto como este:

GUI objeto tem dois objetos:. Objeto aManager e objeto bManager, que não nunca conversam entre si

Ambos aManager e bManager ter objecto cManager como um atributo (ou melhor, um ponteiro para cManager). Então, quando aManager modifica seu cManager, está afetando cManager de bManager também.

A minha pergunta é qual é a maneira correta de design / implementar isso?

Eu estava pensando em fazer cManager como um atributo do GUI, e GUI passa um ponteiro para cManager ao construir aManager e bManager. Mas IMHO, GUI não tem nada a ver com cManager, então por que GUI tê-lo como um atributo?

Existe um padrão de design específico que eu deveria estar usando aqui?

Answer 1

Vou interpretar isso como simplesmente quanto possível, se eu não estou respondendo a sua pergunta, eu peço desculpas.

Quando você realmente obter a resposta a esta pergunta, é o primeiro passo para realmente pensando Objeto Orientedly.

Em OO, quando dois objetos tanto "tem um" 'nother objeto, ele é perfeitamente aceitável para ambos para se referir a esse outro objeto. O truque com OO é que os objetos têm uma vida própria, eles são fluidos e qualquer um que precisa deles pode manter uma referência para eles. O objeto deve manter-se "válido" e manter a estabilidade quando está sendo usado por muitos outros objetos. (É por isso que objetos imutáveis ??como cordas são tão grandes, eles estão sempre tão válido como o segundo que foram criados)

A única exceção é se você está programando em C ++, porque então você realmente tem que objetos manualmente livres, que implica um proprietário que pode monitorar o ciclo de vida de cada objeto - que o torna realmente muito difícil "pensar" em OO em C ++.

[adição] Desde que você está se referindo a ponteiros, eu estou pensando que você está programando em C ++ que é diferente. Nesse caso, você está certo. Faça um gerente "Own" o ciclo de vida do seu objeto compartilhado. Ele não deve deixar esse objeto morrer até que todas as outras referências desapareceram.

Você também pode usar contagem de referência. Sempre que alguém obtém uma referência ao seu objeto, ele chama de "AddReference" ou algo assim, sempre que ele fez isso remove a referência. Se alguém chama removeReference quando a contagem for 1, o objeto pode limpar-se para cima. Isso é provavelmente o mais próximo que você pode vir a alocação verdadeiro estilo OO / liberando em C ++. É muito embora propensa a erros.

Existem bibliotecas para fazer este tipo de coisas que eu acredito.

Answer 2

Eu recomendo apenas passando em cManager como um parâmetro em seu construtor objeto GUI, mas não manter uma referência a ele (código Java aqui, mas você começa a idéia):

public GUI(CManager cManager)
{
    this.aManager = new AManager(cManager);
    this.bManager = new BManager(cManager);
    // don't bother keeping cManager as a field
}

Eu não acho que qualquer um Singleton ou Factory é apropriada aqui.

Answer 3

Use singletons com cuidado (ou não em todos, se você quiser testes fáceis!)

• Singletons são Patológica Mentirosos
• onde foram todos os Singletons Longe
• causa raiz de Singletons

Answer 4

Você pode usar o padrão de fábrica para solicitar uma referência a cManager por ambos aManager e bManager conforme necessário.

http://msdn.microsoft.com/en-us/library /ms954600.aspx

Answer 5

Você deve olhar para separar o seu GUI do seu modelo e implementação.

Você poderia fazer cManager um singleton se não só é, nunca quis ser um cManager nunca, em toda a aplicação.

Answer 6

Isto é complicado de responder sem uma discussão sobre o que você deseja alcançar. Mas, eu diria, vai com a obtenção de GUI para entregar o ponteiro para aManager e bManager como você diz.

Se você está tentando criar uma GUI e querendo saber como obter dados dentro e fora dela, então eu posso recomendar este: http://codebetter.com/blogs/jeremy.miller/archive/2007/07/25/the-build-your-own-cab-series-table-of-contents.aspx

Eu acho que é escrito principalmente para usuários C #, mas se aplica a outras línguas. Eu estou supondo que isso pode ser mais avançado do que você precisa para sua primeira aplicação OO embora. Eu acho que você vai ter para obter-se um livro sobre projeto OO e passar algumas noites com ele.

Como um noob, eu recomendo que você não perca tempo tentando fazer tudo o mais perfeito maneira correta primeira vez, mas é só pegar algo para trabalhar. Você vai aprender com o tempo (e lendo muito) o que torna uma solução melhor do que outros para diferentes critérios. Não há resposta certa para a pergunta.

Answer 7

Em geral, a qualquer momento no tempo, qualquer objeto mutável deve ter exatamente um proprietário claramente definida (um objeto normalmente têm vários proprietários ao longo de sua vida, com o primeiro deles sendo o construtor, que então mãos a propriedade para o código que chamou, etc.) Qualquer outra coisa que contém uma referência para o objeto deve considerar que a referência como sendo uma referência a um objeto pertencente a outra pessoa.

Pode-se pensar, quando se passa de C ++ para Java ou .net, "Hey cool - Eu não precisa se preocupar com a propriedade objeto mais", mas isso não é verdade. A propriedade dos objetos mutáveis ??é tão relevante em um sistema baseado na GC como em um sistema não-GC. A falta de qualquer meio de expressando propriedade não isenta o programador da obrigação de saber quem possui o quê. Limitou-se a torna mais difícil de cumprir essa obrigação.

Se um cManager é mutável, então ou aManager deve possuir um e bManager manter uma referência a ele, e acho que de qualquer alteração ao seu alvo como afetando cManager de aManager, ou bManager deve possuir um (com aManager mantendo uma referência, etc. ), ou alguma outra entidade deve possuir um, com aManager e bManager tanto o pensamento de suas mudanças como afetando propriedade de outra entidade.

Ainda que se utiliza uma linguagem ou estrutura que não reconhece qualquer conceito de propriedade, sempre penso nesses termos quando se lida com objetos mutáveis. Para fazer o contrário é convidar confusão e desastre.