Modelagem de Software Orientado a Objetos utilizando a Linguagem UML

Apresentação em tema: "Modelagem de Software Orientado a Objetos utilizando a Linguagem UML"— Transcrição da apresentação:

1 Modelagem de Software Orientado a Objetos utilizando a Linguagem UML
Alcides Calsavara

2 Calendário Carga horária: 25 horas
Dias: 5/11, 12/11, 26/11, 3/12 e 10/12 Horário: das 12:40 às 18:00 Intervalos: das 14:20 às 14:30 e das 16:10 às 16:20 Divisão: 3 blocos de 100 minutos cada - das 12:40 às 14:20 - das 14:30 às 16:10 - das 16:20 às 18:00

3 Local Laboratório de treinamento da Allen-Productique:
Microsoft PowerPoint ferramenta CASE com suporte à linguagem UML ferramenta de compilação e execução de programas escritos na linguagem Java

4 Objetivo Habilitação no uso da linguagem UML na modelagem de software orientado a objetos

5 Método Apresentação da teoria
Apresentação de exemplos e solução de exercícios utilizando as ferramentas disponíveis CASE e de programação Aplicação da teoria na resolução de estudos de casos propostos pela Allen-Productique, do segundo ao último dia do curso, em paralelo à apresentação da teoria

6 Conteúdo Programático
05/11: princípios de O-O 12/11: método, casos de uso, classes 26/11: relacionamentos, restrições, interfaces, tipos parametrizados, estereótipos, pacotes 03/12: estados e eventos 10/12: seqüência, colaboração, atividades, componentes, implantação

7 Bibliografia Básica UML Toolkit UML in a Nutshell
Object-Oriented Software Construction Modelagem de Objetos através da UML Design Patterns: Elements of Reusable Object-Oriented Software Modelagem e Projeto baseados em Objetos

8 Princípios de Orientação a Objetos
(dia 1)

9 Sumário Tipos de dados abstratos Classes e instâncias
Operações e atributos Construção de objetos Referências para objetos Pacotes de classes Encapsulamento Modos de visibilidade/acesso

10 Sumário Asserções e invariantes de classe Tratamento de exceções
Objetos compostos Herança, sobrecarga, polimorfismo Herança múltipla Interfaces Tipos parametrizados

11 Tipos de Dados Abstratos (ADT)
Um ADT é um modelo matemático para descrição de um tipo independente de sua representação física. Um tipo é uma coleção de objetos caracterizados através de funções, axiomas e pré-condições. Um objeto que pertence ao conjunto de objetos descritos por um ADT é dito ser uma instância do ADT.

12 Exemplo de ADT Pilha (Stack)
Opções de representação: array listas ... Questão básica: Como definir formalmente uma pilha de forma independente de sua representação?

13 Exemplo de ADT Primeira Parte: Tipos
Especificação ADT para pilhas TYPES STACK [G]

14 Exemplo de ADT Segunda Parte: Funções
FUNCTIONS put: STACK[G] X G --> STACK[G] remove: STACK[G] -/-> STACK[G] item: STACK[G] -/-> G empty: STACK[G] --> BOOLEAN new: STACK[G]

15 Exemplo de ADT Terceira Parte: Axiomas
AXIOMS Para todo x : G, s : STACK[G] A1 - item ( put ( s, x ) ) = x A2 - remove ( put ( s, x ) ) = s A3 - empty ( new ) A4 - not empty ( put ( s, x ) )

16 Exemplo de ADT Quarta Parte: Pré-condições
PRECONDITIONS remove ( s : STACK[G] ) require not empty(s) item ( s : STACK[G] ) require not empty(s)

17 Modularização Construção de software orientado a objetos é a construção de um sistema de software como uma coleção de implementações de ADTs possivelmente parciais. Um ADT corresponde a um módulo de um sistema de software.

18 Classe Uma classe é um tipo abstrato de dados equipado com uma implementação possivelmente parcial. A definição de uma classe inclui uma lista de atributos e uma lista de operações. Um sistema de software orientado a objetos é definido por um conjunto de classes.

19 Instância Todo objeto é instância de alguma classe.
A execução de um sistema de software orientado a objetos corresponde a interações entre objetos através de mensagens (chamadas de operações). Toda execução é iniciada em um objeto raiz, com a chamada de uma de suas operações.

20 Classe X Objeto Um classe é um elemento de construção de software. Portanto, é um elemento definido e criado estaticamente. Um objeto é um elemento de run-time, isto é, só existe em tempo de execução de um sistema de software. Portanto, é criado dinamicamente.

21 Atributo A definição de uma classe inclui uma lista de atributos.
Toda instância de uma classe contém todos os atributos definidos pela classe. Cada atributo tem um nome, um tipo e, opcionalmente, um valor default. O conjunto de valores dos atributos de um objeto define o seu estado.

22 Atributo Tipos de atributos:
de instância: há um valor específico para cada instância de classe: há um único valor (compartilhado) para todas as instâncias O valor de um atributo pode ser uma constante.

23 Operação A definição de uma classe inclui uma lista de operações que correspondem à interface da classe. Uma operação é uma função ou transformação que pode ser aplicada a todo e qualquer objeto de uma classe. Uma operação tem um nome, uma lista de argumentos, um tipo de retorno e uma implementação (um método).

24 Operação Em um sistema de software, existe apenas uma única ocorrência de cada operação de uma classe, independentemente do número de instâncias da classe. Operações são definidas e criadas estaticamente.

25 Construção de Objetos Toda classe define um ou mais operações específicas para a criação (iniciação) de novos objetos, normalmente denominadas construtores da classe. Toda vez que um novo objeto é criado, um construtor da correspondente classe deve ser selecionado para execução.

26 Referência para Objeto
Uma referência é um valor de run-time que pode ser void ou attached. Quando o valor de uma referência for attached, a referência identifica um único objeto. (A referência está fixada em um certo objeto.) Podem existir várias referências para um mesmo objeto. Copiar uma referência é diferente de copiar um objeto.

27 Pacote de Classes Classes podem ser logicamente organizadas em grupos denominados pacotes. Pacotes são estrurados de forma hierárquica. Há pacotes disponibilizados em bibliotecas. Usuários podem criar seus próprios pacotes.

28 Encapsulamento Processo de ocultamento de partes internas da implementação de um objeto e permissão de acesso ao estado do objeto somente através de uma interface bem definida. Os atributos de um objeto são manipulados (para leitura e escrita) somente por operações definidas para o objeto.

29 Modos de Visibilidade/Acesso
Pode-se controlar a manipulação de atributos e operações (membros, de forma geral) considerando-se os escopos de classe, subclasse e pacote, de forma combinada. Modificadores: private protected package public

30 Modificador private Um membro qualificado como private somente é acessível a partir de métodos da própria classe à qual pertence o membro.

31 Modificador public Um membro qualificado como public é acessível a partir de qualquer operação de qualquer classe, independentemente de subclasse e de pacote.

32 Modificadores public e private - Exemplo 1
class Pessoa { private int idade; private int altura; public Pessoa(int i, int a) { idade = i; altura = a; } private void cresce( ) { idade++; altura++; } private void decresce( ) { idade++; altura--; } public void envelhece( ) { if (idade < 22) cresce( ) else decresce( ); } }

33 Modificadores public e private - Exemplo 2
class Funcionario extends Pessoa { private int nivel; private int horas; public Funcionario(int i, int a, int n, int h) { super(i, a); nivel = n; horas = h; } public double salario( ) { return ( nivel * 80 * horas) ; } }

34 Modificador package Um membro qualificado como package é acessível a partir de qualquer operação de qualquer classe pertencente ao mesmo pacote que a classe à qual pertence o membro, independentemente de subclasse.

35 Modificador protected
Um membro qualificado como protected é acessível a partir de qualquer operação de qualquer classe, exceto se a classe de acesso estiver em pacote distinto e não for subclasse da classe à qual pertence o membro.

36 Modificadores package e protected Exemplo 1
class Veiculo { int ano; // package protected int potencia; ... } class Carro extends Veiculo { ... potencia++; ano++; } class Retificadora { ... Carro c = new Carro (...) ; c.ano = 1980; c.potencia = 100; ... }

37 Modificadores package e protected Exemplo 2
package Basico; // arquivo 1 class Veiculo { int ano; // package protected int potencia; ... } package Extensao; // arquivo 2 class Carro extends Veiculo { ... potencia++; ... } // sem acesso a ano class Retificadora { ... Carro c = new Carro (...) ; ... } // sem acesso a ano e potencia

38 Asserções P {A} Q A execução de A, iniciando em um estado no qual P é verdadeira, terminará em um estado no qual Q é verdadeira. P : pré-condição Q : pós-condição A : uma operação (ou parte de)

39 Asserções - Exemplos {x >= 9} x := x + 5 {x >= 13}
{x >= 0} y := sqrt(x) { true } {false} y := x * x { y >= 0 } {not full} put(x : G) { not empty AND item = x AND count = old count + 1 }

40 Invariante de Classe Uma invariante é uma propriedade inalterável durante todo o ciclo de vida de um objeto. Exemplos: 0 <= count count <= capacity empty = (count = 0)

41 Tratamento de Exceção Exceções são acontencimentos fora do comportamento normal ou desejado para um programa. O gerenciamento de exeções permite o controle sobre erros e possivelmente uma solução de contorno. Exemplos: entrada em formato inválido, arquivo corrompido, conexão de rede não disponível, índice inválido para vetor, ...

42 Exemplo de código frágil
class TestNullP { static String s = null; public static void main(String args[ ]) { char c1 = s.charAt(2); // java.lang.NullPointerException (programa pára) s = new String("Curitiba"); char c2 = s.charAt(2); // c2 = 'r' char c3 = s.charAt(8); // java.lang.StringIndexOutOfBoundsException (programa pára) } } // fim

43 Exemplo de código frágil
class TestNullP { static String s = null; public static void main(String args[ ]) { char c1 = s.charAt(2); // java.lang.NullPointerException (programa pára) s = new String("Curitiba"); char c2 = s.charAt(2); // c2 = 'r' char c3 = s.charAt(8); // java.lang.StringIndexOutOfBoundsException (programa pára) } } // fim

44 Exemplo modificado com ifs
class TestNullP { static String s = null; public static void main(String args[ ]) { if (s != null && s.length( ) > 2) char c1 = s.charAt(2); s = new String("Curitiba"); char c2 = s.charAt(2); // c2 = 'r' if (s != null && s.length( ) > 8) char c3 = s.charAt(8); } } // fim

45 Exemplo modificado com tratamento de exceções
class TestNullP { static String s = null; public static void main(String args[]) { try char c1 = s.charAt(2); } catch (Exception e) System.out.println("Exceção " + e); // Exceção: java.lang.NullPointerException } // continua

46 Exemplo modificado com tratamento de exceções (cont.)
s = new String("Curitiba"); try { char c2 = s.charAt(2); // c2 = 'r' } catch (Exception e) System.out.println("Exceção " + e); // continua

47 Exemplo modificado com tratamento de exceções (cont.)
try { char c3 = s.charAt(8); } catch (Exception e) System.out.println("Exceção " + e); // Exceção: java.lang.StringIndexOutOfBoundsException } // fim

48 Hierarquia de exceções
... ... ... ...

49 A cláusula throws class TestNullP { static String s = null;
static void work( ) throws Throwable { try { char c1 = s.charAt(2); } catch (Exception e) { System.out.println("Exceção"); throw(e); } catch (Error e) { System.out.println("Erro"); throw(e); } finally { System.out.println("Adios, amigos");} } // continua

50 A cláusula throws (cont.)
public static void main(String args[ ]) { try { work( ); } catch(Throwable t) { System.out.println("Erro ou Exceção " + t); } finally { System.out.println("Adios, amigos II");} } } // fim

51 Definindo suas próprias exceções
class ProblemaEmWork extends Exception { public ProblemaEmWork( ) { } public ProblemaEmWork(String msg) { super(msg); } } // continua

52 Definindo suas próprias exceções (cont.)
class TestNullP { static String s = null; static void work( ) throws ProblemaEmWork { try { char c1 = s.charAt(2); } catch (Exception e) { throw(new ProblemaEmWork("Exceção em work " + e)); } catch (Error e) { throw(new ProblemaEmWork("Erro em work " + e)); } finally { System.out.println("Adios, amigos");} } // continua

53 Definindo suas próprias exceções (cont.)
public static void main(String args[ ]) { try { work(); } catch(ProblemaEmWork p) { System.out.println(p); } finally { System.out.println("Adios, amigos II");} } } // fim

54 Objeto Composto Um objeto pode conter uma referência para outro objeto, recursivamente. Nesse caso, o objeto é dito ser composto ou complexo.

55 Generalização Relacionamento entre uma classe e uma ou mais versões refinadas ou especializadas da classe. Especialização: relacionamento inverso Superclasse: versão mais abstrata de outra classe, a subclasse Subclasse: versão mais refinada de outra classe, a superclasse

56 Herança Mecanismo baseado em objetos que permite que as classes compartilhem atributos e operações baseados em um relacionamento, geralmente generalização. Uma subclasse herda atributos e operações da superclasse.

57 Classes Abstratas e Concretas
Classe abstrata: classe que não pode ter instâncias diretas, mas cujos descendentes sim; organizam características comuns a diversas classes; mecanismo para reutilizar código; pode definir operações abstratas (sem um correspondente método) Classe concreta: classe que pode ter instâncias diretas; não pode definir operações abstratas

58 Interface Um classe totalmente abstrata é dita ser uma interface.
A definição de uma interface não inclui qualquer implementação.

59 Interfaces - definição básica -
Uma interface possui um nome, e define apenas métodos abstratos e constantes (descreve uma abstração, normalmente um comportamento) Uma interface não pode ser instanciada Uma interface pode ser implementada por uma ou mais classes Cada classe pode estender somente uma classe, mas pode implementar diversas interfaces (alternativa para a falta de herança múltipla em Java)

60 Interfaces - definição básica -
Uma classe que implementa uma interface deve implementar todos os métodos abstratos definidos pela interface (não pode deixar qualquer implementação para suas subclasses) Uma interface pode estender uma ou mais interfaces Se uma classe herda duas constantes de duas interfaces distintas mas com o mesmo nome, deve fazer referência a cada constante precedendo-a com o nome da interface e um ponto

61 Interfaces - como usar - exemplo 1 -
public interface F { int k = 10; // public, static, final (constante) int f ( ); // public, abstract } class C implements F { public int f ( ) { return k; } // tem que ser public

62 Interfaces - como usar - exemplo 2 -
public interface F { int k = 10; int f( ); } interface G extends F // G e seus membros tem visibilidade package { void g( ); } class C implements G { public int f( ) { return k; } public void g( ) {}

63 Interfaces - como usar - exemplo 3 -
public interface F { int k = 10; int f( ); } interface H { int k = 10; int h( ); } interface G extends F, H { void g( ); } class C implements G { public int f( ) { return F.k;} public int h( ) { return H.k;} public void g() {} }

64 Interfaces - como usar - exemplo 4 -
public interface F { int k = 10; int f( ); } interface H { int k = 10; int h( ); } class D { } class E extends D implements F, H { public int f( ) { return F.k;} public int h( ) { return H.k;} }

65 Sobrecarga Atributos e operações podem ser redefinidos (sobrecarregados) por subclasses.

66 Sobrecarga para extensão
A nova operação é igual à operação herdada, exceto pelo fato de acrescentar alguns detalhes de comportamento, normalmente afetando novos atributos da subclasse.

67 Sobrecarga para restrição
A nova operação restringe o protocolo (assinatura da operação), podendo reduzir os tipos de argumentos. A operação herdada fica fechada (restrita) dentro de cada subclasse específica.

68 Sobrecarga para otimização
O novo método tem o mesmo protocolo externo e apresenta o mesmos resultados A implementação do novo método (algoritmo utilizado) pode ser completamente diferente

69 Sobrecarga por conveniência
Emprego adhoc de herança para reutilizar classes. Uma nova classe é tornada subclasse de uma classe existente e substitui os métodos inconvenientes. Semanticamente errado e conduz a problemas de manutenção; recomenda-se criar uma terceira classe (superclasse das demais)

70 Polimorfismo Assume muitas formas
A propriedade segundo a qual uma operação pode comportar-se diferentemente em classes diferentes. A subclasse redefine a implementação de uma operação herdada da superclasse. Onde se espera uma instância de um certa classe pode aparecer uma instância de qualquer subclasse daquela classe.

71 Herança Múltipla Uma classe possui mais de uma subclasse e herda características de todos os seus ancestrais. Maior capacidade de especificação de classes. Maior oportunidade de reutilização. Perda em simplicidade conceitual e de implementação.

72 Tipo Parametrizado Um tipo pode receber como parâmetro uma lista de tipos. Exemplos: pilha de inteiros pilha de reais pilha de pessoas ...