MAC 441/5714 - Programação Orientada a Objetos

Aula 10 - 10/04/2008

More Smalltalk Goodies - assuntos Smalltalkísticos variados

Classes abstratas

• Conceitualmente, é uma classe que não implementa um ou mais de seus métodos e portanto não podem ser instanciadas
  
• São muito úteis para capturar comportamento comum a várias subclasses
• Podem também ser úteis para especificar um supertipo de onde vários tipos são derivados

• Em Smalltalk, não existe o conceito explícito/formal de classe abstrata mas o conceito pode ser implementado utilizando-se duas características da linguagem:
1. uma classe pode implementar o método new de forma a gerar uma exceção indicando que a classe não é instanciável
2. pode-se determinar que a implementação de um método é de responsabilidade de suas subclasses utilizando-se a mensagem subclassResponsibility
• métodos abstratos são simulados com a implementação ^self subclassResponsibility
  
• os métodos concretos nas subclasses devem se sobrepor ao método abstrato.
• se um "método abstrato" é chamado, executa-se o método Object>>subclassResponsibility que gera uma exceção com o texto My subclass should have overriden one of my messages :-)

• Um exemplo interessante é a classe Magnitude onde o método < é abstrato e todas as demais comparações são definidas em função de <
•  Assim, as subclasses de Magnitude podem simplesmente definir < que automaticamente, todas as outras operações serão definidas por tabela.
  

Namespaces vs. Categories vs. Packages

• Namespaces são uma forma de organizar os nomes das classes e variáveis em um ambiente; evitam conflitos por repetição de nomes.
• Categories são apenas uma forma dos desenvolvedores agruparem suas classes para fins de organização do código, as categorias em geral indicam qual o "tipo conceitual" de classe com a qual estamos lidando (não é usado pelo Smalltalk em si).
•  Packages são uma forma de organizar as classes para distribuição na Internet, para armazenamento em disco, etc.
• Um pacote pode conter classes de vários namespaces e de várias categorias.
  

Usos de caracteres especiais para criação de Objetos de tipos específicos

• Criação de intâncias de Point pode ser feita com o operador @ da classe número:
• 3@5
• 3.23@-10.5
• Criação de instâncias de Association pode ser feita com o operador -> de Object
• 'casa' -> 'maison'
• 'ADD' -> 2r00001101
• associações são normalmente usadas em dicionários:
• Dictionary new add: 'SP' -> 'São Paulo'; add: 'RJ' -> 'Rio de Janeiro'; add: 'PR' -> 'Paraná'.

Depuração

• O depurador de Smalltalk é muito sofisticado; é uma ferramenta tão poderosa que alguns programadores experientes preferem desenvolver seu código dentro dele!
• Podemos usar a opção Debug it para executar um trecho de código dentro do depurador
• ou então utilizar o método halt no ponto onde desejamos parar. Para isso, basta incluir o comando self halt. no ponto onde se deseja parar e daí executar o trecho com Do it:

printString

• O método printString é a forma padrão de converter um objeto qualquer para um String.
• É equivalente ao toString() de Java.
• Se você quiser que os seus objetos sejam capazes de se imprimir através do printString, então o que você deve fazer é implementar o método printOn: aStream que é chamado pelo printString de Object.
  

Igualdade (==) vs. Equivalência (=)

• Dois objetos são equivalentes (=) se possuem o mesmo conteúdo (como o equals() de Java)
• Duas referências são iguais (==) se apontam para o mesmo objeto (como o == de Java)
• o contrário de =  é ~=
• o contrário de == é ~~
• Exemplo:
• p1 := (Point x: 10 y: 20)
  p2 := (Point x: 10 y: 20)
  Transcript clear; show: (p1 =  p2) printString. "true"
  Transcript cr;    show: (p1 == p2) printString  "false"

Ponteiros (apontadores) vs. Referências

• Uma referência é uma variável que guarda o endereço de memória onde um objeto reside.
• O que podemos fazer com uma referência:
1. elas podem ser derreferenciadas para se contactar o objeto referenciado por elas
2. podemos atribuir a ela um novo valor no momento da criação de um novo objeto ou fazendo com que uma referência seja associada ao mesmo objeto de outra referência.
• em linguagens com checagem estática de tipos como Java, o compilador verifica no momento da atribuição, se não está ocorrendo uma violação de tipos.
3. podemos comparar referências para saber se elas apontam para o mesmo objeto.

• Apontadores são ligeiramente diferentes, além de ser possível fazer as mesmas operações com referências descritas acima, é também possível fazer:
1. aritmética de ponteiros, ou seja, fazer algo como p = p + 10 para fazer com que p aponte para 10 posições após a posição atual.
2. atribuir valores diretamente a ponteiros, por exemplo, p = 3725, o que é claramente muito inseguro. Linguagens como C/C++ permitem isso.

• Java e Smalltalk possuem apenas referências, o que torna o código mais seguro (safe)
• C++ possui tanto ponteiros (*) quanto referências (&)
  

Exceções

• Um mecanismo existente em linguagens OO para tratar de casos excepcionais de forma elegante.
• Ao contrário de C que nos força a testar possíveis códigos de erro a cada chamada de função, as exceções nos permitem escrever todo o código supondo que nada deu errado e tratar os casos de erro separadamente.
• Não use exceções para identificar casos que não representam um erro (p.ex., uma consulta a um banco de dados não deveria gerar uma exceção caso o elemento não está no banco, ela deveria simplesmente informar isso; já um erro de acesso ao banco ou um erro de leitura no disco, deveria sim gerar uma exceção).
• em Smalltalk:
• toda exceção é uma subclasse de Exception
• o VW já vem com 183 subclasses pré-definidas (e o Squeak com 132) indicando qual o tipo de erro que ocorreu;
  
• experimente imprimir o resultado da execução de Exception allSubclasses
• objetos deste tipo possuem vários atributos como
  
• messageText (que descreve o erro)
• isResumable (dizendo se o programa pode ser continuado ou não)
• vários contextos (pilhas de execução) relacionados à exceção:
  
• signalContext
• handlerContext
• outerContext
  
• etc.
• os subtipos principais de Exception são Error e Notification.
• Error por padrão, abre aquela famosa janela de exceções
• Warning (no VW) por padrão abre uma janela de diálogo com opções yes/no e devolve um booleano indicando a resposta
• Notification (no VW) simplesmente abre uma janela com botão de OK.
• O Squeak possui um booleno indicando se o código está sendo executado em ambiente de desenvolvimento ou em ambiente de produção; em desenvolvimento, as exceções abrem uma janela, em produção, um texto é escrito num arquivo de log.
  
• o comando #(1 2 3) at:4 por exemplo, gera um Error
• Para gerar uma exceção enviamos uma das seguintes mensagens a uma subclasse de Exception
  
• signal
• signal: aString
• ZeroDivide signal: 'Enganei um bobo, na casca do ovo'
  
• Para capturar exceções, precisamos colocar o trecho de código que pode gerar a exceção dentro de um bloco e enviar ao bloco uma das seguintes mensagens:
• on: classeDaExceção do: tratamentoDaExceção
• Exemplo:
• [10 / x]
     on: ZeroDivide
     do: [:exception | Transcript show: 'Tentativa de divisão por zero']
• note que o objeto exceção gerado é passado como parâmetro ao bloco tratador da exceção
• o parâmetro passado ao seletor on: pode conter uma lista de exceções separados por vírgulas (ExceptionSet)
• Bloco ifError: BlocoDeTratamento
  
• Exemplo:
• [#(1 2 3) at: 4] ifError: [Transcript show: 'Deu erro!'. nil]
  
  
• Quando um bloco é executado, cada chamada de mensagem empilha um objeto MethodContext com informações sobre a mensagem enviada, seu emissor e seu receptor (de forma similar à pilha mostrada no depurador). Se algum método gera uma exceção, a máquina virtual passa a procurar na pilha de contextos por algum tratador para aquele tipo de exceção (ou supertipo); quando o primeiro tratador compatível é encontrado, ele é executado e a excecução continua a partir daquele ponto sendo que todo o resto da parte superior da pilha de execução é descartado.
  

Referências

• Ivan Tomek. Introduction to VisualWorks Smalltalk. Documento disponível no VW na janela Welcome na aba Introduction. 2003.
  
• Abdala & Wangenheim. Conhecendo o Smalltalk. Capítulo 11: Captura e Tratamento de Exceções. Visual Books, 2002.