Loading ...
Sorry, an error occurred while loading the content.

RE: [st-br] Questão de visibilidade

Expand Messages
  • Sebastian Sastre
    pergunta: Suponho que eu fiz um acoplamento . estou Certo? Sempre que quero que dois objetos se conheçam preciso fazer isso, passar o objeto como
    Message 1 of 5 , Feb 25, 2008
    View Source
    • 0 Attachment
      "pergunta: Suponho que eu fiz um "acoplamento". estou Certo? Sempre que quero
      que dois objetos se "conheçam" preciso fazer isso, passar o objeto como
      parâmetro em uma mensagem para outro objeto e este, por sua vez, deve salvar uma
      referência dentro dele em algum lugar. é Isso?"

      Sim, um acoplamento e feito sempre que um objeto está composto com
      outro. O dicionario fica como mero intermediario ou veiculo de soporte do
      conhecimento entre umEspaco e o quadrado aquele.

      O assunto é que voce justamente nao queria acoplar. Se for por acoplay
      voce pode colocar diretamente o objeto numa variavel de instancia (aka instVar)
      ou como voce fez dentro de alguma collection que fica numa instVar.

      O que voce parece estar querendo fazer com o negocio de enviar mensagems
      diferentes de acordo com a especie que se recebe tem uma forma de resolver que
      se chama double dispatch. Warning: Ela vai te ajudar so se voce nao se importa
      em acoplar o codigo entre o que se recebe e o receitor.

      Exemplo: se requer que umEspaco reaja adicionando em forma separada de
      acordo à espécie de objeto que ele recebe no mensagem #add:

      Atores:

      umEspaco
      umQuadrado
      umTriangulo
      umCirculo

      Espaco>>add: umQuadrado
      ^ umQuadrado adicionarEm: self

      Quadrado>>adicionarEm: umEspaco
      ^ umEspaco adicionarQuadrado: self

      Triangulo>>adicionarEm: umEspaco
      ^ umEspaco adicionarTriangulo: self

      Circulo>>adicionarEm: umEspaco
      ^ umEspaco adicionarCirculo: self

      Claro que agora Espaco precisa entender essas mensagems e atuar de
      acordo ao requerimento. Observa que o resultado foi enriquecer semanticamente
      Espaco para que ele "saiba" atuar em cada caso que já vem discernido so pelo
      fato de que cada especie fala para ele como fazer.

      Eu antes usaba mais o double dispatch agora para mim nao é muito comum.
      De qualquer forma ajuda a pensar e as veces é suficiente. Outras por exemplo
      nao: que tal fazer que Espaco seja configuravel na forma de reagir? Ai ja nao
      serve porque voce vai precisar fatorizar tudo isso em algum objeto que defina a
      politica de reacao (desacoplar o comportamento de reacao tanto do espaco como
      dos objetos geometricos). Ai a configuracao vai ser colocar diferentes de essas
      "PoliticaDeReacaoDeEspaco" (que cada uma tem suas particularidades) e pronto.
      Alguns exemplos de politicas (arbitrariamente criativos) que seriam subclasses
      de PoliticaDeReacaoDeEspaco seriam: AdicionarOsPrimeirosDez,
      AdicionarSeAreaSerMaiorAValorPreconfigurado, AdicionarIncondicionalmente (esta
      estaria fazendo o mesmo que o double dispatch), etc.

      Agora, com respeito aos eventos, eles vao te ajudar so em um caso:
      quando voce quer manter aoplamento "solto" ou "leve" com parents.

      Na arbore (grafo) de composicao de um objeto os "childs" (as partes)
      normalmente é bom que não conhecam os "parents" (os objetos que contem essas
      partes). Se voce precisa que o parent monitore algo que acontece no child entao
      o evento vai te ajudar sim. Announcements é so um melhor framework de eventos.

      Para ilustrar o que falei, considere um veiculo que tenha um sensor de
      pressao de pneu. O veiculo é um objeto composto por pneus e o contrario e falso.
      Agora o sensor detecta baixa pressao e notifica do "evento" #baixaPressao. Ele
      nao fala a o carro o que ele tem que fazer. Ele so relincha se queixando. Ele
      nem sabe que é parte de um carro (ele pode estar numa bicicleta ou guardado no
      portamalas que tem que ter os pneus com boa pressao). Mas, o sistema do carro,
      sim que quer saber quando os pneus, que sao importantes para ele, perderom
      pressao porque ele pode atuar em consequencia afetando o carro todo (por exemplo
      limitando velocidade maxima a 40 km/h se nao for o de portamals e ligar uma luz
      no dashboard se for o da portamala).

      Cada caso deve ser avaliado para saber que aplica antes de implementar.
      Bom.. sempre pode usar o ambiente smalltalk para experimentar inocentemente o
      semidesconhecido. Tipo laboratorio. Total se nao dar certo sempre vai poder
      refatorizar ;)

      Go to discover the world!

      Sebastian




      ________________________________

      De: st-br@yahoogroups.com [mailto:st-br@yahoogroups.com] En nombre de
      Marco Franci
      Enviado el: Lunes, 25 de Febrero de 2008 16:06
      Para: st-br@yahoogroups.com
      Asunto: RE: [st-br] Questão de visibilidade



      quadrado1 setIn: quadrado2 color: Color blue

      Se interpretei bem, no exemplo umEspaço envia uma mensagem para
      quadrado1 enviar uma mensagem para quadrado2 trocar sua cor. Para isso
      "quadrado2" é passado como parâmetro.

      Seria algo como:
      João, entregue essa laranja para ele (ele é Pedro).

      Estou tentando fazer algo como:
      Se João receber uma laranja ele entrega para Pedro, se receber uma flor,
      entrega para Maria.

      (talvez o que eu queira fazer são eventos)

      No caso dos quadrados, resolvi o problema do seguinte modo: eu criei um
      método "Quadrado1>>conheca: aQuadrado" em que salvo o objeto que passo em uma
      variável dicionário "conhecidos" do quadrado1. Depois criei um método:

      Quadrado1>>recebaACor: aColor
      (conhecidos at:#quadrado2) color: aColor.

      Então no momento que quadrado1 recebe uma cor ele a envia para quadrado
      2 pedindo para ele trocar sua cor.

      pergunta: Suponho que eu fiz um "acoplamento". estou Certo? Sempre que
      quero que dois objetos se "conheçam" preciso fazer isso, passar o objeto como
      parâmetro em uma mensagem para outro objeto e este, por sua vez, deve salvar uma
      referência dentro dele em algum lugar. é Isso?

      Gostaria sim, Sebastian, de mais detalhes de como fazer através de
      eventos e announcements. Está me ajudando muito.

      grato
      Marco


      Sebastian Sastre <ssastre@...> escreveu:

      Olá Marco,

      pois veja voce pode ensinar aos seus objetos a fazer a açao que
      voce
      deseja de forma "nao acoplada" simplesmente adicionando a
      mensagem que faz a
      acao lá na clase Quadrado. No seu exemplo:

      Quadrado>>setIn: aQuadrado color: aColor
      "Sets aColor as the morph color of aQuadrado."
      ^ aQuadrado color: aColor

      Isto geralmente voce usa justamente quando o desacoplamento
      entre esses
      objetos é desejado sem deixar de poder interatuar entre eles.

      Claro que ai voce tem que ter resolvido por un terceiro que
      conheca os
      dois o problema de realmente chamar essa mensagem. Vamos supor
      que o objeto
      umEspaco conhece quadrados. Entao ele pode fazer:

      quadrado1 setIn: quadrado2 color: Color blue

      abraço,

      Sebastian Sastre
      PD: observa que uma vez comprendido tecnicamente, o interesante
      é questionar se
      é correto que um objeto possa afetar o outro dessa manera. No
      exemplo nao faz
      muita diferenca porque é algo meramente didatico, mas se voce
      ter que fazer um
      modelo de como funciona um negocio ou qualquer coisa da vida
      real, entao vai ser
      bem importante ter um bom modelo conceitual e administrar bem as
      responsabilidades entre eles.

      ________________________________

      De: st-br@yahoogroups.com <mailto:st-br%40yahoogroups.com>
      [mailto:st-br@yahoogroups.com <mailto:st-br%40yahoogroups.com> ] En nombre de
      Marco Franci
      Enviado el: Domingo, 24 de Febrero de 2008 22:28
      Para: st-br@yahoogroups.com <mailto:st-br%40yahoogroups.com>
      Asunto: [st-br] Questão de visibilidade



      Olá,
      uma dúvida de iniciante:

      Se eu tenho duas classes:

      Morph subclass: #Quadrado1
      instanceVariableNames: ''
      classVariableNames: ''
      poolDictionaries: ''
      category: 'Quadrados'

      Morph subclass: #Quadrado2
      instanceVariableNames: ''
      classVariableNames: ''
      poolDictionaries: ''
      category: 'Quadrados'

      posso alterar as cores dos objetos dessa forma:
      |quadrado1 quadrado2|
      quadrado2:= Quadrado2 new openInWorld.
      quadrado1:= Quadrado1 new openInWorld.
      quadrado1 color: Color blue.
      quadrado2 color: Color orange.

      Eu instancio os dois objetos e depois envio mensagens para que
      eles
      alterem suas cores.

      pergunta:

      Como faço se quiser que o objeto "quadrado1" envie uma mensagem
      para
      "quadrado2" para que ele altere sua cor se "quadrado1" não
      enxerga "quadrado2"?
      Eu não quero instanciar quadrado2 dentro de quadrado1. E também
      não
      quero que um terceiro objeto é que na verdade envie mensagens
      para "quadrado1" e
      "quadrado2".
      Resumindo: quero que "quadrado1" envie uma mensagem diretamente
      para
      "quadrado2" mas o primeiro não "enxerga" o segundo.
      Eu só posso enviar mensagens para objetos do local onde eles
      foram
      instanciados? Se não como faço?

      Obrigado




      ________________________________

      Abra sua conta no Yahoo! Mail

      <http://br.rd.yahoo.com/mail/taglines/mail/*http://br.mail.yahoo.com/
      <http://br.rd.yahoo.com/mail/taglines/mail/*http://br.mail.yahoo.com/> > , o
      único
      sem limite de espaço para armazenamento!






      ________________________________

      Abra sua conta no Yahoo! Mail
      <http://br.rd.yahoo.com/mail/taglines/mail/*http://br.mail.yahoo.com/> , o único
      sem limite de espaço para armazenamento!
    Your message has been successfully submitted and would be delivered to recipients shortly.