UNIJUI – Universidade Regional do Noroeste do Estado do Rio Grande do Sul

Ijuí, RS – Campus Ijuí

DETEC – Departamento de Tecnologia

Curso de Java
Módulo Básico

Introdução à OO
Introdução à UML
Introdução à JAVA

Eleonor Vinicius Dudel Mayer

Agosto de 2006

1
Sumário

1.Introdução à Orientação a Objetos....................................................................................................5
1.1.Objetos........................................................................................................................................6
1.2.Classe.........................................................................................................................................6
1.3.Polimorfismo..............................................................................................................................6
1.4.Herança......................................................................................................................................7
1.5.Métodos orientados a objetos.....................................................................................................7
2.Introdução à UML.............................................................................................................................9
2.1.Origem e evolução da UML.......................................................................................................9
2.2.Diagramas na UML...................................................................................................................9
2.2.1.Diagrama de Caso de Uso.................................................................................................10
2.2.2.Diagrama de Interação.....................................................................................................10
2.2.3.Diagrama de Seqüência....................................................................................................10
2.2.4.Diagrama de Colaboração................................................................................................11
2.2.5.Diagrama de Gráfico de Estados......................................................................................11
2.2.6.Diagrama de Atividades...................................................................................................12
2.2.7.Diagrama de Classes.........................................................................................................12
2.2.8.Diagrama de Componentes..............................................................................................13
2.2.9.Diagrama de Objetos........................................................................................................13
2.2.10.Diagrama de Implantação...............................................................................................14
2.3.Como os diagramas se relacionam na UML............................................................................14
2.4.Elementos da UML..................................................................................................................15
2.5.Blocos de construção da UML.................................................................................................15
2.5.1.Itens...................................................................................................................................15
2.6.Itens Estáticos...........................................................................................................................16
2.6.1.Classe................................................................................................................................16
2.6.2.Colaboração......................................................................................................................16
2.6.3.Caso de Uso......................................................................................................................17
2.6.4.Componente......................................................................................................................17
2.7.Itens Dinâmicos........................................................................................................................17
2.7.1.Iteração..............................................................................................................................17
2.7.2.Máquina de Estados..........................................................................................................18
2.8.Pacotes......................................................................................................................................18
2.9.Notas........................................................................................................................................19
2.10.Relacionamentos.....................................................................................................................19
2.10.1.Associação......................................................................................................................20
2.10.1.1.Multiplicidade de associação........................................................................................20
2.10.2.Agregação e Composição...............................................................................................20
2.10.3.Generalização..................................................................................................................21
2.10.4.Especialização.................................................................................................................21
2.10.5.Realização.......................................................................................................................22
2.11.Propósitos da UML.................................................................................................................23
2.12.O que não é UML...................................................................................................................23

2
 2.13.Onde pode ser utilizada a UML.............................................................................................23
2.14.Diferenças entre as versões da UML......................................................................................24
2.14.1.Versão 1.0 para 1.1..........................................................................................................24
2.14.2.Versão 1.1/1.2 para 1.3....................................................................................................24
3.Modelagem utilizando a UML........................................................................................................26
3.1.Modelagem da arquitetura de sistemas.....................................................................................26
3.2.A importância da modelagem..................................................................................................27
3.2.1.Construindo modelos........................................................................................................28
3.2.2.Modelagem orientada a objetos.......................................................................................28
4.Introdução à JAVA...........................................................................................................................29
4.1.Kit de Desenvolvimento JAVA.................................................................................................29
4.1.1.Plataforma JAVA...............................................................................................................29
4.1.2.Java Virtual Machine (JVM)............................................................................................29
4.1.3.Java 2 JDK........................................................................................................................29
4.1.4.Compilador javac..............................................................................................................29
4.1.5.Interpretador java..............................................................................................................29
4.1.6.Interpretador jre................................................................................................................29
4.1.7.Gerador de documentação javadoc...................................................................................29
4.1.8.Java Archieve Tool............................................................................................................29
4.2.Sintaxe.....................................................................................................................................29
4.2.1.Nomes de identificadores.................................................................................................29
4.2.2.Palavras reservadas..........................................................................................................30
4.2.3.Operadores da linguagem JAVA.......................................................................................30
4.2.3.1.Precedência de operadores........................................................................................30
4.2.4.Tipos Primitivos...............................................................................................................30
4.2.5.Java e C++........................................................................................................................30
4.3.JAVA Básico.............................................................................................................................30
4.3.1.Comandos.........................................................................................................................30
4.3.1.1.Declaração de variáveis.............................................................................................30
4.3.1.2.Condicionais.............................................................................................................30
4.3.1.3.Laços.........................................................................................................................30
4.3.1.4.Comandos especiais..................................................................................................30
4.3.2.Comentários.....................................................................................................................30
4.3.3.Modificadores...................................................................................................................31
4.3.4.Declaração de classes, métodos e variáveis......................................................................31
4.3.4.1.Classes.......................................................................................................................31
4.3.4.2.Subclasses.................................................................................................................31
4.3.4.3.Interfaces...................................................................................................................31
4.3.5.Instanciação de objetos.....................................................................................................31
4.3.5.1.super e this................................................................................................................31
4.3.6.Conversões........................................................................................................................31
4.3.6.1.Tipos Primitivos........................................................................................................31
4.3.6.2.Objetos......................................................................................................................31
4.3.6.3.Interfaces...................................................................................................................31
4.3.7.Arrays................................................................................................................................31
4.3.8.Aplicação JAVA................................................................................................................31
4.3.8.1.Parâmetros de entrada...............................................................................................32

3
4.3.9.Exceções...........................................................................................................................32
4.3.10.Threads...........................................................................................................................32
4.3.10.1.Criação de threads...................................................................................................32
4.3.10.2.Métodos de tread.....................................................................................................32
4.3.10.3.Monitores................................................................................................................32
4.3.10.4.Uso de wait() e notify()...........................................................................................32
4.3.11.JDBC...............................................................................................................................32
4.3.11.1.Arquitetura JDBC....................................................................................................32
4.3.11.2.Instalação de um driver JDBC................................................................................32
4.3.11.3.Exemplo com a ponte JDBC­ODBC.......................................................................32
4.3.11.4.Classes do package java.sql.....................................................................................32
4.3.11.5.Tabela de conversão JAVA­SQL..............................................................................32
4.3.12.RMI – Remote Method Invocation.................................................................................33
4.3.12.1.Arquitetura RMI......................................................................................................33
4.3.12.2.Interface com métodos de acesso remoto...............................................................33
4.3.12.3.Servidor de métodos...............................................................................................33
4.3.12.4.Cliente.....................................................................................................................33
4.3.12.5.Etapas de compilação.............................................................................................33
4.3.12.6.Inicio do serviço.....................................................................................................33

4
 1. Introdução à Orientação a Objetos

A orientação a objetos surgiu como uma nova forma de modelar e construir sistemas de software, 
isto   é,   organizar   e   gerir   conhecimentos   manipulados   e   registrados   dentro   de   uma   empresa.   No 
desenvolvimento   de   um   sistema   orientado   a   objetos,   dados   e   processos   são   organizados   e 
manipulados por objetos, e não por programas.

Vantagens:
● Reutilização dos objetos: Os dados e os processos são manipulados por objetos, não 
ficando   engessados   dentro   de   programas,   isto   é,   os   objetos   construídos   podem   ser 
utilizados por diferentes sistemas;
● Modularidade:   O   sistema   é   formado   por   objetos   e   não   por   programas,   facilitando   o 
trabalho e a manipulação desses objetos no futuro;
● Utiliza­se dos mesmo conceitos da realidade na construção de sistemas de software.

A orientação a objetos baseia­se em conceitos da realidade – objetos, estado e estímulos – para 
modelagem e construção de sistema de software. Dessa forma, o uso da orientação a objetos se 
torna mais natural, pois os conceitos utilizados são os mesmos que já conhecemos, só que aplicados 
nesses casos ao desenvolvimentos de sistemas.

5
 Exemplo de objeto, estado e estímulo

1.1.Objetos

Pode ser qualquer coisa na natureza que possua características e comportamentos.

Objetos:
● Uma pessoa; 
● Um veículo; 
● Uma região; 

1.2.Classe

É   uma   abstração  de  um  conjunto de  objetos  que possuem  os  mesmo  tipos  de  características  e 
comportamentos.

Classe Veículo:
● Carro de Passeio; 
● Carro Esportivo; 
● Carro Rural; 

1.3.Polimorfismo

Polimorfismo   (do   grego   “muitas   formas”)   refere­se   aos   processos   que   vários   objetos   podem 

6
executar, dado apenas a solicitação de uma única operação. No ambiente polimórfico, todos os 
objetos contem uma mesma operação, que é implementada por métodos particulares a cada objeto.

Polimorfismo

1.4.Herança

É o comportamento pelas classes especializadas (subclasses) dos atributos e operações de classes 
mais gerais (superclasse).

Herança

1.5.Métodos orientados a objetos

Nos últimos tempos houve uma grande evolução na engenharia de software, que passou a contar 
com técnicas, como a análise, o projetos estruturado e a Engenharia da Informação. Os métodos 

7
orientados a objetos surgiram na década de setenta (70), procurando melhorar estas técnicas.

A seguir são apresentados resumidamente alguns métodos que surgiram para a orientação a objetos.

Método Descrição
Booch Consiste em técnicas do desenho orientado a objetos. Esse método utiliza­se 
do desenho de objetos, que servem como base para a criação dos módulos 
do sistema. Esse método foi criado por Grandy Booch.
OMT O   método   OMT   (Object   Modeling   Technique)   consiste   na   modelagem 
semântica de dados, suportando os conceitos de:
­ Modelagem de dados (atributos e relacionamentos);
­ Objetos (composição e agregação);
­ Herança;
Esse método foi criado por James Rumbaugh.
OOSE O   método   OOSE   (Object   Oriented   Software   Engineering),   consiste   na 
análise dos requerimentos de um sistema utilizando casos de uso, criando 
categorias para pessoas e equipamentos com que esses casos interagem. Esse 
método foi criado por Ivar Jacobson.
Coad/Yourdon Peter Coad e Ed Yourdon dividiram a análise orientada a objetos em classes 
e objetos. Dentro desse contexto, os objetos são relacionados por meio dos 
conceitos de agregação, generalização/especialização, associação, conexões 
e mensagens.

8
 2. Introdução à UML

A Unified Modeling Language (UML) é o resultado da unificação dos métodos Booch, OMT e 
OOSE, que dá origem a uma linguagem padronizada para a modelagem de sistema de software 
orientados a objetos, sendo adotada pela indústria de software como linguagem­padrão, e também 
por fornecedores de ferramentas CASE.

2.1.Origem e evolução da UML

Os trabalhos para criação da UML iniciaram­se em mil novecentos e noventa e quatro (1994) com 
Grandy Booch (Método Booch) e James Rumbaugh (Método OMT), que combinaram seus dois 
métodos mais populares.

Versão Ano Principais Fatos Ocorridos

UML 0.8 1995 Lançamento do primeiro esboço da UML.
UML 0.9 1996 Integração de Ivar Jacobson à equipe, e seu método OOSE à 
expansão do escopo da UML.
Formação   de   um   consórcio   de   empresas,   com   o   objetivo   de 
apoiar a definição da UML.
UML 1.0 1997 A UML foi submetida como candidata a linguagem­padrão de 
modelagem à OMG (Object Management Group, uma entidade 
de padronização estabelecida pela indústria de software).
UML 1.1 1997 Expansão   do   consórcio   formado   por   empresas   para   apoiar   a 
definição da UML, e aceitação da UML pela OMG.
UML 1.2 1998 Revisões e novas padronizações.
UML 1.3 1998 Revisões e novas padronizações.

2.2.Diagramas na UML

Diagrama é a representação gráfica de um conjunto de elementos do sistema. A UML disponibiliza 
nove diagramas que permitem representar diferentes partes do modelo de um sistema.

9
 2.2.1.Diagrama de Caso de Uso

O diagrama de casos de uso representa um conjunto de atores, casos de uso e os relacionamentos 
entre eles.

Diagrama de Casos de Uso

2.2.2.Diagrama de Interação

Os diagramas de interação representam colaborações entre objetos, para realizarem algum tipo de 
comportamento para um sistema. Os diagramas de interação são representados por:
● Diagrama de Seqüência;
● Diagrama de Colaboração;

2.2.3.Diagrama de Seqüência

O diagrama de seqüência dá ênfase à ordenação temporal em que as mensagens são trocadas entre 
os objetos de um sistema. Podemos entender por mensagens, os serviços solicitados por um objeto a 
outro, e as respostas devolvidas a essas solicitações.

10
 Diagrama de Sequencia

2.2.4.Diagrama de Colaboração

O diagrama de colaboração dá ênfase à ordenação estrutural em que as mensagens são trocadas 
entre os objetos de um sistema.

Diagrama de Colaboração

2.2.5.Diagrama de Gráfico de Estados

O diagrama de gráfico de estados representa os estados possíveis de um objeto em particular. São 

11
exibidos os estados de um objeto, eventos, transições e atividades. Pode ser usado principalmente 
para a modelagem de estados de classes e colaborações.

Diagrama de Gráfico de Estados

2.2.6.Diagrama de Atividades

O diagrama de atividades representa a modelagem do fluxo de controle de uma atividade para uma 
outra no sistema. São exibidos os estados das atividades e ações, transições e objetos.

Diagrama de Atividades

2.2.7.Diagrama de Classes

O   diagrama   de   classes   representa   a   estrutura   (esqueleto)   de   um   sistema,   sendo   encontrado 

12
geralmente na maioria dos sistemas orientados a objetos. São exibidos classes e seus respectivos 
relacionamentos.

Diagrama de Classes

2.2.8.Diagrama de Componentes

O   diagrama   de   componentes   representa   um   conjunto   de   componentes   e   suas   respectivas 

dependências, podendo ter como base de sua construção os diagramas de classes.

Diagrama de Componentes

2.2.9.Diagrama de Objetos

O diagrama de objetos representa as instâncias das classes de um sistema, em determinado ponto no 
tempo.

13
 Diagrama de Objetos

2.2.10.Diagrama de Implantação

O diagrama de implantação representa a configuração e a arquitetura de um sistema em que estarão 
ligados   os   respectivos   componentes,   podendo   ser   representado   também   a   arquitetura   física   de 
hardwares, processadores, entre outros. Com o diagrama de componentes, representa os aspectos 
físicos de um sistema.

Diagrama de Implantação

2.3.Como os diagramas se relacionam na UML

Os diagramas da UML representam diferentes partes do modelo de um sistema. No quadro a seguir 
é demonstrado como os diagramas se relacionam, formando toda a modelagem orientada a objetos.

14
 Relacionamento entre diagramas da UML

2.4.Elementos da UML

Os elementos da UML são as simbologias e notações que utilizaremos para construir os modelos 
orientados a objetos. Nesse caso, os elementos principais são os blocos de construção.

2.5.Blocos de construção da UML

Os   blocos   de   construção   da   UML   são   as   matérias­primas   utilizadas   pelos   diagramas   para 

representar partes de um sistema de software. Entre os blocos de construção existentes na UML, 
podemos observar:
● Itens;
● Relacionamentos;

2.5.1.Itens

Os itens são os blocos de construção da modelagem orientada a objetos. Existem quatro tipos de 
itens na UML. São eles:

Tipo Descrição
Itens Estáticos Representam a estrutura do modelo, elementos conceituais e físicos 

15
Tipo Descrição
(classes, colaborações, casos de uso, entre outros).
Itens Dinâmicos Definem   o   comportamento   do   modelo   (interações   e   estado   dos 
objetos).
Pacotes São as partes organizacionais da UML.
Notas São   as   partes   explicativas   do   modelo   na   UML   (comentários   e 
observações de esclarecimentos no modelo).

2.6.Itens Estáticos

Os itens estáticos representam o esqueleto e a estrutura estável de um sistema.

2.6.1.Classe

Uma   classe   é   um   conjunto   de   objetos   que   compartilham   os   mesmo   atributos,   operações   e 

relacionamentos. É representada graficamente como no exemplo a seguir:

Classe

2.6.2.Colaboração

Uma colaboração é o nome dado à interação entre duas ou mais classes, com o objetivo de fornecer 
algum comportamento cooperativo. Ocorrem por meio da troca de mensagens entre dois ou mais 
objetos.

16
 2.6.3.Caso de Uso

Um caso de uso é um documentos que descreve os cenários pretendidos para um sistema, com o 
objetivo de atender às necessidades do usuário. É representado graficamente como no exemplo a 
seguir:

Caso de uso

2.6.4.Componente

Um componente é a parte física de um sistema. Existem diferentes tipos de componentes, como os 
componentes COM+ e Java Beans.

Componente

2.7.Itens Dinâmicos

Os itens dinâmicos representam as partes de um sistema que possam ter alguma alteração. Existem 
dois tipo principais de itens dinâmicos. São eles:
● Iteração;
● Máquina de estados;

2.7.1.Iteração

Representa a realização dos processos de um sistema, por meio da troca de mensagens entre os 
objetos. Pode envolver mensagens, seqüências de ações e conexões entre os objetos. Uma interação 
é representada por uma flecha cheia, como no exemplo  seguir:

17
 Mensagem

2.7.2.Máquina de Estados

Representa   um   comportamento   que   especifica   as   seqüências   de   estados   pelos   quais   os   objetos 

passam durante sua existência, de acordo com os eventos atendidos. No exemplo a seguir, temos um 
estado possível para o objeto “Venda”.

Estados

2.8.Pacotes

Os pacotes organizam os modelos criados na UML. Todos os blocos de construção criados no UML 
(casos de uso, classes, componentes, e demais), bem como os diagramas que tratam desses blocos, 
podem ser organizados em pacotes. Deve­se fazer essa organização observando a semelhança de 
cada bloco e diagrama da UML, no que diz respeito à solução do problema que cada um está 
empregando.

18
 Pacotes

2.9.Notas

As   notas   representam   comentários,   observações   e   esclarecimentos   que   poder   se   utilizar   para 

qualquer elemento da UML. No exemplo a seguir, a representação de uma nota informando a última 
versão de uma classe.

Nota

2.10.Relacionamentos

Os relacionamentos reúnem os itens criados na UML. Existem seis tipo de relacionamentos. São 
eles: 
● Associação;
● Agregação e composição;
● Generalização;

19
 ● Especialização;
● Realização;

2.10.1.Associação

Uma associação descreve relacionamentos entre objetos. Cada associação tem duas pontas, onde em 
cada ponta está ligado um objeto. Por exemplo, poderíamos ter um relacionamento de associação 
entre o objeto Cliente na primeira ponta, e o objeto AnaliseCredito na outra ponta.

Associação

2.10.1.1.Multiplicidade de associação

É a indicação de quantos objetos podem participar de dado relacionamento. No exemplo anterior, 
pode­se dizer que o objeto NotaFiscal pode ter um ou mais objetos Produtos, enquanto esse objeto 
pode   ter   zero   ou   mais   objetos   NotaFiscal.   Na   UML   temos   basicamente   os   seguintes   tipos   de 
multiplicidade:
● 0 (zero);
● 1 (um);
● 0..1 (zero ou um);
● 0..* (zero ou mais);
● 1..* (um ou mais);
● * (muitos);

2.10.2.Agregação e Composição

A agregação é um tipo de associação na qual o todo é relacionado com suas partes (um objetos todo 
contem os objetos­partes – relacionamento todo/parte). É representada como um linha de associação 

20
com um diamante junto à classe agregadora.

Agregação

A composição é um tipo de relacionamento muito semelhante à agregação. Em uma composição, o 
objeto­parte pode pertencer somente ao objeto­todo. Além disso, geralmente o objeto­todo vive e 
morre com suas partes, isto é, acontece uma remoção em cascata. É representada como uma linha 
de associação com um diamante preto, junto à classe agregadora.

Composição

2.10.3.Generalização

Generalização é a capacidade de se criar supertipos que encapsulam a estrutura e o comportamento 
comum a vários subtipos. Os procedimentos pode se obter a generalização são:
● Identificar similaridades de estrutura/comportamento entre várias classes;
● Criar o supertipo para encapsular a estrutura e o comportamento comum a mais de uma 
classe;
● Os objetos originais passam a ser subtipos de novo supertipo criado;

2.10.4.Especialização

A especialização é a capacidade de se criar subtipos que representam refinamentos nos quais a 

21
estrutura e/ou comportamento do supertipo são adicionais ou modificados. Os procedimentos para 
obter a especialização são:
● Perceber que algumas classes apresentam estrutura e/ou comportamento especializado;
● Criar subtipos de acordo com sua especialização;

Generalização / Especialização

2.10.5.Realização

A   realização   é   um   relacionamento   entre   itens,   em   que   um   item   implementa   comportamentos 

especificados   por   outros.   Pode   ser   realizado   entre   interfaces   e   classes   ou   componentes   que   as 
realizam. É representado por uma seta pontilhada, como no exemplo a seguir:

22
 Realização

2.11.Propósitos da UML

A   UML   nasceu com  o propósito de documentar, visualizar, especificar  e construir  sistemas  de 

software orientados a objetos.

Propósito Descrição
Documentar Artefatos como requisições de negócio, modelo de arquitetura, código­
fonte, modelo de análise, protótipo e outros documentos que servem de 
informação sobre o sistema, podem ser documentados com a UML
Visualizar No   processo   de   desenvolvimento   de   sistemas   de   software,   é   quase 
impossível a visualização de toda a estrutura de um software sem o uso de 
modelos que a represente. Dessa forma, a UML disponibiliza símbolos 
gráficos para a representação de artefatos de software.
Especificar A   UML   é   uma   linguagem   que   atente   a   todos   os   requisitos   de 
especificação dentro de um processo, desde a fase de análise até a fase de 
teste e implementação do sistema construído.
Construir Na UML é possível realizar um mapeamento dos modelos gerados, para 
linguagens de programação e até mesmo para banco de dados relacionais 
ou orientados a objetos.

2.12.O que não é UML

A UML não é uma linguagem de programação visual, e sim uma linguagem para modelagem visual. 
Apesar de oferecer suporte a diversas linguagens de programação, a UML é uma linguagem para 
construção de artefatos de software que servem para a tomada de decisão quanto à definição de 
arquitetura, implementação, entre outros.

A UML não é um processo de desenvolvimento, mas pode e dever ser aplicado a um. A UML, como 
uma linguagem de modelagem, pode e deve ser aplicada a um processo de desenvolvimento de 
software, assim como outros linguagens utilizadas para a construção de artefatos de software. Em 
um contexto de processos, a UML se propõe a tratar, em diversos domínios, diferentes problemas e 
em diferentes organizações.

2.13.Onde pode ser utilizada a UML

23
A UML pode ser aplicada a qualquer tipo de sistemas de software. Por ser uma linguagem muito 
abrangente, ela pode ser usada também para modelar processos de trabalhos, projetos de hardware, 
entre outros.

2.14.Diferenças entre as versões da UML

A UML desde seu nascimento vem passando por mudanças em seu conteúdo. Como conseqüência 
dessas mudanças foram criadas versões mais maduras e completas. A seguir são descritas algumas 
mudanças (as mais importantes) que ocorreram durante as versões lançadas da UML.

2.14.1.Versão 1.0 para 1.1

As mudanças mais significativas nessa versão dizem respeito aos diagramas de classes e diagramas 
de  seqüência. Na versão 1.1 as classes pode ser especializadas como tipos ou como classes de 
implementação.

● Tipos   de   Implementação:   Uma   classe   de   implementação   é   realmente   uma   classe 

programada no ambiente de software. Uma classe especializada como tipo que pode 
representar   uma   abstração   do   sistema.   Podem   ser   classes   que   representam   apenas   o 
modelo conceitual do sistema ou, ainda, as interfaces do sistema. Portanto, você pode 
representar em seu modelo de classes de implementação um ou mais tipos;
● Diagrama de Seqüência: Na versão 1.0 da UML os retornos em diagramas de seqüência 
eram representados por uma flecha vazada, em vez de uma flecha cheia. Na versão 1.1 os 
retornos são realizados por meio de uma flexa pontilhada, deixando mais perceptível 
esse tipo de atividade. Supõe­se que essa mudança foi realizada pois a diferença entre 
uma flecha vazada e uma cheia era muito sutil e de difícil diferenciação;

2.14.2.Versão 1.1/1.2 para 1.3

As mudanças realizadas da versão 1.1 para a versão 1.2, foram modificações sutis. Somente na 
versão 1.3 foram feitas mudanças realmente significativas.

● Relacionamentos   entre   casos   de   uso:   Na   versão   1.1   da   UML   havia   dois   tipos   de 
relacionamentos entre casos de uso: relacionamentos do tipo <<uses>> e <<extends>>. 
Já na versão 1.3 foram disponibilizados três tipos de relacionamentos:
 Include:   No   relacionamento   do   tipo   <<include>>   (subtituíndo   então 
<<uses>>) as atividades em comum compartilhadas por alguns casos de uso 

24
 são incluídas em um outro caso de uso público. Por exemplo, em um sistema 
de análise de crédito pode ser que tanto o processo de aprovação de crédito 
quanto o processo de reprovação utilizem as atividades de validar a alçada do 
analista de crédito;
 Extends: No relacionamento do tipo <<extends>> as atividades de um caso 
de uso não são obrigatórias são estendidas em um outro caso de uso. Isso 
significa que um comportamento de caso de uso pode ser desviado apenas em 
situações   predefinidas   no   caso   de   uso   estendido.   Por   exemplo,   em   um 
processo   de   análise   de   crédito,   o   crédito   dos   clientes   pode   ser   aprovado 
automaticamente, sem que tenha de passar por todas as etapas de análise, caso 
sua   renda   seja   cinco   vezes   o   valor   total   do   financiamento.   Esse 
comportamento de aprovação automática pode mudar todo o comportamento 
do sistema caso sua condição seja verdadeira;
 Generalização:   No   relacionamento   de   generalização   o   comportamento 
comum a mais de um caso de uso em um mesmo domínio é capturado em um 
supertipo (generalizado). Sendo assim, esses casos de uso agora considerados 
subtipos (especializados) herdam desse supertipo criando o comportamento 
comum a eles mesmo;
● Diagrama   de   Atividade:   Para   comportamento   condicional,   você   pode   agora   usar   a 
atividade   de   decisão   (em   forma   de   losango),   para   a   intercalação   ou   ramificação   de 
comportamentos. A barra de sincronização é agora referida como separação ou junção. 
Mas você não poderá mais acrescentar condições arbitrárias às junções. Deve­se, então, 
seguir regras de combinação para assegurar­se de que separação e junção combinam. O 
acionamento   duplo   não   é   mais   utilizado.   Agora   você   pode   utilizar   a   concorrência 
dinâmica em um atividade, usando­se o asterisco (*);

25
 3. Modelagem utilizando a UML

Esclareceremos agora como é dividida a modelagem de um sistema orientado a objetos e o uso da 
UML neste contexto.

3.1.Modelagem da arquitetura de sistemas

A arquitetura de um sistema representa um conjunto dos artefatos e elementos que formarão o 
sistema.   A   arquitetura   deve   abranger   como   este   será   construído,   seus   elementos   estruturais   e 
comportamentais, suas colaborações, entre outras.

Construir sistemas de software é uma tarefa que requer a visualização da arquitetura desses sistemas 
sob várias perspectivas e em diferentes níveis de detalhamento. Todos os envolvidos na construção 
de   sistemas   –   gerentes,   analistas,   programadores,   usuários   finais   –   necessitam   visualizar   a 
arquitetura de um sistema sob perspectivas diferentes, pois a necessidade de entendimento de cada 
participante neste processo influenciará seu trabalho futuramente quando o sistema estiver pronto.

Portanto, a arquitetura de um sistema deve ser visualizada por meio de cinco visões:

Divisão da arquitetura de um sistema

Visão Descrição
Caso de Uso Essa visão focaliza os comportamentos de um sistema. A visão deve ser 
transparente   para   todos   os   envolvidos   na   construção   do   sistema   – 
gerentes, analistas, programados, usuários finais.
Diagramas utilizados: Diagrama de casos de uso, interação, atividade e 
de gráficos de estados.
Projeto Essa visão focaliza a estrutura (esqueleto) de um sistema. A visão sob 
essa perspectiva demonstra as classes, colaborações e as interfaces de um 

26
Visão Descrição
sistema em construção.
Diagramas   utilizados:   Diagramas   de   classes,   de   objetos,   interação, 
atividades e de gráfico de estados.
Processos Essa   visão   focaliza   as   questões   de   desempenho,   escalabilidade, 
mecanismos de concorrência e de sincronização. 
Diagramas utilizados: os mesmos diagramas da visão de projeto.
Implementação Essa   visão   focaliza   os   artefatos   físicos   para   a   efetiva   montagem   do 
sistema. São abordados componentes e outros arquivos que servem para a 
montagem do sistema.
Diagramas   utilizados:   Diagrama   de   componentes,   de   interação,   de 
atividade e de gráfico de estados.
Implantação Essa visão focaliza os nós que formam a topologia de hardware em que o 
sistema será executado.
Diagramas   utilizados:   Diagrama   de   implantação,   de   interação,   de 
atividade e de gráfico de estados.

3.2.A importância da modelagem

Vamos   imaginar   um   possível   situação.   Você   trabalha   para   uma   grande   rede   de   lojas   de 
departamentos,  onde  são  comercializados  diversos  produtos   como  eletrônicos, eletrodomésticos, 
informática e outros. Esta rede automatizará toda a sua área de concessão de crédito, e você foi 
designado a conduzir todo o processo de construção de um sistema que atenda as necessidades de 
negócios   da   empresa.   Esse   sistema   será   encarregado   de   realizar   toda   a   análise   de   crédito   dos 
clientes dessas lojas, seguindo uma rigorosa política de crédito estabelecida pela diretoria.

Esse sistema deve fornecer informações sobre o crédito do cliente, por meio de Órgãos de Proteção 
ao   Crédito,   realizar   análises   pelo   CreditScore,   conferir   as   informações   pessoais   prestadas   pelo 
cliente, enfim, verificar o enquadramento do perfil desse cliente junto às políticas de concessão de 
crédito da empresa.

A   menos   que   já   tenha   feito   diversos   sistemas   com   as   mesmas   requisições   de   negócios,   você 
certamente   precisará   fazer   um   planejamento   antes   de   começar   a   fazer   a   primeira   linha   de 
programação.

Nesses caso, você deverá estimar o tempo necessário para que esse sistema seja desenvolvido, bem 
como   qual   será   o   curso   do   seu   desenvolvimento.   Será   preciso   estimar   também   quais   serão   os 
recursos   humanos   envolvidos   nesse   processo,   bem   como   o   custo   de   cada   recurso,   suas 
responsabilidades, entre outras atividades.

27
Dessa forma, para que tudo saia conforme suas estimativas (ou o mais próximo disso) você com 
certeza necessitará de todos os modelos e esboços desse projeto que demonstrem a complexidade do 
processo e os riscos possíveis. Além disso, você desejará manter todo o processo documentado, pois 
em   manutenções   futuras   desses   sistema   e,   caso   os   desenvolvedores   iniciais   não   estejam   mais 
presentes,   você   certamente   não   passará   apuros,   esperando   que   se   entenda   como   o   processo 
funciona. Você também desejará que, no próximo sistema que será desenvolvido, se passa reutilizar 
os processos já criados anteriormente, sem que seja necessário “reinventar a roda”.

Uma das variáveis que farão com que esse processo seja bem­sucedido é a utilização da modelagem. 
Não quer atribuir toda a responsabilidade do sucesso de um sistema, somente pelo fato de uso da 
modelagem.   É   evidente   que   a   escolha   de   bons   profissionais   com   esforço   em   equipe   (e 
principalmente, o apoio de todos os envolvidos nesse processo) se torna indispensável para que se 
atinja o objetivo proposto.

3.2.1.Construindo modelos

Imagine a construção de uma nova casa, um novo prédio ou até mesmo um avião, sem que seja 
construído primeiro os seus respectivos modelos. Seria um erro cuja proporção não poderíamos 
estimar. Milhões de vidas seriam arriscadas (e certamente perdidas) se não houvesse modelos em 
que pudéssemos visualizar o que futuramente virá a ser realidade, possibilitando a correção de erros 
antes que fossem concebidos os produtos finais.

Enfim, construimos modelos para compreendermos melhor o sistema que estamos desenvolvendo. 
Com a modelagem, podemos alcançar:
● A especificação da estrutura e do comportamento do sistema;
● A visualização do sistema como ele é ou como desejamos que ele seja;
● Documentar todas as decisões tomadas;

3.2.2.Modelagem orientada a objetos

A visão do desenvolvimento de sistemas nos últimos anos, vem adotando uma perspectiva orientada 
a objetos. Sob esta perspectiva, o principal bloco de construção do sistema é o objeto. Não há 
dúvidas de que os métodos orientados a objetos têm consolidado seu uso na construção de sistemas 
de diferentes domínios de problemas, sendo simples ou complexos.

28