Embed Size (px)
Citation preview
OrganizadorErick Guilhon
Design InstrucionalNT Editora
RevisãoNT Editora
Editoração EletrônicaNT Editora
Projeto GráficoNT Editora
CapaNT Editora
IlustraçãoNT Editora
NT Editora, uma empresa do Grupo NT SCS Quadra 2 – Bl. C – 4º andar – Ed. Cedro IICEP 70.302-914 – Brasília – DFFone: (61) [email protected] e www.grupont.com.br
Copyright © 2018 por NT editora.Nenhuma parte desta publicação poderá ser reproduzida por
qualquer modo ou meio, seja eletrônico, fotográfico, mecânico ou outros, sem autorização prévia e escrita da NT Editora.
Guilhon, Erick (Org.).
Programação orientada a objetos / Erick Guilhon (Org.) – 1. ed. – Brasília: NT Editora, 2018.
160 p. il. ; 21,0 X 29,7 cm.
ISBN 978-85-8416-281-9
1. Programação. 2. Objetos. 3. Linguagem Java.
I. Título
LEGENDA
ÍCONES
Prezado(a) aluno(a),Ao longo dos seus estudos, você encontrará alguns ícones na coluna lateral do mate-rial didático. A presença desses ícones o(a) ajudará a compreender melhor o conteúdo abordado e a fazer os exercícios propostos. Conheça os ícones logo abaixo:
Saiba maisEsse ícone apontará para informações complementares sobre o assunto que você está estudando. Serão curiosidades, temas afins ou exemplos do cotidi-ano que o ajudarão a fixar o conteúdo estudado.
ImportanteO conteúdo indicado com esse ícone tem bastante importância para seus es-tudos. Leia com atenção e, tendo dúvida, pergunte ao seu tutor.
DicasEsse ícone apresenta dicas de estudo.
Exercícios Toda vez que você vir o ícone de exercícios, responda às questões propostas.
Exercícios Ao final das lições, você deverá responder aos exercícios no seu livro.
Bons estudos!
4 NT Editora
Sumário
1. INTRODUÇÃO .................................................................................................. 9
1.1 Decomposição funcional .......................................................................................................91.2 Orientação a objetos ...............................................................................................................91.3 Fases de desenvolvimento ................................................................................................. 111.4 Linguagens de programação ............................................................................................ 111.5 Testes ......................................................................................................................................... 121.6 Metodologias .......................................................................................................................... 12
2. A LINGUAGEM JAVA ...................................................................................... 16
2.1 Introdução ............................................................................................................................... 162.2 Enunciados e comentários ................................................................................................. 162.3 Variáveis e constantes .......................................................................................................... 162.4 Operadores .............................................................................................................................. 172.5 Controle de fluxo ................................................................................................................... 202.6 Controle de repetição .......................................................................................................... 23
3. CLASSES ......................................................................................................... 31
3.1 Definição .................................................................................................................................. 313.2 Atributos ................................................................................................................................... 333.3 Tipos de atributos .................................................................................................................. 343.4 Valor inicial de um atributo ................................................................................................ 343.5 Atributos constantes ............................................................................................................ 343.6 Métodos .................................................................................................................................... 353.7 Visibilidade ............................................................................................................................... 363.8 Construtores ............................................................................................................................ 383.9 Diagramas de classes ........................................................................................................... 40
4. OBJETOS......................................................................................................... 44
4.1 Definição .................................................................................................................................. 444.2 Identificador de objeto ....................................................................................................... 444.3 Tipos de objetos ..................................................................................................................... 454.4 Instanciando uma classe..................................................................................................... 474.5 Representação na UML ....................................................................................................... 49
5. RELACIONAMENTOS ..................................................................................... 52
5.1 Diagramas de classes ........................................................................................................... 52
5Programação Orientada a Objetos
5.2 Diagramas de objetos .......................................................................................................... 525.3 Associações ............................................................................................................................. 525.4 Navegabilidade ...................................................................................................................... 545.5 Nomes das associações ....................................................................................................... 555.6 Papéis em associações......................................................................................................... 555.7 Multiplicidade e cardinalidade ......................................................................................... 565.8 Associação um para um ...................................................................................................... 565.9 Associação muitos para um ............................................................................................... 575.10 Associação um para muitos ............................................................................................ 585.11 Associação muitos para muitos ..................................................................................... 585.12 Associações qualificadas .................................................................................................. 605.13 Associações exclusivas ...................................................................................................... 605.14 Associações ordenadas ..................................................................................................... 615.15 Atributos de uma associação ......................................................................................... 615.16 Agregações ........................................................................................................................... 625.17 Especializações e generalizações .................................................................................. 625.18 Métodos abstratos .............................................................................................................. 665.19 Métodos finais ...................................................................................................................... 675.20 Interfaces ............................................................................................................................... 68
6. MENSAGENS .................................................................................................. 72
6.1 Troca de mensagens ............................................................................................................. 726.2 Polimorfismo ........................................................................................................................... 736.3 Métodos estáticos ................................................................................................................. 766.4 Diagramas de sequência .................................................................................................... 76
7. BIBLIOTECAS DE CLASSES ........................................................................... 82
7.1 Packages ................................................................................................................................... 827.2 Nomes dos packages ........................................................................................................... 827.3 Localizações dos packages ................................................................................................ 837.4 Classes e interfaces em um package .............................................................................. 837.5 Nomes em Java ...................................................................................................................... 847.6 Controle de acesso ................................................................................................................ 857.7 Packages padrão .................................................................................................................... 867.8 Packages na UML ................................................................................................................... 90
8. EXCEÇÕES ...................................................................................................... 95
6 NT Editora
8.1 Informando erros................................................................................................................... 958.2 Lançando exceções .............................................................................................................. 958.3 Tratamento de exceções ..................................................................................................... 968.4 Passando a responsabilidade do tratamento.............................................................. 978.5 Definindo uma exceção ...................................................................................................... 98
9. ESTADOS E EVENTOS .................................................................................. 103
9.1 Estados ....................................................................................................................................1039.2 Eventos ....................................................................................................................................1039.3 Transições ...............................................................................................................................1069.4 Guarda .....................................................................................................................................1079.5 Diagramas de estados .......................................................................................................1089.6 Diagramas de estados na UML .......................................................................................1099.7 Subestados ............................................................................................................................1129.8 Transições ...............................................................................................................................112
10. IMPLEMENTAÇÃO ..................................................................................... 117
10.1 Alternativas .........................................................................................................................11710.2 Interfaces baseadas em caracteres .............................................................................11710.3 Interfaces gráficas .............................................................................................................11810.4 Applets ..................................................................................................................................12010.5 Tratamento de eventos ...................................................................................................12110.6 Gerenciadores de layout ................................................................................................12210.7 Painéis ...................................................................................................................................123
11. ESTUDOS DE CASO ................................................................................... 129
11.1Especificando o programa ..............................................................................................12911.2 Programa exemplo ...........................................................................................................12911.3 Interface gráfica principal ..............................................................................................13011.4 Especificação da fonte ....................................................................................................13711.5 Outras interfaces gráficas ..............................................................................................14111.6 Acessos aos arquivos .......................................................................................................14711.7 Exceções ...............................................................................................................................149
12. FERRAMENTAS DE DESENVOLVIMENTO ................................................ 151
12.1Ambientes integrados de desenvolvimento ...........................................................15112.2 Projetos .................................................................................................................................15112.3 Edição de classes ...............................................................................................................152
7Programação Orientada a Objetos
12.4 Interfaces gráficas .............................................................................................................15212.5 Tratamento dos eventos .................................................................................................15212.6 Navegação ...........................................................................................................................15312.7 Depuração ...........................................................................................................................15312.8 Bibliotecas e documentação ........................................................................................15312.9 Ferramentas CASE ............................................................................................................15412.10 UML e CASE ......................................................................................................................15412.11 Casos de uso .....................................................................................................................15412.12 Diagramas de classes ....................................................................................................15512.13 Diagramas de sequência e de interação ................................................................15612.14 Outros diagramas e geração de código .................................................................157
EXERCÍCIOS PROPOSTOS ............................................................................... 158
BIBLIOGRAFIA ................................................................................................. 160
9Programação Orientada a Objetos
1. INTRODUÇÃO
1.1 Decomposição funcionalUma abordagem típica usada no desenvolvimento de programas complexos consiste em decom-
por os programas em diversos módulos e dividir cada módulo em diversas funções (Fig.1.01). Cada fun-ção é responsável por parte da solução do problema. Esta abordagem de desenvolvimento se baseia na decomposição funcional. Embora a decomposição funcional tenha sido amplamente utilizada nos últimos anos, apresenta algumas deficiências, tais como o fraco acoplamento entre dados e funções.
Fraco acoplamento: Cada função é responsável por parte da solução do problema. Esta abor-dagem de desenvolvimento se baseia na decomposição funcional, que, embora tenha sido amplamente utilizada nos últimos anos, apresenta algumas deficiências. Um tipo de deficiên-cia facilmente identificável é o fraco acoplamento entre os dados e as funções.
Fortemente acoplados: Em um programa desenvolvido usando-se orientação a objetos, existem facilidades para se definir quais as funções que podem acessar determinados dados. É fácil, portanto, limitar o acesso aos dados a apenas um conjunto determinado de funções. Por este motivo, diz-se que existe forte acoplamento entre dados e funções.
1.2 Orientação a objetosA orientação a objetos é uma tecnologia de desenvolvimento composta por metodologias e
linguagens usadas na análise, no projeto e na implementação de programas. Apesar de existir há décadas, só recentemente a orientação a objetos adquiriu popularidade. Em parte, esta popularidade decorre do uso crescente de interfaces gráficas e da arquitetura distribuída dos programas atuais, ca-racterísticas que são adequadamente suportadas pela orientação a objetos.
Os programas desenvolvidos usando-se a orientação a objetos são compostos por módulos cujos dados e funções são fortemente acoplados (Fig.1.02). Estes módulos são denominados “obje-
Repr
oduç
ão p
roib
ida.
Cop
yrig
ht ©
NT
Edito
ra. T
odos
os
dire
itos
rese
rvad
os.
10 NT Editora
tos” e, em cada um deles, temos dados e fun-ções. As funções são denominadas “métodos” e contêm o código responsável pelos serviços providos pelos objetos. Os dados, por sua vez, só podem ser acessados por meio do código presente nos métodos do objeto (Fig.1.03). Por isso, costuma-se dizer que os dados são encapsulados.
Considere, por exemplo, um obje-to que modela uma conta corrente em um sis-tema bancário. Por meio dos métodos, pode-se, por exemplo, depositar e sacar. Em outras palavras, os serviços depositar e sacar são providos pelos métodos usados para solicitar serviços aos objetos que modelam as contas bancárias. Além dos métodos responsáveis pelos serviços, cada objeto que mo-dela uma conta bancária contém dados, como o nome do dono da conta e o valor do saldo. Como os dados normalmente não podem ser acessados diretamente, o acesso é feito por meio dos métodos.
O forte acoplamento entre dados e código facilita o desenvol-vimento de programas modulares. A modularidade resultante facilita tanto a manutenção e a evolução dos programas quanto a reutilização de código entre programas destinados a uma mesma área de aplica-ção. A possibilidade de se desenvolver programas a partir de módulos existentes reduz o custo de desenvolvimento, sendo uma das vanta-gens da orientação a objetos.
Exercitando o conhecimento...
Leia com atenção cada uma das afirmações abaixo e identifique-as como Verdadei-ra ou Falsa.
1 – Nos módulos, estão contidos os códigos responsáveis pelos serviços providos pe-los objetos.
( ) Verdadeira
( ) Falsa
2 – Os dados só podem ser acessados através do código presente nos métodos do objeto.
Por isso, costuma-se dizer que os dados estão encapsulados.
( ) Verdadeira
( ) Falsa
Fig.1.03 – Encapsulamento dos dados
Repr
oduç
ão p
roib
ida.
Cop
yrig
ht ©
NT
Edito
ra. T
odos
os
dire
itos
rese
rvad
os.
11Programação Orientada a Objetos
Fig.1.04 – Fases do desenvolvimento
1.3 Fases de desenvolvimentoO desenvolvimento de um programa orientado a objetos é realizado em fases: análise, projeto
e implementação (Fig.1.04). A primeira fase é a análise, na qual é feita a especificação dos requisitos do programa que é descrito com base nas expectativas dos usuários. Ao final, devem ser removidas as omissões da especificação inicial e os usuários devem estar convencidos de que a especificação descreve o programa desejado. As principais atividades da análise são:
• levantar a especificação junto aos usuários;
• descrever o programa por meio de casos de uso;
• identificar objetos no domínio do problema;
• identificar, para cada objeto, suas responsabilidades;
• identificar os relacionamentos entre os objetos.
A partir do momento em que os aspectos de implementa-ção começam a influenciar os modelos, tem início a fase de proje-to. Nessa fase, os modelos definidos na análise são adaptados ao ambiente no qual o programa será implantado. Os modelos resul-tantes da fase de projeto descrevem o programa da forma como o mesmo será realmente implementado. As principais atividades do projeto são:
• identificar aspectos do ambiente de implementação e investigar as consequências de tais aspectos sobre o programa a ser implementado;
• traduzir os modelos gerados na fase de análise de forma a escreverem um programa possível de ser implantado, levando em consideração as restrições impostas pelo ambiente de implementação;
• identificar os objetos e como estes interagem.
A fase seguinte no desenvolvimento de um programa é a implementação. No caso de um programa orientado a objetos, a implementação torna-se mais simples se for usada uma linguagem de programação que suporte os conceitos presentes na orientação a objetos. Com tais linguagens, é possível mapear os conceitos usados na análise e no projeto para os códigos dos programas. Os principais conceitos que devem ser suportados são: classes (tipos de objetos), objetos, polimorfis-mo e herança. Vale salientar que a orientação a objetos é uma tecnologia. O simples uso de uma linguagem de programação adequada não é suficiente para garantir que os benefícios desta tecno-logia sejam alcançados.
1.4 Linguagens de programaçãoNo que diz respeito ao suporte à orientação a objetos, as linguagens de programação são clas-
sificadas como convencionais, baseadas em objetos ou orientadas a objetos. As linguagens conven-cionais e as baseadas em objetos não suportam integralmente os conceitos presentes na orientação a objetos. São linguagens convencionais: C, Pascal, Cobol, Fortran e Basic. São linguagens baseadas em objetos: ADA e Modula-2.
As linguagens orientadas a objetos suportam integralmente os principais conceitos presentes na orientação a objetos. Os principais conceitos suportados por tais linguagens são: classes (tipos de objetos), objetos, polimorfismo e herança. São linguagens orientadas a objetos: C++, Object Pascal, Smalltalk e Java.
Repr
oduç
ão p
roib
ida.
Cop
yrig
ht ©
NT
Edito
ra. T
odos
os
dire
itos
rese
rvad
os.
12 NT Editora
1.5 TestesAo longo do desenvolvimento de um programa orientado a objetos, é fundamental que seja
dada atenção ao planejamento e à execução dos testes a fim de se garantir a qualidade do programa. Os testes devem ser parte integrante do desenvolvimento, não devendo ser realizados apenas ao final da implementação. Os testes são geralmente classificados como: testes das unidades, testes de inte-gração e testes do sistema.
Os testes das unidades têm por objetivo testar o funcionamento individual de cada objeto e os serviços por eles providos. Os testes de integração verificam agrupamentos de obje-tos, denominados subsistemas e os testes do sistema, por fim, testam o sistema como um todo. Os testes de integração e do sistema verificam se o programa atende aos casos de uso descritos na especificação, submetendo-o a diferentes cargas de uso e analisando aspectos relativos à performance.
1.6 MetodologiasO desenvolvimento de um programa orientado a objetos pode se tornar uma tarefa mais sim-
ples se for adotada uma metodologia de desenvolvimento. As metodologias descrevem técnicas para facilitar e organizar o desenvolvimento de programas e geram, como resultado, diversos modelos. Cada modelo apresenta uma visão do sistema: visão de dados, de comportamento e da arquitetura. Os modelos apresentam um nível crescente de detalhamento dependendo da fase em que se encon-tra o desenvolvimento.
A visão de dados, representada por meio de diagramas de classes e diagramas de objetos (Fig.1.05), descreve os tipos de objetos e como estes se relacionam. A visão de comportamento, re-presentada, por exemplo, por meio de diagramas de interação (Fig.1.06), descreve o comportamento dinâmico do sistema. A visão de arquitetura descreve, por exemplo, a divisão do sistema em subsiste-mas e pode assumir diferentes formas, dependendo da metodologia utilizada (Fig.1.07).
Fig.1.06 – Diagrama de interaçãoFig.1.05 – Diagrama de classe e de objetos
Repr
oduç
ão p
roib
ida.
Cop
yrig
ht ©
NT
Edito
ra. T
odos
os
dire
itos
rese
rvad
os.
13Programação Orientada a Objetos
Fig.1.07 – Diagrama da arquitetura
As metodologias de desenvolvimento são geralmente compostas por um processo e por uma linguagem de modelagem (Fig.1.08). O processo descreve aspectos como: fases de desenvolvimento, documentos resultantes de cada fase, conselhos para a identificação dos objetos, etc. A linguagem representação dos modelos que descrevem o programa em desenvolvimento e merece destaque é a Unified Modeling Language (UML). Dentre as diversas metodologias para análise e projeto de progra-mas orientados a objetos podemos destacar:
• Object Oriented Design;
• Object Oriented Systems Analysis;
• Object Modeling Technique;
• Object Oriented Analysis;
• Hierarchical Object Oriented Design;
• Object Oriented Structured Design;
• Responsability Driven Design;
• Object Oriented Role Analysis; e
• Object Oriented Software Engineering.
As metodologias para o desenvolvimento de programas orientados a objetos apresentam di-versas similaridades, por exemplo:
• ao longo das fases de análise e projeto são mantidos integrados os dados e os comportamen-tos dos objetos;
• suportam classes, objetos e herança;
• sugerem como identificar classes e suas responsabilidades;
• sugerem como identificar características semelhantes entre classes e como agrupar classes em hierarquias;
• sugerem como identificar as interações entre objetos.
Repr
oduç
ão p
roib
ida.
Cop
yrig
ht ©
NT
Edito
ra. T
odos
os
dire
itos
rese
rvad
os.
14 NT Editora
Parabéns, você fina-lizou esta lição!
Agora responda às questões ao lado.
Exercícios
Questão 01 – Com relação à Orientação de objetos, marque a afirmativa falsa:
a) possibilita o forte acoplamento entre dados e funções;
b) é uma tecnologia que se popularizou recentemente;
c) possibilita o desenvolvimento de programas modulares;
d) não facilita a reutilização do código.
Questão 02 – A respeito dos objetos, marque a afirmativa incorreta:
a) são compostos por dados e funções;
b) funções são chamadas métodos;
c) dados podem ser acessados a partir de qualquer função;
d) métodos definem uma interface para o objeto.
Questão 03 – Dentre as alternativas abaixo, marque aquela que não é responsabilidade da fase de análise:
a) levantar a especificação junto aos usuários;
b) especificar aspectos da plataforma de implementação;
c) identificar objetos no domínio do problema;
d) identificar omissões na especificação inicial.
Questão 04 – Dentre as alternativas abaixo, marque aquela que não é responsabilidade da fase de projeto:
a) elaborar especificação inicial;
b) levar em consideração aspectos da plataforma de implementação;
c) identificar objetos que serão codificados na implementação;
d) usar os modelos definidos na fase de análise.
Questão 05 – marque a afirmativa que não indica uma característica de uma linguagem orientada a objetos:
a) suporte e herança;
b) suporte a classes e objetos;
c) suporte a polimorfismo;
d) suporte a variáveis globais.
Repr
oduç
ão p
roib
ida.
Cop
yrig
ht ©
NT
Edito
ra. T
odos
os
dire
itos
rese
rvad
os.
15Programação Orientada a Objetos
Questão 06 – marque a opção que não indica uma linguagem orientada a objetos:
a) Object Pascal;
b) Java;
c) C++;
d) C.
Questão 07 – A respeito de metodologias, marque a afirmativa falsa:
a) compostas por processos e linguagens de modelagem;
b) UML é um processo de modelagem;
c) Booch, Rumbaugh e Jacobson são famosos metodologistas;
d) existem diversas formas de metodologias de modelagem orientadas a objetos.
Questão 08 – Marque a afirmativa falsa a respeito de metodologias orientadas a objetos:
a) mantêm integrados os dados e o comportamento;
b) suportam como identificar a integração entre objetos;
c) sugere como identificar classes e agrupá-las em hierarquias;
d) usadas apenas na fase de projeto.
Questão 09 – Marque a afirmativa falsa a respeito de modularidade:
a) facilitada na orientação a objetos pelo encapsulamento;
b) reduz o tempo de desenvolvimento e facilita a manutenção;
c) nos módulos que compõem um programa orientado a objetos, dados e códigos são fracamente acoplados;
d) é possível o desenvolvimento de programas não orientados a objetos que se-jam modulares.
Questão 10 – Marque a afirmativa falsa sobre testes:
a) podem ser de unidade, de integração ou de sistema;
b) testes de unidades testam o funcionamento individual de cada objeto;
c) testes de integração testam o sistema como um todo;
d) testes de sistema verificam se o programa atende aos casos de uso especificados.
Repr
oduç
ão p
roib
ida.
Cop
yrig
ht ©
NT
Edito
ra. T
odos
os
dire
itos
rese
rvad
os.
