Ap

o
da Pro
Traduo
Joo Eduardo Nbrcga Torlcllo
Revisl10 Tcnic(l
Ana Fernanda Gomes Ascencio
a
em 21
Tony Sintes
Bacharel em Ci ncia da Computao pela pue-sp
o
Especialista cm Si stema de Infonnao pela UFSCAR c mestre cm computao pela UFROS
I

r
PEARSON
Makron
Books
So Paulo
Brasil Argentina Colmbia Costa Rica Chile Espanha
Guatemala Mxico Peru Porto Ri co Venezuela
@ 2002 by Pearson Education do Brasil
Ttulo Original:
Object Oriented Programming in 21 Di as
2002 by Sams Publi shing
Todos os direitos reservados
Editora: Gislia do Carmo Cosia
Gerente de Produo: Si las Camargo
Produtora Editorial: Sandra Cristina Pedri
Reviso: Jorge Abdalla Neto
Capa: Marcelo da Silva Franozo, sobre o projeto original
Editorao Efetr6nica: ERJ Informtica LIda.
Dados de Catalogao na Publicao
Sintes, Tony
Aprenda Programao Orientada a Objetos em 21 Dias
Traduo: Joo Eduardo Nbrega TorteUo
Reviso Tcnica: Ana Fernanda Gomes Ascencio
So Paulo: Pearson Education do Brasi l, 2002
Titulo Original: Object Oriented
Programming in 21 Dias
ISBN: 85.346.1461-X
,
Indice para Catlogo Sistemtico
1. Programao Orientada a Objelos
2002
Direitos exclusivos para a lngua portuguesa cedidos
Pearson Education do Brasi l,
uma empresa do grupo Pearson Educalion
Av. Ermano Marchetti, 1435
CEP 05038-001 - Lapa - So Paulo - SP
Tel : (11) 3613- 1222 Fax: ( 11) 3611-0444
e-mail : vendas@pearsoned.com
Sobre o autor
TONY SINTES trabalha com tecnologias orientadas a objetos h sele anos. Nesse tempo, Tony
fez parte de muitos trabal hos de desenvolvimento orientados a objetos de larga escala. Alual-
mente, Tony trabalha na Firsl Class Consult ing, uma empresa que fundou para ajudar as grandes
empresas a integrar seus diversos s istemas em uma estrutura unificada. Antes de iniciar a First
Class Consulting, Tony trabalhou na BroadVision como consultor snior, onde ajudou a cons-
truir alguns dos maiores sites Web do mundo. Atualmente, as principai s responsabilidades de
Tony so como arquiteto, lder tcnico e mentor da equipe, ajudando a construir as habilidades
em desenvolvedores menos experientes.
Tony um autor tcnico ampl amente reconhecido, cujos trabalhos tm aparecido naJavaWorld,
Dr. Dobb 's JOllrnol, LinuxWorld, JavaOne Today e Silicon Prairie, onde co-autor de uma co-
luna mensal altamente respeitada sobre programao orientada a objetos. Atuahnente, Tony es-
creve a coluna mensal de perguntas e respostas daJavaWorld. Voe pode entrar em contato com
ele no endereo styoop@flrslclasscommlling.nel.
Agradecimentos
Escrever um livro um processo como nenhum outro. A quantidade de pessoas que colaboram
em um livro, e que so necessrias para produzir a cpia final que voc est lendo agora, sim-
plesmente espantoso. Gostaria de estender minha gratido equipe inteira de editoriais da Sams.
Sem seu trabalho rduo, este li vro simplesmente no existiria.
Pel o nome, gostaria de agradecer a Michael Stephens, Carol Ackerman, Tiffany Taylore George
Nedeff. A liderana e toques sutis de Carol foram o que realmente fi zeram este li vro prosseguir
at sua concluso. A capacidade de Tiffany de estruturar e encadear o material tcnico, clara e
conci samente, simplesmente espantosa. No apenas as edies de Tiffany tornaram este livro
mai s legvel, mas acho que seu trabalho me ensi nou algumas lies valiosas sobre redao tc-
ni ca. Tambm gostaria de agradecer a William Brown. Wi ll iam entrou em contato comigo a respeito
do projeto STY oor, no incio de agosto de 2000. Confiar tal projeto a um aut or relativamente
desconhecido era arriscado e agradeo a William por me dar a chance de escrever este li vro.
Agradeo especialmente aos edi tores tcnicos, Mark Cashman e Ri chard Baldwin, que garanti-
ram que o material apresentado fosse tecnicamente bom. Agradeo a vocs pela awao tcnica.
Aos meus colegas, muito obrigado. Gostaria de estender os agradecimentos especiai s a David
Kim e Michael Hall . Eu comecei este livro enquanto estava na BroadVis ion e gostaria de agrade-
cer a David Kim por me permit ir aquel as frias de pnico, quando os prazos de entrega comea-
ram a se aproximar. Tambm gostaria de agradecer a Michael Han, por SlIas idias tcnicas e por
escrever o apndice sobre Java deste livro.
Por (ll timo, mas no menos importante, tenho o privilgio de agradecer minha maravilhosa es-
posa, Amy, por seu apoio firme, revi sl'lo e pacincia. Agradeo ainda minha ramlia e amigos,
que ofereceram seu apoio e que ouviram minhas reclamaes.
Diga-nos o que voc acha!
Como leitor deste livro, voc nosso crt ico e colaborador mais importante. Valori zamos sua
opini o e queremos saber o que estamos fazendo corretamente. o que poderamos fazer melhor,
sobre quais reas voc gostaria de nos ver publi cando e qualquer outra sugesto importante que
deseje passar para ns.
Receberemos com satisfao seus comentrios. Voc pode enviar um fax, e-mail ou escrever di-
feiamen te, para que possamos saber o que gostou ou no neste l i vro - assim como o que pode-
mos fazer para tornar nossos li vros melhores.
Por favor, entenda que no podemos ajud-l o em problemas tcnicos relacionados ao assunto
deste livro e que, devido ao grande volume de correspondncia que recebemos, no possamos
responder a todas as mensagens.
Quando voc escrever, cert ifique-se de incluir o tlul o e o autor deste livro, assi m como seu
nome e n(nnero de tele fone ou fax. Examinaremos seus comentrios cuidadosamente e os com-
partilharemos com os aulores e editores que trabalharam no livro.
Fax: (1 1) 36 11 -9686
Fone: ( 11 ) 3613- 12 13
Endereo elelrnico: clientes@makron.com.br
Endereo postal: Pearson Education do Brasi l Lida
Rua Emlio Goeldi, 747 - Lapa
So Paulo - SP - CEPo 05065-110
Sumrio
Introduo XXIII
Sobre os exemplos' .. ............ ......... .. . . ... . .. . XXI V
O que voc precisa saber para usar este livro' ... ... .... .. . .. . ..... XXIV
SEMANA 1 Definindo 00
,
Di a 1 Introduo programao orientada a objetos
3
Programai'lo orientada a objelos em um contexto histrico' . .. ..... . ....... 4
Precursores da POO .................................. ... .... ... 4
Programao orientada a objetos' . .... .................. .. . ..... . . 6
Uma estratgia de POO para software usando objetos ...... . ..... . ...... 6
O que uma classe?' ............................. ... . .. . .... .. 8
Reunindo tudo: classes e objetos' ............................... 9
Fa7..endo os objetos trabal har ' ............................. . ..... . I I
Relacionamentos de objeto ................................ . .... 13
Como a programao orientada a objetos fundamenta o passado ' ......... 14
Vantagens e objeti vos da 00 .................... ................ . . 14
Natural' ........................... . ........................ 15
Confi vel ' .................. ..... . .. . . .. .......... .. ..... 15
Reuti lizvel ' .... . ...... . ................................. 15
Manutenvel ' ......... .. . ... . ................ . ... .. . . ...... 16
Extensvel ........ . . . .. .... . . .. ... . . . .. . .. . . .. .. .. .... 16
Oportuno' ........ . . . ... . . . .. .. ..... ............... ...... . .. 16
Armadilhas ................................................... 16
Armad ilha I : pensar na POO simplesmente como uma li nguagem ... .. . . .. 17
Armadilha 2: medo da reut ili zao' . . . .. .. ........................ 17
Armadilha 3: pensar na 00 como uma soluo para tudo ' . . . . ........... 17
Armadilha 4: programao egosta' . . . . ................. . . . . . . .... 18
A prxima semana' ... . . ... . . . ... . ................... .. . ..... 18
Resumo ' . .. ....................... . . ......... .. . ..... . ..... 18
Perguntas e respostas' ...... . . . ......... . .... ................ 19
Workshop ............... ..... .......... . ..... .......... 19
Teste' ................ ' ..... .................. .. ... .. ..... 19
Exerccios ................. .... .. . .. . ................. . ..... 20
Dia 2 Encapsulamento: aprenda a manter os detalhes consigo mesmo 21
Encapsulamento: o primeiro pilar ' ................................ 22
Um exemplo de interface e implementao' ................. . . .. . . .. 24
x Aprenda Programao Orientada a Obj etos em 21 Dias
Pbli co, privado e protegido' ................................... 25
Por que voce deve encapsul ar? ....... ................... .. ..... . 25
Abstrao: aprendendo a pensar e programar de forma abstraia ' .... . ........ 26
O que abstrao? ............................................ 26
Dois exemplos de abstrao .................. ................... 27
Abslrao eficaz' ............................................. 28
Guardando seus segredos atravs da ocuhao da implementao' ........ . .. 29
Protegendo seu objeto atravs do TAO (Abslract Data Type - Tipo
Abstraio de Dados)- ...................................... . .... 30
O que um tipo? . .. . . .. .. . . . .. . . . ......................... . .. 30
Um exemplo de TAO . ........................ 33
Protegendo outros de seus segredos, atravs da ocultao da impl ementao' . 34
Um exemplo real de ocultao da implementao ................ . . . . . 36
Diviso da responsabil idade: preocupando-se com seu prpri o negcio' ....... 37
Dicas e armadilhas do encapsul amento' ........................ . . .. . . 41
Dicas e armadilhas da abstrao .. . . . . .. .. .................. . . . .. . 41
Dicas e armadi lhas do TAD .... ............. 43
Dicas da ocultao da implementao' . ........................... . 43
Como o encapsulamento atende os objet ivos da programao orientada
a objetos ................................................... 44
Advertncias ............ . ..................................... 45
ReSUI110 ........ .... . 45
Perguntas e respostas ..... . . ................................ 45
Workshop .............. . ................................. 46
Teste .. .................................... . ............ 46
Exerccios .............. . .... .. .............. .. . . . . . ..... 47
Di a 3 Encapsulamento: hora de escrever algum cdigo 49
Laboratri o I : configurando o ambiente Java' . . ................ . ...... 49
Exposio do problema' ....................... ... . ..... .. ..... 50
Laboratrio 2; classes bsicas' .... .. . . . ...... .. . . .. . . .. . ... .... .. 50
Expos io do problema' ...... . .... .. . . . .. . , .. " . .. . .... .. ..... 53
Solues e discusso' ............. .. . ............ .. .. . ....... 54
Laboratrio 3: o encapsulamento ' .. .... . .. . ................. .... . . 56
Exposio do problema ' ........................................ 57
Sol ues e discusso' ................................... .. ..... 57
Laboratrio 4: estudo de caso - os pacotes de pri mitivas Java (opcional ) ..... 62
Exposio do problema ' ........................................ 66
Sol ues e discusso .......................................... 66
Perguntas e respostas ............. . ........... . ..... .......... 67
Workshop ... . . . ......... . .................... , ... . .... 68
Teste' ................ ............ .... ..... ......... 68
Exercidos ............ . ..... . .... . .. .... .. .... .. .... ..... 69
Sumrio
Dia 4 Herana: obtendo algo para nada
7'
o que herana? . . ....... . .. . ...................... . .. . . ...... 71
Por que herana? . . . .. . ............ . .. ... . ........... . . .. ... . .. 74
" um" versus "tem um": aprendendo quando usar herana ' ...... ....... 75
Aprendendo a navegar na teia emaranhada da herana ' .. . . . .. .... .. . .... 77
Mecnica da herana ... . . ......... . . . . ............ ... . .. . .. 79
Mtodos e atributos sobrepostos' ... .. .. . .......... . ..... . . .. . . . .. 8 1
Novos mtodos e atributos . . ........... ... ..... .. . ... . . .. .. . 84
Mtodos e atributos recursivos .... .. .. . . ... .. ........ . . . . ..... 84
Tipos de herana .. . .. . ... .... . . . . ..... . ... ...... .. . . ... . . . . .. 84
Herana para impl ementao' .. ... .. . . .. ... ... . .... . . . . . . . . .... 85
Problemas da herana da implementao' .. . . . . .... .. . . . . . . . .. . .... 85
Herana para diferena' . .. .... .. . ...... . ... . . ... . ... . ........ 86
Especializao' ...... . .. .... .. . . . .. .. .... . . .. . . . .... ... . .... 87
Herana para substituio de tipo ....... .. . . ..... . . . .. ........ 90
Dicas para a herana eficaz ' .. .... .. . . . .... . . .. ... . . .... .... . .. . 92
Resurno ..... . .. . ... . . ...... . . ... . . ... .... . . . ... . ..... .. ... .. 94
Como a herana atende aos objetivos da 00 .. ... . .. . . .... ... . . ... . . .. . 94
Perguntas e respostas .. ....... . ....... . . .. . . . . . .... . . . . .. . .. . 96
Workshop . ............... . . . ............. . ..... . ..... . ...... 96
Teste' ......... . . . . ............ . . ..... ..... ..... .... .. 97
E
" ' xerclcl0s .......... . ..... . ................ . . . ...... ...... 97
Dia 5 Herana: hora de escrever algum cdigo 99
Laboratrio I: herana simples ' . . ......... .... .. ..... . ..... . ... . .. 99
Expos io do problema ' ......... ..... . ............... .. .. .. . . 100
Solues e di scusso' ... . .. . .. . ...... . .... . .. .. . . . .... . ....... 101
Laboratrio 2: usando classes abstratas para herana planejada . ... . . .. . . .. . 102
Exposio do problema' . . .. . ..... . . .... .. .. .. . ...... .. . .. . .... 105
Solues e di scusso' ......................... . . ..... . . .. . . . . . 105
Laboratrio 3: conta em banco - praticando a herana simples' . .. . ....... 107
Urna conta genrica . ...... . . . .. .. ..... . ........ . . . .... . .. . .. 107
A cont a poupana' ... . . . ........... . . .. . .. . .. .. . . .... .. . .... 107
Urna conta com vencimento programado' . .. .. .. .. .. . .. . . . . .... . . 107
Conta com cheques' . . . . . . . .. . ..... .. .. .. . . . ..... . .... . . .. ... 107
Conta com cheque especial ' . . . . . . . ........ . . . . . ... . . . . . . .. .... 108
Exposio do problema' . .. . ..... . . .. .... . . . . . .. . . . . ... .. 108
Expos io estendida do problema' ...... . ..... . . . .. . ............. 110
Sol ues e discusso' .... . . . ..... . ................. . .... . ..... I I I
Laboratrio 4: estudo de caso - " um", "tem um" e j ava.uti l.Stack .... .... 1 17
Expos io do problema .. . ... . .. . ................. . ........... I 18
Solues e discusso' . ... . .. . ........ . ... ............. . . . . . . . . I 18
ResUlllo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1 19
Pergurllas e respostas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . I 19
XII Aprenda Programao Ori entada a Obj etos em 21 Dias
Workshop' ...... . .. . . . .. . . .. . . . . . .. ....
Teste' ....... ..................... . . . .. . .. . . ........
E
.'
xerCIClOS ..................... . ........................
Dia 6 Polimorfismo: aprendendo a prever o futuro
120
120
120
121
Polinl orfi smo ....................... ....... . .. .. . . .. .. . ..... 122
Polimorfismo de incl uso' ....... . .......... o 126
Polimorfi smo paramtrico' .. . . .. . . ..... . .............. . ........ 13 1
Mtodos paramtricos' .................................... 131
Tipos paramtri cos ' . .. . . .. . ....... ............... .. .. . . . . 133
Sobreposio ............... .... ... . . . .... .... . .. .... 134
Sobrecarga' . . .. . . . .. .... .. . . .... . ... .. . . .. .... . . .. . . .. . . 135
Converso' .. . . . .. .... .... . .. .. .. ... .. .. .. . . . . . . ... . . . . 137
Poli morfis mo eficaz' . .. ..................... . .. . ............ . . . 137
Armadi lhas polimrficas ' . . .. .. . . . . . ........................ .. . . . 139
Armadilha I : mover comportamentos para cima na hi erarquia' ...... .. . . . 140
Armadil ha 2: sobrecarga de desempenho ' ..................... . .... 140
Armadil ha 3: vendas 141
Advertncias' ........ . . . .. .... .. . . . .. . .. . .. . .. .. .. . . .. . .. .... 142
Como o polimorfismo atende os objcti vos
da 00 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
ResunlO ..................................................
Perguntas e respostas .... . . .. . ..............................
Workshop' ............ . ..... . ..................... . . . . ....
Teste' .... ......... . .. .... .. .............. . . .... .. . . . ....
E
. '
xerCICIOS ............ . . . .. . ............ . . . . ..... . ......
142
143
144
145
145
145
Dia 7 Polimorfis mo: hora de escrever algum cdigo 147
Laboratri o \: apli cando poli morfismo' .. .... . ... . . .. . . .. . . .. . . . . . 147
Exposio do problema ............... . .... .. .. . .............. 154
Solues e discusso' .. . . .. . . . .... ................... ... .. . . . . 155
Laboratrio 2: conta de banco - aplicando polimorfismo em um exemplo
conhecido' . . .................................... . .. . . .. ...... 156
Expos io do problema' . .. .. . . .. .. ................. ...... .. . . . 157
Solues e discusso' ....... . ................................. 159
Laboratrio 3: conta de banco - usando polimorfismo para escrever cdigo
prova do fut uro' .... . . . .. .. .... . .... .. ....................... 160
Exposio do problema ' ....................................... 162
Sol ues e discusso" ........................................ 163
Laboratrio 4: estudo de caso - estruturas condicionais Java e pol imorfismo' 165
Corri gindo uma estrutura condicional ............................. 167
Exposio do problema ' .. . .................................... 169
Solues e discusso' .... . .... . ..... .. .. ... . .. . .. ... .. .. ... 17 1
Res Ulll o ..... ............... . . . .. .. . . . . . .. . .. . . ..... ...... 172
Sumrio
XIII I
Perguntas e respostas .... . . . . . .. .. . .. ... . . . .... .. .... ... ... 173
Workshop' ...... ....... . .. . . .. . .... . . .. . .. . . ........ 173
Teste 173
Exerccios ........ .... .. . ............................. 173
SEMANA 1 Em reviso 174
SEMANA 2 Aprendendo a aplicar 00 175
Dia 8 Introduo UML 177
Introduo Unified Modeling Language ...... .. .. .... ..... . ........ 177
Modelando suas classes .. . . .. . . . .. . ........................ . . 179
Notao bs ica de classe' .............. . .. . . .. ........ ........ 179
Notao avanada de classe . . . . .. . ........................ .. . . . 181
Modelando suas classes de acordo com seus objeti vos .... . . . .. ... . . 18 1
Modelando um re lacionamento de classe' ......... . ..... .. .. .. , .. . ... 183
Dependncia' . ... .. . . . .. .. . . .. .. .................. .. ..... . . 183
Associao' ....... .......... . . .. . . .. .. . .............. . . 184
Agregao ' .................. ... ...... .... .. .. ....... 186
Conl pos iO ........ . .... . .................. .. ....... 187
General izao' ............ . . .. .. ............. . .. . .. . .... 188
Reun indo tudo ......... . .... ... .. .. . ... . . . .. ... .. .. . . .... 189
ResUlll o ............. ..... . .... .. . . .. ... .... . . . .. . . . . . .... 190
Perguntas e respostas ..... .. . . . . .... . . . . . . ..... . ..... . ....... 191
Workshop' ............ .. ... . ...........................
Teste ' ................. . .. . ..... . .......................
E
,.
xerCICIOS ...... . ....... . ......................... .. .. . ...
191
191
192
Dia 9 Introduo AOO (Anlise Orientada a Objetosl 193
O processo de desenvolvimento de software " ..................... . . . . 194
O processo it erativo ' .... .. . .... .. . . ...... ............ ..... . . 195
Uma metodologia de alto nvel ' ......................... . . . . .... 197
AOO (Anli se Orientada a Objetos)- .. .. . .. ................ . . . .... . . 198
Usando casos de estudo para descobrir o li SO do sistema ' . .... . . . . ...... 199
Cri e uma lista preliminar de casos de uso ................ . . .. ...... 20 I
Construindo o modelo de domnio' . . .................. .... ...... 2 13
E agora?' .. ... ...... ................. ........ .... .......... 2 14
Resull'o ............ . . . ................................... 2 15
Perguntas e respostas ......... ... . . ............. . ... .. ..... 2 16
Workshop' ............. . . . . .. . .... ..... . .... .. . . . .. ...... 2 16
Teste 2 16
Exerccios ............ .. ................................. 2 17
Dia 10 Introduo ao POO (Projeto Orientado a Objetos) 219
POO (Projeto Orient ado a Objelos)' ............... . .. .. . . . .. ..... 220
XIV Aprenda Programao Orientada a Obj etos em 21 Dias
Como voc apl ica roo (Projeto Orientado a Objeto)?' . . .. .. . . .. .. ...... 221
Passo I: gere uma lista inicial de objetos ............ .. . . ......... 222
Passo 2: refi ne as responsabilidades de seus objetos ......... ......... 223
Passo 3: desenvolva os pontos de imerao ....................... 231
Passo 4: detal he os relacionamentos entre os objelos ........ . ...... . .. 232
Passo 5: construa seu modelo .. . .................... .. . . ..... 233
ReSUlll O .......... . ............................. . . . . ... 234
Perguntas e respostas ... . .... . ... . . . .. .. .. .. . ... . .... . . ..... 234
Workshop' .. .. . . ..... . . .. . . . . .. . . . . ... . . . . .. ..... ......... 235
Teste' ........... .. . . .. . .... . ....................... . . . . 235
Exerccios ...................... . .. . ..................... 236
Dia 11 Reutilizando projetas atravs de padres de projeto 237
Reutili zao de projeto' ....................... .. .. ........... . . . 238
Padres de proj eto . . .. . . . .. ..... . . ...................... .. . . . 238
O nome do padro' . ... .. .. . .. . .. . . .. .. . ..... . ..... ... .. . . . 239
O problelna ........... ... . ...... ..... . .... .... ... .. ....... 239
A soluo' ... .... . . . . .. . . . . ....... . . . .. .. . . .. . ... ....... 239
As conseqUncias' .. . . . . . . . . ... . . . .. . ... .. . .. . . .. . . .. . .. .... 239
Realidades do padro' ...... . . .. . ... . . . . . . ... ... .. .. . . .. ....... 240
Padres por exemplo' .......... .. .. .. ... .. .... .. .... . ....... 240
O padro Adapter' .... . ..... . .............. . .... . ....... 24 1
O padro Proxy ........ . ........................ . .... . .. 245
O padro Iterator ........... . .... .. .. . . .. ....... . ... ..... 247
Apossando-se de um padro ' .... . . .... . ..... . .. . .. . . . .. . . . .... 254
ReSUlno ....... . .. . .. . .. . . . . . .. . . .. .. . . . .. . . . ..... . ...... 255
Pergunt as e respostas ........... . .... .. ..... .. .... . .... . ...... 255
Workshop' ..... . ..... ... .............................. . . . . 256
Teste' ................ .. . . . . ...... ..................... 256
E
" xerclclos ................. . . . ... ... ... .. ..... . .. . . . . ...... 256
Respostas do teste ' . . .. .... .. . . . .. . . . . . .... . ..... . . . . . . .. . . . . 259
Respostas dos exerccios ' ..... . . . ... ... ... ... ... .. .. . . . . . . ...... 260
Dia 12 Padres avanados de projeto 263
Mais padres por exemplo' .. . .. . ............ . .. . . .. ..... .. ..... 263
O padro Abst racl Factol)' 264
O padro Singleton ' . . . . .. . .. . ... ... .... . .. . . . . . . . .. . ..... 269
O padro Typesafe Enum ..... .. . ..... .. . .. . ..... . . . ... .. .... 275
Armadilhas do padro' ..................................... 280
Resumo' ................ ........ ...... . ............... 281
Perguntas e respostas ..... ................ . ..... . .... .. ..... 28 1
Workshop' .............. . ................. . . . .. . . .. ..... 282
Teste ' ............. .. . . . . . . ... ... . . . ... . .. . .. ... .. .. .... 282
Exercfcios ..... . . . . . . ... . . . . . . .. . . . . . .. . .. . . ..... . . .. .. 282
Sumrio
Respostas do teste' .......... , , ........... . . . . . .... .... .. ...... 284
Respostas dos exerccios' ..................... .. .. .. . . ......... 285
Dia 13 00 e programao da interface com o usurio
289
POO e a interface com o usurio' ........................... .. ..... 289
A importncia das Uls desacopladas .......................... . ..... 290
Como desacoplar a UI usando o padro Model View Controll er ... ......... 293
o Inodelo' ............ ........ ... . ......................... 294
o modo de visualizao' ...................................... 297
O controlador ' .... . .. . . .. . .............................. 30 I
Problemas com o MVC ....... . ............ . ..... 303
Uma nfase nos dados' . . .. . . . .... . ... .. . . .. .. . . ... . . . . . . 304
Acoplamento fort e' . .... .... . .. .. . . . . .. . . .. . . ... . .. . . . . 304
Ineficincia' ............. .. .. .. .. .... . ... .. .. ........... ... 305
Resumo ' ...... . . . .. . . . ... .... ......................... . . . . 305
Perguntas e respostas .. ... .. .. . .. . .. . . .. .. . ................... 305
Workshop' .............. ......... ........... . ......... ... .. 306
Teste' ....... ... . .. . .. . .. . ..... . ...... . .... .. . ... ....... 307
Exerccios ................................ .. .... . . .. . .. .... 307
Dia 14 Construindo software confivel atravs de testes 313
Testando software 00314
Testes e o processo de desenvolvi mento de software iterat ivo' .... .. . . .... 3 14
Fonnas de teste' ...................................... . . . . .... 3 17
Teste de unidade ................................ .... . ...... 317
Teste de integrao' .............. .. .... .. ......... . ....... 3 18
Teste de sistema ' . . .... .. .......................... .. .. .... 318
Teste de regresso ... .................. ................... 3 19
Um guia para escrever cdigo confivel ' ..... . .. ... .... . .... . . .... 3 19
Combinando desenvolvimento e teste' .... .... . .. . . . ... .. . . . . . 3 19
Escrevendo cdigo excepcional ' .. . .. . . .. .. .. . . . .. . . . . .. ..... 335
Escrevendo documentao eficaz' ............ .. ................. 336
Resumo ' ........ . .. . . .. .... . ............................ . . 339
Perguntas e respostas .......... . .. . .......................... 339
Workshop' ....................... . ........................ 340
Teste 341
Exerccios .... ...... . ... . .. ... .. .... . . . . .. ... .... .. ..... 341
SEMANA 2 Em reviso
342
SEMANA 3 Reunindo tudo: um projeto 00 completo 345
Dia 15 Aprendendo a combinar teoria e processo 347
Jogo Vinle-e-um' .................... . ...... . .... . ... . ... .... 347
Por qu vi nte-c-um? ................... - .... . . .. . . ... ...... 348
XVI Aprenda Programao Ori entada a Obj etos em 21 Dias
Ded arao da viso' ............ .. .. . . ... . . . .... . . .. .. ...... 348
Requis itos de sobreposio ' ....... . .... . . .. .. .. . . ......... 349
Anlise inicial do jogo vinte-e-um ..................... .. ......... 349
As regras do jogo vinte-e-um ............ ..................... 350
Criando uma lista preliminar de casos de uso' .......... .. .......... 353
Plancjando as iteraes ' ......... . ................ . .. ..... ..... 353
Iterao I : jogo bsico' .................... ... .. . . .... . . .. .. 354
Iterao 2: regras' ... ................ . . .. . ... . .. .. . . ... .. 355
Iterao 3: aposta' ................. . .. . . . .. . ..... .... . . ... 355
Iterao 4: interrace com o usurio ' . ..................... . . . . 355
Iterao 1: jogo bs ico ......................................... 356
Anlise do jogo vinte-e-um' . . . . ......................... . . . . 356
Projeto do jogo vinte-e-um .. . . . .... . .. . .. . ... . ... . ... . . 360
A implementao' ............ . .. . .. . . .. .. .. . .. . .. ... ..... 365
Resumo ' ........... . . .. . .. . . .... . .. . .. . . .. . . . .. ...... . . 380
Perguntas e respostas .. . . . . .. . . .. . .............. . ....... ..... 381
Workshop' ................. - ............................. 381
Teste' ............. . .. . . - - ..... - ..... . ........... .... .... 381
Exerccios ................................... . ........ . .... 381
Dia 16 Iterao 2 do jogo vinte-e-um: adicionando regras 383
Regras do jogo vinte-e-um ..................................... 383
Anlise das regras' ...... ..... ........................ . - ...... 384
Projeto das regras' .......... . .................... ... ..... 388
Implementao das regras' .... . . ... -o . 395
Teste' ......... . .. .......... .. . .... .. .. ... ..... . ...... 409
ResUlno .......................... .. ................ . ...... 409
Perguntas e respostas ... .... ... ...... .................... . ... 410
Workshop' ............... . .......... ..................... 4 10
Teste 4 11
Exerccios ... . . . .. .. .... . . . .. .. ............ . . .. . . ... ....... 4 1 I
Dia 17 Iterao3dojogo vinte-e-um: adicionando aposta 413
Aposta no jogo vinte-c-um . .. .. . . .. .. . . . .. .. . ............ ....... 413
Anlise da aposta' ...... ........ ................ . ........... 4 14
Projeto da aposta .................. . ....... . . . ... . . . ...... 4 17
Impl ementao da aposta .. . ..... . ...... . . .. . .. . . . . .. . ..... 420
A implementao de Bank (Banco) ......... . .. ... ... ........... 421
Um pequeno teste: um objeto falsificado' ....................... 427
Resumo ' ..................... .... ....................... 428
Perguntas e respostas .......................................... 429
Workshop' .............. ..... ............. . . ... ... ...... 429
Teste' ..... ........ .. . . . . . . ... . . . ... . . . . .. . .. .. . .. ...... 429
Exercicios .... . . . . . . . ... ... . .. .. . . . . . .... . . . .. .. . ...... 429
Sumrio
XVII I
Dia 18 Iterao 4 do jogo vinte-e-um: adicionando uma GUI 431
Apresentao do jogo vinte-e- um' ....................... . ........ 431
Oti mizacs da linha de comando ...... ..... . ........... ......... 432
Anlise da GUI do jogo vi nte-e-um ' .................... o 433
Casos de uso da GUI .... ...... ........ . . . .. . . . . .. ... . .. . . 433
Modelos visuais de GUI .. ...... ..... .. .. .. .. . .. .. .. ..... 436
Projeto da GUI do jogo vinte-e-um 437
Cartes CRC da GUI ...................................... 437
Estnltura da GUI 438
Refazendo' .. . .................................. .... . . . . . 439
Diagrama de classes da GUI . . .... . ... ....... . ... . .. o 440
Implementao da GUI do jogo vinte-e-um . . ..... ... ... . . . . ..... 440
Implement ando YCard, YDeck c CardVicw .. ......... . .. . . . ... . . . . 440
Implementando Pl ayerVicw' .. . . .. . ..... . ...................... 444
Implementando Opt ionYicw e OptionViewCont roll er' ....... .. ... .. . . 445
Implementando GUIPlayer . .. . . .. . .. . ................. . ....... 445
Reunindo ludo com BlackjackGUI 448
Resurl10 ...... ..... . .. . .. . ......... .. . . . . .. . . . .. .... ... .. 449
Perguntas e respostas .... ........ . .... . . .. . . .. . .. . . . . ..... 450
Workshop' ............ . . . ... . . .. ......... .. . ............. 450
Teste' .......... .. ........................... . ....... 450
E
. .
' XCrcICIOS .............. .......... ...... . ............. 451
Dia 19 Aplica ndo uma alternativa ao MVC
453
Uma GUI alternativa do jogo vinte-e-um 453
As camadas do PAC .... ... ....................... .. .. .. .. 454
A filosofia do PAC , .... ... . .. . ............................. 454
Quando usar o padro de projeto PAC ............................ 455
Analisando a GUI PAC do jogo vinte-c-um .... ................ .... . . . 455
Projetando a GUI PAC do jogo vinte-e-um ................. . . . ...... 455
Identificando os componentes da camada de apresentao' .... . . . . .. . . . . 456
Projetando os componentes da camada de abslrao' ................. 457
Projetando ri camada de controle' ............................... 458
Usando o padro Faclory para evi tar erros comuns' ..... ..... . .... . . 458
Implementando a GUI PAC do jogo vinte-e-um' .... . ..... . .......... 460
Implementando YCard e VHand ................. . .. ... ... . .... 460
Implementando VBettingPlayer ................ . . . .. . ..... 462
Implementando VBlackj ackDealer' ...... . ..................... 464
Implementando GUIPlayer ................... .... ......... 465
Reunindo tudo com O Controle' .................. ..... . .... 465
Resurl10 ...................................... .. ..... . ..... 468
Perguntas e respostas .. .... ...... ..... ..... . . . . . .. . . .. . .. . .. 468
Workshop' ............ . .... . . . .... .. ... ... ... . .. ... .. . ..... 468
XVII I Aprenda Programao Ori entada a Objetos em 21 Dias
Teste ' ....... , , .. , . , ... , , , ... .. .. . .... . . . .... .. .. .. . ..... 468
Exercicios .......... ........... .... . . .. .. .. . . ......... 469
Dia 20 Oivertindo-se com o jogo vinte-e-um 471
Di vertindo-se com O polimorfismo" ............. .... . .... ....... 471
Criando um jogador ................ . .. . ... . .. .. . .. .. . ..... 471
O jogador seguro' .............. .. . .. .. .... .. . ........... 472
Adicionando SafePlayer na GUI ...................... . ........ 472
Aperfeioamento' ........................................ 473
POO e simul aes' .. . . ............... ................... . . .. 474
Os jogadores do jogo vinte-c-um ' .... .. .. . . . ............ . ..... 474
Resurno .... .... . ............ .... . ... .. . . .. ... . . . .. . . .... 479
Perguntas e respostas .. .... .. . . . ....... . .. .. .. . . . . .... . . . . 480
Workshop' ......... .... . .. .. .... . ..... . ..................... 480
Teste' ...... . . . .. . . . ... . . . .......... ............... ..... 480
Exerccios ..... ......... . . .. . .......................... 480
Dia 21 O ltimo quilmetro 483
Amarrando as pontas ....... . ..... . ............................. 483
Refazendo o projeto do jogo vinte-eum para reut ili zao em outros
sistcnl as ............ .............. ......................... 484
Identificando as vantagens que a Poo tTouxe para o sistema do jogo
vi nteeum ................................................. 489
Rea li dades do setor e POO ..................................... 491
Resulllo .................... . . .. .. . ..... .... . ...... . ...... 49 1
Perguntas e respostas . ..... ...... ......................... . 491
Workshop' ............ . .................................. 492
Teste' ...... . .. .. . ... .. .. ...................... .. . .... 492
Exerccios .... . .. .... .. . ............ . . .. .. .. .... ....... 492
SEMANA 3 Em reviso 493
Apndices
495
Apndice A Respostas 497
Dia 1 Respostas do teste ' . . ................. .. .. . . ...... .... .. . . 497
Respostas do teste' ............. . .......................... 497
Dia 2 Respostas do teste e dos exerccios' ......................... 499
Respostas do teste' ......................................... 499
Respostas dos exerccios' .......................... . ... ..... 50 I
Dia 3 Respostas do teste e dos exerccios' ...... .. . ... . . ... .. ....... 50 1
Respostas do teste' .. .... ....... ........ ... . . .... ............ 50 I
Respostas dos exercicios' .................................... 503
Dia 4 Respostas do teste e dos exerccios' ....................... . .. 505
Respostas do teste' ...... . .... . ............................. 505
Sumrio
Respostas dos exercicios' .... . .. . ... . .. .. . . . ..... . .......... 507
Dia 5 Respostas do teste' . . .............. . . .. .. .. . . ......... 508
Respostas do teste' ............... . ..... . ................... 508
Dia 6 Respostas do teste e dos exerccios' ......................... 508
Respostas do teste' ...... .. ......... . ... . .................... 508
Respostas dos exercicios' ...... . ................... .. .. . ..... 5 10
Dia 7 Respostas do teste' .............. .. . .. ... . . . .. . .. . . . ... 511
Respostas do leste' ... . .... . .. . ..... . .. . .. . ... . .. .. . .. ..... 51 1
Dia 8 Respostas do teste e dos cxerccios' .... . .... . . . .. ..... ... .. . ... 512
Respostas do teste' .. .. . . .. . .... . ...................... . . . . 512
Respostas dos exerccios' ........... . .. . . . ................... 5 13
Dia 9 Respostas do teste e dos exerccios' ..... . ... .. .. ... . .. .. . . . . 515
Respostas do teste' .. .... .. . . . ......... .. . ... .. . . . . . . . . 5 15
Respostas dos exerccios' .............. . .. . . . .. . . .. .. ... .. . . . 5 17
Dia 10 Respostas do teste e dos exerccios' .... .. . .. . ... . . .... . . 5 17
Respostas do teste' .. . . . .. .. .... . .......... .... . . ...... ...... 5 17
Respostas dos exerccios' . ......... ........... ... ........... 5 19
Dia I I Respostas do teste e dos exerccios ' .. . ............ .. .. . .... 520
Respostas do teste' ............................ .. .... . ... . .... 520
Respostas dos exerccios' ............... . . .. . . . .. . . . . . . . . ..... 521
Dia 12 Respostas do teste e dos exerccios .... .. . . . . ... . .. .. . . . ..... 523
Respostas do testc' .................... . . .. ..... . ..... . ....... 523
Respostas dos exerccios' . . .. . ............................. 524
Dia 13 Respostas do teste e dos exerccios . . ..................... 528
Respostas do teste' . ....... ...... ......... . ..... .. ... . . ...... 528
Respostas dos exerccios' ... . .. . .. . .. . ....... . .. .. . .. . . ..... 529
Dia 14 Respostas do teste e dos exerccios' .... . . . ... . . . . .. . . ...... 53 1
Respostas do teste' . . .. .... .. .......... ... .. .. . . ..... . .. . . .. 53 1
Respostas dos exerccios' . .. . .... .. . . .. . ... . .. .... . ......... .. 532
Dia 15 Respostas do teste e dos exerccios' . .. . .. . .. ................ 533
Respostas do teste' .. .. ... .. . . ....... ............... ......... 533
Respostas dos exerccios' ... . . . ...... . .. .. .. ..... . ... . . . ...... 533
Dia 16 Respostas do leste e dos exerccios' .... . . . . . . . . . ... . . . .... ... 534
Respostas do teste' .. . . . .. .. . .. . .. ..... . .. . . . . . . . . .. . . .... . . . 534
Respostas dos exerccios' . .... .............. . .. . . .. ........... 534
Dia 17 Respostas do teste e dos exerccos ' .. . .............. ....... 536
Respostas do teste' .... . ........ . .... . .................... 536
Respostas dos exerccios' ................... . ..... . .... .. ..... 536
Dia 18 Respostas do teste e dos exerccios ' ....... . . . .... .... . .... 540
Respostas do teste' ...... . .......... . .... . . . . ... .... , .... 540
Respostas dos exerccios' .................. . .... .. ..... . ..... 540
Dia 19 Respostas do teste e dos exerccios' . . ...... , ........... ..... 543
Respostas do teste' ....... . ................ . ..... . .......... 543
xx Aprenda Programao Ori entada a Objetos em 21 Dias
Respostas dos exercicios' .................. . . . .... . . ... . ...... 544
Dia 20 Respostas do teste e dos exerccios' .... . .. .. .. . . ......... 548
Respostas do leste' ............... . .............. .. ......... 548
Respostas dos exerccios' ................................... 548
Dia 2 1 Respostas do teste e dos exerccios' . . ... . .......... . ...... . .. 553
Respostas do leste' ........... . ..... . ............. .. .. . ..... 553
Respostas dos exerccios' ............... . . ... . . . . .... . . . ... 554
Apndice B Resumo do Java 555
O Java Developer's Kit: J2SE 1.3 SDK ............ . . . . . ... ... .. . . .. 555
Configurao do ambiente de desenvolvimento' ............... . . . . 556
Panorama das felTamentas do SDK ..... . . .. . .... .. .. . .......... ... 557
Compil ador Java: javac' .... . . . .. . .............. . .... ... .. . . . . 557
Int erpretador Java: java ' .. . .. . . .. .. . . .. . . .. ........... . . . .. . . 558
Uti li trio de compactao de arqui vos Java: jar . . . .. .... ... . . .... . 558
Documentao Java e o gerador de documentao: javadoc .... .. ... .. . . 559
Cercadinho Java: seu primeiro programa Java .. .... . ............... . . 560
Compi lando e executando ' ..................................... 561
Cri ando um arqui vo .jar . .... . .......... . . ............... ... 562
Gerando j avadoc' ........... . .... ...... . ..... . .. . .. . ....... 563
Mecnica da li nguagem Java' ... . .. .. . . .... . . .. .. .. . . . . . . .. ... 564
Classe Java simples ........ .... .. .. . .. .... . . ..... . .. ..... 564
Ti po de Dados ............ . .... . . ..... ..... . ..... . ....... 565
Variveis' ...... . .... . ... . .......................... . 566
Constantes ............ . ... . .. .. . . .. . ............ ....... 568
Operadores' .. . .. . ....... .. ................. .. .... . .. . ... 568
Est ruturas condi cionais' . .. . . ..... . .. . . . ............... . .. . . . 570
Laos ou estruturas de repetio" . .. . .. . . .... .. ......... . ...... 57 1
Classes e interfaces - blocos de construo da linguagem Java ' .... . .. . . . . 57 1
Usando classes j ex istentes' . . .. . .. . . .. . .... .. ................ 572
Cri ando suas prprias classes ....... ............... . .. . .. . ...... 572
Int erfaces' . .... . .. . . .. . .. . .. . .... ...... . ............ . .. ... . 575
Classes internas e classes internas anni mas' .... . . .... . .... . .. , .... 577
Resulno ... . .. . .. . ........ .. ....... . .. . .. . .. . . . ... . . . . .... . . 579
Apndice C Referncia da UML 581
Referncia da UM L ............ . ... . . . .... . . ........... . .... . 581
Classes' .............. . .... . .......... .... ................ 581
Objeto ............... ..... . ...... .. . . . ............... 581
Visibilidade " ......... . ............... . ..... . .... .. ..... 581
Classes e mtodos abstralOs ' .... .. .............. . . .. .. .. . .... 582
Notas ...................... . . .. .. ... . ... . .. . . ... . . . .. .... 582
Esteretipos ' ............ . .... . .. ... . . . .... .... .. ... . .... . 583
Relacionamentos ' .... . . . .. ........... . ... . . . .. . . .. ..... . ..... 583
Sumrio
Dependncia ..... .... . . . . .. . . ..... .. ... .... .. . . . ... ... 583
Associao ' ...... . . . .. .. . . .. . .... . . . .. .. .. . . ......... 584
Papis' ...... ... . . ..... . ............... .. ..... ... ... ... 584
Multipl icidade ........... . .......... ................... 584
Agregao ........... ..... ... . ... . .................... 585
COlnposio ........... ...... ... .. .......... . .. ..... ..... 585
General izao' ................... .... ... . . .. .... . . .. .. 585
Diagramas de inlerao' ...... . .. . . . . ... .. .. . ... . .... . . ... .. 586
Diagramas de colaborao ............ . . .. . . .. .. . . ... .... . . ... 586
Diagramas de seqUncia' . .. . .... .. ..................... . . . . 586
Apndice O Bibliografia selecionada
587
Anlise, projeto e metodologias' . . . .. . ....................... . . . . 587
Programal'lo com C++ . .... .. . . . .. .. . . .. .. .. . . .. .. . . .. .. . . 588
Padres de projeto ........ ............ .... . . . .. . . .. .. .. . .. ... 588
Principios e teoria geral da 00 .. . . .. .. ............ . . .. . . . .... . . 588
Teoria "Hard Core" (mas no deixe isso assust- lo!) . . ............... 588
Programallo com Java' ................... ............ ........ 589
Miscelnea ' ........... ................ ..................... 589
Snl alltalk ................... . ..... ...... . ... ................. 589
Teste' .......................................... .... ........ 589
Apndice E Listagens do cdigo do jogo vinte-e-um 591
blackjack.core ..................... ................... . ...... 592
blackjack.core.lhreaded ..... . ................ ............ . ..... . 6 19
blackjack.exe .... ......................... ........ .. ..... 62 1
blackjack. players ........ . .. . ......... ........ . ... ........ 627
blackjack. ui ........... . .. .. .... . .. . ............... ... ...... 635
...... . . . . . ... ... . . .... . . ... . .. .. .. ... ....... 636
blackjack. ui.pac ... . .. . .. .. . ... ... ... ... .. . . . .. . . . ... ....... 649
(ndice Remissivo 669
Introduo
Este livro adota uma estratgia prtica para ens inar programao orienlada a objclos (POO). Em
vez de ensinar POO em um nvel acadmico, este li vro apresenta lies e exemplos acessveis e
amigveis, para pennitir que voc comece a aplicar POO imediatamente. Em vez de tenlar ensi-
nar cada detalhe terico, este li vro destaca os assuntos que voc precisa conhecer para poder
aplicar POO em seus proj etas dirios - e no perder seu tempo se degladiando em algum debate
terico.
o objetivo deste li vro fornecer a voc uma base slida sobre programao ori entada a objelos.
Aps 21 dias, voc dever ter lima boa idia dos concei tos bs icos da POO. Usando essa base,
voc pode comear a apli car conceitos de POO em seus projetas dirios, assi m como cont inuar a
construir seus conhecimentos de 00, atravs de estudo adicional. Voc no aprender tudo a
respeito de POO em 21 dias - isso simplesmente no possvel. Entret8llto, possvel construir
uma base slida e comear com o p direito. Este livro o ajuda a fazer exatamente isso.
Dividimos este li vro em trs partes. A Semana I apresenta os trs princpios da POO (tambm
conhecidos como os trs pilares da POO). Esses trs princpios fonnam a base da teoria da orien-
tao a objetos. O entendimento desses trs princpios absolutamente fundamental para enten-
der POO. As lies da semana esto divididas entre apresentao da teoria e o fornec imento de
experincia prtica, atravs de laboratrios.
A Semana 2 apresenta o processo de desenvolvimento de software 00. Embora as lies do Ca-
ptulo I, "llllroduo programao orientada a objetos", sejam importantes, mand-lo progra-
mar sem qualquer outra instruo como dar a voc madeira, uma serra, um martelo e alguns
pregos, e dizer para construir uma casa. A Semana 2 mostra como aplicar as ferramentas apre-
sentadas nas I ies da Semana I.
A Semana 3 o conduz em um estudo de caso completo, de um jogo de cartas 00. Esse estudo
permitir que voc percorra um ciclo de desenvolvimento 00 inteiro, do incio ao fim, assi m
como prat ique a escrita de algum cd igo. Esperamos que esse estudo de caso ajude a esclarecer a
teoria da 00 e torne as coisas mai s concretas.
Tambm existem vrios apndices no final do livro. De importncia especial o "Resumo do
Java", no Apndice B, e a bibliografia selecionada, no Apndice D, O Apndice B serve como
um gui a excelente para a linguagem de programao Java. A bibliografia mostra os recursos que
voc desejar consultar, quando conti nuar seus estudos de POO. Esses recursos certamente fo-
ram valiosos para escrever este livro.
Sobre os exemplos
Todos os exemplos de cdigo-fonte foram escritos em Java. A Iguma experincia em Java ajuda-
r; entretanto, o Apndice B deve ajud-lo a ter velocidade, caso voc esteja enferrujado ou mln-
ca tenha visto a linguagem antes. Desde que voc tenha algum conhecimento de programao,
os exemplos 5<10 os mai s acess veis. Os recursos e truques especiais do Java foram particular-
mente evitados nos exemplos.
o que voc precisa saber para usar este livro
Este li vro presume alguma experincia anterior em programao e no lenta ensinar programa-
o bsica. Este livro pega o conhecimento que voc j tem e mostra como pode us-lo para es-
crever sofi ware orientado a objclos. Ou escrever software orientado a obj elos melhor. Isso no
quer dizer que voc precisa ser um guru de programao para ler e enlender este livro - um cur-
so de programao introdutrio ou simplesmente a leitura de um li vro de programao todo o
conhecimento que voc deve precisar.
Para poder tirar total proveito dos exemplos e exerccios, voc tambm precisar de um compu-
tador com acesso Internet. A escolha do ambiente operacional e do editor fi cam completamen-
te por conta de seu gosto pessoal. O nico requisi to que voc possa fazer download, instalar e
executar Java. O Apndice B o conduz pelo processo de obteno de um SDK Java.
Finalmente, voc precisa de determinao, dedicao e uma mente aberta. A programao orien-
tada a objetos no fci l e voc demorar mais de 21 dias para dominar, mas aqui voc pode ter
um incio bom e slido.
O mundo maravilhoso da roo est espera ....
SEMANA 1
Definindo 00
I Introduo programao ori entada a objetos
2 Encapsul amento: aprenda a manter os detalhes

consIgo mesmo
3 Encapsulamento: hora de escrever algum cdigo
4 Herana: obtendo algo para nada
5 Herana: hora de escrever algum cdigo
6 Polimorfismo: aprendendo a prever o fut uro
7 Polimorfismo: hora de escrever algum cdigo
Panorama
Os prximos sete dias fornecer dO a voc uma base slida sobre programao ori entada a objelos.
O Dia I descreve os fundamentos da 00 (ori entado a objetos). Voc aprende a respeito de orien-
tao a objelos a parti r de uma perspectiva histrica e v como a 00 evoluiu a partir de li ngua-
gens de programao existentes. Voc tambm aprende a termi nologia bsica, ass im como as
vantagens e armadi lhas da programao orientada a objetos.
Os dias 2, 4 e 6 apresent am os trs pitares da programao orientada a objelos: encapsulamenlo,
herana e polimOlfismo. Esses captul os no apenas expli cam os fundamentos da programao
orientada a obj elos, mas como e quando us-los, assi m como os erros a serem evitados.
Os dias 3, 5 e 7 fornecem laboratrios correspondentes a cada um dos trs pilares. Cada capitulo
de laboratrio fornece experi ncia prtica que lhe penn ite se fami liarizar-se com os pi lares apre-
sentados nos dias 2, 4 e 6.
Aps concluir a primeira semana, voc dever ter um entendiment o completo do qu constitui
um programa orientado a objetos. Voc deve poder identificar os trs pilares da 00 e aplic-los
em seu cdigo.
Testes e exerccios seguem a li o de cada dia, para ajud-lo a entender melhor os assuntos abor-
dados. As respostas de cada pergunta dos testes e exerccios aparecem no Apndice A.
SEMANA 1
DIA
Introduo programao
orientada a objetos
Embora as linguagens orientadas a objetos j existam desde a dcada de 1960, os ltimos 10
anos tm vi sto um cresci mento sem paralelo no uso e na aceitao de tecnologias de objeto, por
todo o selar de software. Embora tenham comeado como algo secundrio, slIcessos recentes,
como Java, CORBA e C++, tm impulsionado as tcnicas orientadas a objetos (00) para novos
nveis de acei tao. Isso no por acaso. Aps anos presa nos meios acadmicos e tendo de lutar
uma rdua batalha contra as prticas entrincheiradas, a programao orientada a objetos (POO)
amadureceu at o ponto onde as pessoas so finalmente capazes de perceber as promessas que a
tcnica contm. No passado, voc tinha de convencer seu chefe a permit ir o uso de uma lingua-
gem ori entada a objetos. Hoje, muitas empresas obrigam seu uso. seguro dizer que as pessoas
esto finalmente ouvindo.
Se voc est lendo este livro, fina lmente foi convencido. Provavelmente algum com um nvel
intcnnedirio de experincia em programao. Se voc conhece C. Visual Basic ou FORTRAN,
j estava nas imediaes, mas decidi u que precisa dar uma sria olhada na programao orienta-
da a objetos e torn-Ia parte de seu conjunto de habilidades.
Mesmo que voc tenha alguma experincia com uma linguagem orientada a objetos, este li vro
pode aj ud-lo a sol idificar seu entendimento de 00. Mas no entre em pnico, caso voc no
esteja fa miliarizado com uma linguagem 00. Embora este livro use Java para ensinar conceitos de
Dia 1
00, um conhecimento prvio de Java no necessrio. Se voc ficar confuso ou predsar de um
lembrete da sintaxe, basta consultar o Apndice B, " Resumo do Java".
Se voc precisa de 0 0 para se manter no mercado, termi nar seu projeto mais recent e ou satis
fazer sua prpria curi osidade, ento veio ao lugar certo. Embora nenhum livro possa ensinar
tudo que h em relao a ao, este li vro promete fornecer uma base sl ida em 00. Com essa
base, voc pode comear a praticar POO. E, mais importante, a fundamentao fornecer a
base durvel que voc precisa para continuar a aprender e, final mente, dominar esse paradig
ma de programao.
Hoj e voc aprender




Programao orientada a objetos em um contexto hi strico
A base da programao ori ent ada a objetos
As vantagens e obj eti vos da programao ori entada a obj etos
As fa lcias e armadilhas comuns associadas programao ori ent ada a objetos
Programao orientada a objetos em um
contexto histrico
Para entender o estado atual da POO. voc deve conhecer um pouco da histri a da programao.
Ningum cOllcebeu a POO da noite para o dia. Em vez disso, a POO apenas outro estgio na
evoluo natural do desenvolviment o de soft ware. Com o passar do tempo, se tomou mais fcil
identifi car as prticas que funcionam e as que comprovadamente falham. A POO combi na prti
cas comprovadas e testadas o mais efi cientemente possvel.
Novo TERMO
00 a abreviatura de orient ado a objelOs. 00 um lemlO geral que incl ui qualquer
esti lo de desenvolvi mento que seja baseado no conceito de ' objeto' - urna entidade
que exibe caractersticas e comport amentos. Voc pode aplicar uma estratgia ori entada a objetos
na programao, assim como na anlise e no projeto.
Voc tambm pode di zer que 00 um estado da mente, uma maneira de ver o mundo todo em
termos de objetos.
Simplesmente, a 00 cont m tudo que pode ser denominado como ori ent ado a objetos. Voc vai
ver o tenno 00 mui tas vezes neste livro.
Precursores da POO
Atual mente, quando usa um computador, voc tira proveito de 50 anos de refi namento. Antiga
mente, a programao era engenhosa: os programadores int roduziam OS programas diretamente
na memri a princi pal do computador, atravs de bancos de chaves (switches). Os programado--
res escreviam seus programas em linguagem binria. Tal programao cm linguagem binri a
Introduo programao orientada a objetos 5
era extremamente propensa a erros e a falta de estrutura tornou a manuteno do cdigo pratica-
mente impossvel. Alm disso. o cdigo da linguagem binria no era muito acessvel.
Quando os computadores se tomaram mais comuns, linguagens de nvel mais alto e procedurais
comearam a aparecer; a primeira foi FORTRAN. Entretanto, linguagens procedurais posterio-
res, como ALGOL, tiveram mais inOuncia sobre a 00. As linguagens procedurais permi tem ao
programador reduzir um programa em procedimentos refinados para processar dados. Esses
procedimentos refinados definem a estrutura global do programa. Chamadas seqi.lenciai s a esses
procedi mentos geram a execuo de um programa procedural. O programa termi na quando aca-
ba de chamar sua li sta de procedi mentos.
Esse paradigma apresent ou diversas melhorias em relao I inguagem binria, incluindo a adi-
o de uma estrutura de apoio: o procedimento. As funes menores no so apenas mais fceis
de ent ender, mas tambm so mai s fceis de depurar. Por outro lado, a programao procedural
limita a reutilizao de cdigo. E, com muita freqncia, os programadores produziam cdigo
de espagueti - cdigo cujo caminho de execuo se assemelhava a uma ti gela de espagueti. Fi-
nalmente, a natureza voltada aos dados da programao procedural causou alguns problemas
prprios. Corno os dados e o procedimento so separados, no existe nenhum encapsulamento
dos dados. Isso exige que cada procedimento saiba como manipularcorretamente os dados. Infe-
li zmente, um procedi mento com comportamento errneo poderia introduzi r erros se no mani-
pulasse os dados corretamente. Uma mudana na representao dos dados exigi a alteraes em
cada lugar que acessasse os dados. Assim, mesmo urna pequena alterao poderia levar a uma
cascata de alteraes, por todo o programa - em outras palavras, um pesadelo de manuteno.
A programao modular, com uma linguagem como Modula2, tenta mel horar algumas das defi -
cincias encontradas na programao procedural. A programao modular divide os programas
em vri os componentes ou mdulos constitui ntes. Ao contrrio da programao proccdural, que
separa dados e procedimentos, os mdulos combinam os dois. Um mdulo consiste em dados e
procedi mentos para manipular esses dados. Quando outras partes do programa precisam usar um
mdulo, elas simplesmente exercitam a interface do mdulo. Como os mdulos ocultam todos
os dados internos do restante do programa, fcil introduzir a idia de estado: um mdulo con-
tm informaes de estado que podem mudar a qual quer moment o.
Novo TERMO o estado de um objeto o significado combinado das variveis irllemas do objeto.
Novo TERMO Uma varivel inferna um valor mantido dentro de um objeto.
Mas a programao Ill odular sofre de duas deficincias prprias importantes. Os mdul os no
so extensveis, significando que voc no pode fazer alteraes incrementais cm um mdulo
sem abri r o cdigo a fora e fazer as alteraes diretament e. Voc tambm no pode basear um
mdul o em outro, a no ser atravs de delegao. E, embora um mdulo possa definir um ti po,
um mdulo no pode compart ilhar o tipo de oulro mdulo.
Dia 1
Nas linguagens modulares e procedurais, os dados estruturados e no estruturados tm um
' tipo'. O tipo mais facilmente pensado como o fonnalo da memria para os dados. As lingua-
gens fortemente ti padas exigem que cada objeto tenha um tipo especfico e definido. Entretanto,
os tipos no podem ser estendidos para criar outro ti po, exceto atraves de um est il o chamado
'agregao'. Por exemplo, em C, podemos ter dois tipos de dados relacionados:
typedef struct
{
'Int a;
int b;
} aBaseType;
typedef struct
{
aBaseType Base ;
i nt c;
} aDerivedType

Nesse exemplo, aDeri vedType baseado em aBaseType, mas uma est rutura de aDerivedType no
pode ser tratada di retamente como uma estrutura de aBaseType. Uma s pode fazer referncia ao
membro Base de uma estrutura aDeri vedType. Infel izmente, essa organizao lcva a cdigo que
possui muitos blocos case e if7else, pois o aplicativo deve saber como manipular cada mdulo
que encontra.
Finalmente, a programao modular tambm um hbrido procedural que ainda divide um pro-
grama em vrios procediment os. Agora, em vez de atuar em dados brutos, esses procedimentos
manipulam mdulos.
Programao orientada a objetos
A roo d o prximo passo lgico aps a programao modular, adicionando herana e polimor-
fismo ao mdulo. A roo estrutura um programa, dividindo-o em vrios objetos de alto nvel.
Cada objeto modela algum aspecto do problema que voc est tentando resolver. Escrever li stas
seqUenciais de chamadas de procedimento para dirigir o fluxo do programa no mais o foco da
programao sob a 00. Em vez disso, os objetos interagem entre si, para ori entar o fluxo global
do programa. De certa forma, um programa 00 se torna uma si mulao viva do problema que
voc est tentando resolver.
Uma estratgia de POO para software usando objetos
Imagine que voc ti vesse de desenvolver um programa 00 para implement ar um carrinho de
compras on-l ine ou um tenninal de ponto de vendas. Um programa 00 conter os objetos item,
carrinho de compras, cupom e caixa. Cada um desses obj etos vai interagir uns com os out ros
para orientar o programa. Por exemplo, quando o caixa totalizar um pedido, ele veri ficar o pre-
o de cada item.
Introduo programao orientada a objet os 7
Definir um programa em termos de objetos uma maneira profunda de ver o software. Os obje-
lOS o obrigam a ver tudo, em nvel concei tuai, do que um objeto faz: seus comportamentos. Ver
um objelo a partir do nvel concei tua i um desvio da observao de como algo feito: a imple-
mentao. Essa mentalidade o obriga a pensarem seus programas em termos nat urais e reais. Em
vez de modelar seu programa como um conj unto de procedi ment os e dados separados (termos
do mundo do computador), voc modela seu programa em objetos. Os objetos permitem que
voc modele seus programas nos substant ivos, verbos e adjet ivos do domnio de seu problema.
Novo TERMO
Novo TERMO
A implcmcnta(70 define como algo feito. Em tennos de programao, implcmcn-
la(jo o cdi go.
o dOll/inio o espao onde um problema reside. O domnio o conjunt o de conceitos
que representam os aspectos importantes do problema que voc est tent ando resolver.
Quando recua e pensa nos termos do problema que est resolvendo. voc evit a se emaranhar nos
detalhes da implementao. claro que alguns de seus objetos de alt o n vel precisaro interagir
com o computador. Entretanto, o objeto isolar essas interaes do restante do sistema. (O Dia
2, "Encapsulamento: aprenda a manter os detalhes consigo mesmo", explorar melhor essas
vantagens.)
NOTA
Em termos do carri nho de compras, ocultao de implementaosign' ica que
o cai xa no v dados brutos ao t otali zar um pedido. O caixa no sabe procurar,
em certas posies de memria, nmeros de item e outra varivel para um cu-
pom. Em vez disso, o caixa interage com objetos i tem. El e sabe perguntar
quanto custa o item.
Neste ponto, voc pode definir ohjelo fonnalmente:
Novo TERMO
Um objelo uma construo de software que encapsula estado c comportament o. Os
objetos permitem que voc modele seu software em lennos reais e abstraes.
Rigorosament e falando, um objeto urna instncia de lltna classe. A prx ima seo apresentar
o concei to de classe.
Assim como o mundo real consti tudo de objetos, da mesma forma o o software orientado a
objelos. Em uma linguagem de programao 00 pura, tudo um objeto, desde os tipos mais b-
sicos, como inteiros e lgicos, at as instncias de classe mais complexas; nem todas as li nguagens
ori entadas a objeto chegam a esse ponto. Em algumas (como o Java), primi tivas como int c fl oat,
no so tratadas como objetos.
Dia 1
o que uma classe?
Assi m como os objetos do mundo real, o mundo da POO agrupa os objelos pelos seus comporta-
mentos e atributos comuns.
A biologia classifica todos os ces, gatos, elefantes e seres humanos como mamferos. Caracle-
rislicas comparti lhadas do a essas cri aturas separadas um senso de comunidade. No mundo do soft-
ware, as classes agnlp.1.1ll objetos relacionados da mesma maneira.
Uma classe define todas as caracterst icas comuns a um ti pode objeto. Especificamente, a classe
defi ne todos os atribulos e comportamentos expostos pelo objeto. A classe define a quais men-
sagens seus objelos respondem. Quando Ulll objetoquer exercer o comportamento de outro objeto,
ele no faz isso diretamente, mas pede ao outro obj eto para que se mude, normalmente baseado em
alguma informao adicional. FreqUentemente, isso referido como 'envio de uma mensagem' .
Novo TERMO
Uma c/asse define os atributos e comportamentos comuns compartilhados por um
tipo de objelo. Os objetos de certo tipo ou classificao compartil ham os mesmos
comportamentos e atributos. As classes atuam de forma muito parecida com um cortador de mal
de ou biscoito. no sentido de que voc usa uma classe para criar ou instanciar objetos.
Novo TERMO
Atributos so as caracteristicas de uma classe visiveis externamente. A cor dos olhos
e a cor dos cabelos so exemplos de atributos.
Um objeto pode expor um at ri bul a fornecendo um link direto a alguma varivel interna ou retor-
nando o valor atravs de um mtodo.
Novo TERMO
ComporramelJ/o uma ao executada por um objeto quando passada uma mensa-
gem ou em resposta a uma mudana de estado: algo que um objeto faz.
Um objelo pode exercer o comportamenlo de outro, executando uma operao sobre esse objeto.
Voc pode ver os termos chamada de mtodo, chamada de funo ou passar lili/a mensagem,
usados em vez de executar uma operao. O que importante que cada urna dessas aes omi-
te o comportamento de um objcto.
Passagem de mensagem, operao, chamada de mtodo e chamada de fun-
o: o qu voc usa, freqentemente depende de seus conceitos anteriores.
Pensar em termos de passagem de mensagem uma maneira muito orientada
a objetos de pensar. A passagem de mensagem dinmica. Conceituai mente,
ela separa a mensagem do objeto. Tal mentalidade pode ajudar a pensar a res-
peito das interaOes entre objetos.
linguagens como C++ e Java tm heranas procedurais, onde as chamadas de
funo so estticas. Como resultado, essas tinguagens freqentemente se re-
ferem a um objeto reali zando uma chamada de mtodo a partir de outro obje-
to. Uma chamada de mtodo est fortemente acoptada ao objeto.
Este livro normalmente usar chamada de mtodo. devido sua forte ligao
com Java. Entretanto, podem existir ocasies em que o termo mensagem
usado indistintamente.
Introduo programao orientada a objetos 9
Reunindo tudo: classes e objetos
Pegue um objeto item, por exemplo. Um item tem uma descri o, id, preo unitrio, quantidade
e um desconto opcional. Um item saber calcular seu preo descamado.
No mundo da POO, voc diria que todos os objetos item so instncias da classe Item. Uma clas-
se Item poderia ser como segue:
public class Item (
private double unit_pri ce i
private double discount; Il uma porcentagem de desconto que se apl ica ao preo
private i nt quantity;
private Stri ng descr i pt i on i
private Stri ng i d;
public Item( String id , Stri ng descri ption, int quantity , doubl e price ) {
this.id id;
I
thi s.description descript i on;
if( quantity >- O ) I
this.quantily quant ity;
I
else {
l his.quantity O;
I
this.unit_price pri ce i
publi c double getAdjustedTotal() {
I
double total unit_price * quantity;
double total discount total * discount;
-
double adj usted_tot al total - total_discount;
return adjusted_total j
II apl ica uma porcentagem de desconto no preo
publ i c void setOiscount( double di scount ) I
if( dis count u 1. 00 ) {
this .discount discount;
I
else {
t his.discount 0.0;
I
I
publi C double getD1scount() t
return discount:
I
publl c int getQuantityO 1
return quantity;
I
Dia 1
public vo1d setQuantity( int quantity ) {
if( quantity >- O ) {
this.quantity z quantitYi
I
I
publ ic String getProductIDO {
return idi
I
public String getDescription() (
return descriptionj
I
I
Mtodos como
public Item( String id, String descr1ption. 1nt quantity. double pr1ce )
so chamados COI1Slr/llo r es. Os construtores inicializam um objeto durarue sua criao.
Novo TERMO
COI/Slr/IIores so mtodos usados para inicializar objctos durante sua instanciao.
Voc chama a criao de objetos de il/Slallciat7o porque ela cria uma instncia do
objeto da classe.
NOTA
No construtor e por todo o exemplo Item, voc poda notar o uso de thi s. thi s
uma referncia que aponta para a instncia do objato. Cada objato tem sua
prpria referncia para si mesmo. A instncia usa essa referncia para acessar
suas prprias variveis e mtodos.
Mtodos como setDfscountO, getDescript1onO e getAdjustedTota l O so lodos comporta-
mentos da classe I tem que retomam ou configuram atributos. Quando um caixa quer totali zar o
carrinho, ele si mplesmente pega cada item e envia ao objeto a mensagem getAdj us tedT ota 1 O .
Introduo programao orientada a objet os 11
unit_price, di scount, quantity, description e id so todas variveis internas da classe Item.
Esses valores compreendem o esladQ do objelo. O estado de um objeto pode variar com O tempo.
Por exemplo, ao fazer compras, um consumidor pode aplicar um cupom ao item. Aplicar um cu-
pom ao item mudar o estado do item, pois isso mudar o valor de discount.
Os mtodos como getAdjustedTota 10 e getoiscountO so chamados de ace:"SQres, pois eles
pennitem que voc acesse os dados internos de um objeto. O acesso pode ser direto, como no
caso de getDiscount(). Por outro lado, o objeto pode realizar processamento antes de retornar
um valor, como no caso de getAdjustedTotal O.
Novo TERMO
Os do acesso aos dados internos de um objeto. Entretanto, os (lcessores
ocultam o fato de os dados estarem em uma varivel, em uma combinao de vari-
vei s ou serem calculados. Os aces:wres permitem que voc mude ou recupere o valor e tm 'efei-
tos colaterais' sobre o estado interno.
Os mtodos como setDi scount() so chamados de l11ulanles, pois eles permitem que voc alte-
re o estado interno do objeto. Um mutante pode processar sua entrada como qui ser, antes de alte-
rar o estado interno do objeto. Pegue setD; scount () , por exemplo. setDi scount () garante que
o desconto no seja maior que 100%, antes de aplic- lo.
Novo TERMO Os 1II1I/(lI1les pennitem que voc altere o estado interno de um objeto.
Ao serem executados, seus programas usam classes como a I tem para cdar ou instanciar os obje-
tos que compem o aplicativo. Cada nova instncia uma duplicata da lt ima. Entretanto, uma
vez instanciada, a instncia transporta comportamentos e controla seu estado. Ento, o que inicia
sua vida como clone poderia se comportar de maneira mui to diferente durante sua existncia.
Por exemplo, se voc criar dois objetos item a partirda mesma classe I tem, um objeto item pode-
r ter um desconto de 10%, enquanto o segundo pode no ter descont o. Alguns itens tambm so
um pouco mais caros que outros. Um item poderia custar USS 1.000, enquanto outro poderia cus-
tar apenas US$I,98. Assim, embora o estado de um item possa variar com o passar do tempo, a
instncia ainda um objeto de Item. Considere o exemplo da biologia; um mamfero de cor cinza
to mamfero quanto outro de cor marrom.
Fazendo os objetos trabalhar
Considere o mtodo main() a seguir:
publiC static void main( String [] al"9S )
I
II cria os itens
Item mil k
,e. Item( "dairy-Oll", "I Gallon Hilk", 2, 2.50 );
Item yogurt

'e.
Item{ "dairy-032", Peach Yogurt", 4,0.68 ) ;
Item bread
00'
Item( "bakery-023" , "Sliced Bread" 1,2.55 ); ,
Item soap
,e. Item( "household-21", "6 Pack Soap , 1,4.51 ) ;
}
II aplica cupons
milk.setOiscount( 0. 15 ).
II obtm preos ajustados
Dia 1
double milk_price milk.getAdjustedTotal();
doubl e yogurt_price yogurt.getAdjustedTotal();
doubl e bread_price z bread.getAdjustedTotal().
double soap_price a soap.getAdj ustedTotal().
I I imprime recibo
System.out.println(
$ystem. out.println(
System. out.println(
System.out.print l n(
System.out.print l n(
System. out.println(
"Thank Vou For Vour Purchase." ).
"Please Come Again!" ):
milk.getOescription()
yogurt.getOescription()
bread.getOescript ion()
soap.getOescr i pt ion()
+ "\t $"
$"
$"
$"
+ "\t
+ ., \ t
+ ., \ t
II calcul a e imprime total
+ milk_pri ce
+ yogurt_price
+ bread_price
+ soap_price
double total milk_price + yogurt_price + bread_price + soap_price.
System. out.pr intln( "Total Price \t $" + total );
) ;
);
) ;
) ;
Esse mtodo mostra como poderia ser um pequeno programa que usa objetos de Item. Primeiro, o
programa instancia quatro objetos de Item. Em um programa real, ele poderia criar esses itens
quando um usuri o navegasse em um catlogo on-li ne ou quando um caixa percorre os amlazns.
Esse programa cri a vrios itens, aplica descont os e, em seguida, imprime um recibo. O programa
reali za toda a imerao do objeto enviando vrias mensagens para os itens. Por exemplo, o progra-
ma apl ica um desconto de 15% no lei te (milk), enviando a mensagem setDiscount () para o item.
O programa total iza os itens primeiro enviando a cada item a mensagem getAdjustedTotal O.
Finalmente, esse programa envia um recibo para a tela. A Figura 1.1 ilustra o exemplo de saida.
FI GURA 1.1
Imprimindo
I/m recibo.
import ante perceber que toda a programao foi feita em termos de objetos de Item e os com-
portamentos expostos pelos mtodos de I tem- os substantivos e verbos do dom nio do carri nho
de compras.
Introduo programao ori entada a objetos 13
Relacionamentos de objeto
o modo como os objetos se relacionam um componente muito importante da POO. Os objetos
podem se relacionar de duas maneiras importantes.
Primeiro, os objetos podem existi r independentemente uns dos outros. Dois objetos de Item p0-
dem aparecer no carrinho de compras si multaneamente. Se esses dois objetos separados precisa-
rem interagi r, eles interagiro passando mensagens um para o outro.
Novo TERMO
Os objetos se comunicam uns com os outros atravs de mensagens. As mensagens
fazem com que um objeto realize algo.
' Passar uma mensagem' o meSmo que chamar um mlodo para mudar o estado do objeto ou
para exercer um com port amento.
Segundo, um objeto poderia cont er outros objetos. Assim, como os objetos compem um pro-
grama em POO, eles podem compor outros objetos atravs da agregao. A partir do exemplo
Item, voc poderia notar que o objeto item contm muitos outros objetos. Por exemplo, o objeto
item tambm contm uma descri o e uma ido A descrio e a id so ambas objelos de Stri ng.
Cada um desses objetos tem uma interface que oferece mtodos e at ributos. Lembre-se de que,
na POO, tudo um objeto, mesmo as partes que compem um objclo!
A comunicao funciona da mesma maneira entre um objetoe os objetos que ele cont m. Quan-
do os objetos precisarem interagir, eles faro isso enviando mensagens uns para os outros.
As mensagens so um importante conceito de 00. Elas pennilem que os objetos permaneam
independentes. Quando um objeto envia uma mensagem para OUITO, geralmente ele no se preo-
cupa com a maneira como o objetoescol he transportar o comportamento solici tado. objeto so-
licitante se preocupa apenas que o comportamento acontea.
Voc vai aprender mais a respeito de como os objetos se relacionam, na prxima semana.
A definio de objeto est aberta ao debate. Algumas pessoas no defi nem um
objeto como uma instncia de uma classe. Em vez disso, elas definem tudo em
termos de ser um objet o: a partir desse ponto de vista, uma classe um objeto
que cri a outros objetos. Tratar uma classe como um objeto importante para
conceitos como metaclasse.
Quando este livro encontrar uma discordncia na terminol ogia, escolheremos
uma definio e ficaremos com ela. Muito freqentemente, a escolha ser
pragmtica. Aqui, opt amos por usar a definio de objeto como instncia. Essa
a definio UML (Unified Modeling Language) e a mais encontrada no set or.
(Voc vai aprender mais a respeito de UMl posteriormente.) Infelizmente, a
outra uma definio orientada a objetos mais pura. Entretanto, voc no a
encontrar muit o f reqentemente e o conceit o de metaclasse est fora dos ob-
jetivos deste livro.
Dia 1
Como a programao orientada a objetos fundamenta o
passado
Assi m como outros paradigmas lentam acent uar as vant agens e corrigir as ralhas dos paradigmas
ant eriores, a POO rundamenta a programao procedural e modular.
A programao modular est rutura um programa em vri os mdulos. Do mesmo modo, a POO
divide um programa em vrios objetos interativos. Assim como os mdulos ocultam representa-
es de dados at rs de procedi mentos, os objetos encapsul am seu estado por trs de suas interra-
ces. A POO empresta esse concei to de encapsulamento di retamente da programao modular. O
encapsul amento direre muit o da programao procedura l. A programao procedural no en-
capsul a dados. Em vez disso, os dados so abertos para todos os procedi mentos acessarem. Ao
contrrio da programao procedural , a programao orientada a obj etos acopla rort emente
dados e comport amentos ao objeto. Voc vai aprender mais a respei to do encapsulament o nos
dias2e3.
Embora os objetos sejam conceitualmente semelhantes aos mdul os, eles di rerem de vrias ma-
neiras import antes. Primeiro, os mdulos no suportam extenso pront ament e. A programao
orientada a objetos int roduz o conceito de herana para elimi nar essa deficincia. A herana per-
mite que voc estenda e mel hore suas classes raci lmenl e. A herana tambm permi te que voc
classi fi que suas classes. Voc vai aprender mais a respeito da herana no Dia 4, " Herana: ob-
tendo algo para nada" e no Dia 5, " Herana: hora de escrever algum cdigo".
A POO tambm acent ua o concei to de polimorfi smo, que aj uda a construi r programas fl exveis,
que no resistem mudana. O poli morfi smo acrescenla essa fl exibilidade limpando o sistema
de tipagem li mitado do mdulo. Voc vai aprender mais a respeito do poli morfi smo no Dia 6,
" Polimorfismo: aprendendo a prever o ruturo" e no Dia 7, " Poli morfismo: hora de escrever al-
gum cdigo".
A POO certamente no inventou o encapsul amento e o polimorfi smo. Em vez disso, a POO
combina esses conceitos em um s lugar. Pegue a noo da POO de objetos e voc reunir essas
tecnologias de uma maneira jamais rei ta.
Vantagens e objetivos da 00
A programao orient ada a objetos define seis objeti vos sobrepostos para desenvolvimento de
software. A POO se esmera em produzir software que tenha as seguintes caractersticas:
1. Natura l
2. Confivel
3. Reut ilizvel
4. Manutenvel
Introduo programao orientada a objet os 15
5. Extensvel
6. Oportunos
Vamos ver como ela funciona para atender cada um desses obj etivos.
Natural
A POO produz software natural. Os programas naturais so mais intel igveis. Em vez de progra
mar em termos de regies de memria, voc pode programar usando a terminologia de seu pro--
blema em particular. Voc no precisa se aprofundar nos detalhes do computador enquanto
projeta seu programa. Em vez de ajustar seus programas para a linguagem do mundo dos compu-
tadores, a 00 o libera para que expresse seu programa nos termos de seu problema.
A programao orientada a objetos pennite que voc modele um problema em um n vel funci o-
nal e no em nvel de implementao. Voc no precisa saber como um software funciona, para
us-lo: voc simplesmente se concentra no que ele faz.
Confivel
Para criar soft ware ti I, voc precisa criar software que seja to confivel quanto outros produ-
tos, como geladeiras e televi ses. Quando foi a ltima vez que seu microondas quebrou?
Programas orientados a objetos, bem projetados e cuidadosamente escri tos so confiveis. A na-
t ureza modular dos objetos pennile que voc faa alteraes em uma part e de seu programa, sem
afetaroutras partes. Os objetos isolam oconhecimenl o ea responsabilidade de onde pertencem.
Uma maneira de aumentar a confiabilidade atravs de testes completos. A 00 aprimora os tes-
tes, permitindo que voc isole conheci mento e responsabilidade em um nico lugar. Tal isola-
ment o pennite que voc teste e val ide cada componente independentemente. Uma vez que tenha
validado um componente, voc pode reutiliz-lo com confiana.
Reutilizvel
Um construtor inventa um novo tipo de tijolo cada vez que constri uma casa? Um engenheiro
eletricista inventa um novo tipo de resistor cada vez que projeta um circuito? Ento, por que os
programadores continuam ' reinventando a roda?' Uma vez que um problema esteja resolvido,
voc deve reutili zar a soluo.
Voc pode reutili zar prontamente classes orientadas a objetos bem feitas. Assim como os mdu-
los, voc pode reut il izar objetos em muitos programas diferentes. Ao contrri o dos mdulos, a
POO introduz a herana para penni ti r que voc estenda objetos existentes e o polimorfi smo,
para que voc possa escrever cdigo genrico.
A 00 no garante cdigo genrico. Criar classes bem feitas urna tarefa difici l que exige concen-
trao e ateno abstrao. Os programadores nem sempre acham isso fcil.
Dia 1
Atravs da POO, voc pode modelar idias gerais e usar essas idias gerais para resolver proble-
mas especficos. Embora voc v construi r objelos para resolver um problema especfico, fre-
qentemente construi r esses objetos especficos usando partes genri cas.
Manutenvel
o ciclo de vida de um programa no tennina quando voc o di stri bui. Em vez disso, voc deve
manter sua base de cdigo. Na verdade, entre 60% e 80% do tempo gasto trabalhando em um
programa para manut eno. O desenvolvi mento representa apenas 20% da equao!
Um cdigo orientado a objetos bem projetado manutenvel. Para corrigir um erro, voc sim-
pl esmente corrige o problema em um lugar. Corno uma mudana na implementao transpa-
rent e, todos os outros objetos se benefici aro aut omaticamente do aprimoramento. A linguagem
natural do cdigo deve permitir que out ros desenvolvedores tambm o ent endam.
Extensvel
Ass im como voc deve manter um programa, seus usurios exigem o acrscmo de nova funcio-
nalidade em seu sistema. Quando voc construir uma biblioteca de objetos, tambm desejar es-
tender a funcional idade de seus prpri os objetos.
A POO trata dessas real idades. O soft ware no esttico. Ele deve crescer e mudar com o passar
do tempo, para permanecer til. A POO apresenta ao programador vrios recursos para estender
cdigo. Esses recursos incluem herana, polimorfismo, sobreposio, delegao e uma varieda-
de de padres de projeto.
Oportuno
O ciclo de vida do projeto de software moderno freqentemente medido em semanas. A
POO ajuda nesses rpidos ciclos de desenvolvimento. A POO diminui o tempo do ciclo de
desenvolvimento, fornecendo software confivel, reutili zvel e facilmente extensvel.
O software nat ural simplifica o projeto de sistemas complexos. Embora voc no possa ignorara
projeto cuidadoso, o software natural pode otimizar os ciclos de projeto, pois voc pode se con-
centrar no problema que est tent ando resolvcr.
Quando voc divide um programa em vri os objetos, o desenvolvi mento de cada parte pode
ocorrer em paralelo. Vrios desenvolvedores podem trabalhar nas classes independentemente.
Tal desenvolvimento em paralelo leva a tempos de desenvolvimento menores.
Armadilhas
Quando voc aprende 00 pela primeira vez, existem quatro annadilhas que precisa evitar.
Introduo programao orientada a objetos
Armadilha 1: pensar na POO simplesmente como uma
linguagem
17
Freqentement e, as pessoas equiparam linguagens orientadas a objetoscom a poo. O erro surge
ao supor que voc est programando de maneira ori entada a obj etos si mplesment e porque usa
uma linguagem ori entada a objetos. Nada poderia estar mais distante da realidade.
A POO muito mais do que simplesmente usar uma linguagem orientada a objetos ou conhecer
ceno conjunto de definics. Voc pode escrever cdigo horrivelmente no orientado a obj etos
em uma linguagem ori entada a objetos. A verdadeira POO um estado da mente que exige que
voc veja seus problemas como um grupo de objetos e use encapsulament o, herana e polimor-
fismo corretam ente.
Infeli zmente, muitas empresas e programadores supem que, se simplesment e usarem Lima lin-
guagem orientada a objetos, se beneficiaro de todas as vantagens que a POO oferece. Quando
falham, elas tentam culpar a tecnologia e no o fato de que no trei naram seus funcionrios cor-
retamente, ou que agarraram um conceito de programao popular sem entender realmente o que
ele significava.
Armadilha 2: medo da reutilizao
Voc deve aprender a reutilizar cdigo. Aprender a reutili zar sem culpa freqUentemerlle uma
das lies mais dificeis de aprender, quando voc escolhe a POO pela primeira vez. Trs proble-
mas levam a essa dificuldade.
Primeiro, os programadores gostam de cri ar. Se voc ol har a reutilizao de modo errado, ela pa-
recer afastar algumas das alegrias da criao. Entretanto, voc precisa lembrar que est reutilizan-
do panes para criar algo maior. Pode no parecer interessante reutilizar um componente, mas isso
permi tir que voc construa algo ainda melhor.
Segundo, muitos programadores sofrem do sentimento de 'no escrit o aqui' - signi fi cando que
eles no confiam no software que no escreveram. Se um software bem testado e atende sua ne-
cessidade, voc deve reuli liz-Io. No rejeite um componente porque voc no o escreveu. Lem-
bre-se de que reutilizar um componente o liberar para escrever outro software maravilhoso.
Armadilha 3: pensar na 00 como uma soluo para tudo
Embora a POO oferea muitas vantagens, ela no a soluo para tudo no mundo da programa-
o. Existem ocasies em que voc no deve usar 00. Voc ainda precisa usar bom senso na es-
colha da ferramenta correta para o trabalho a ser feito. Mais importante, a POO no garant e o
sucesso de seu proj eto. Seu projeto no ter sucesso automaticamente, apenas porque voc usa
uma li nguagem 00. O sucesso aparece somente com planejament o, projeto e codificao cui-
dadosos.
Dia 1
Armadilha 4: programao egosta
No seja egosta quando programar. Assim como voc deve aprender a reutil izar, tambm deve
aprender a compartil har o cdigo que cri a. Compart ilhar significa que voc encoraj ar outros de-
senvolvedores a usarem suas classes. Entretanto, compart ilhar tambm signifi ca que voc toma-
r fcil para outros reutili zarem essas classes.
Lembre-se dos outros desenvolvedores quando voc programar. Faa interfaces limpas e inteli-
giveis. Mais importante, escreva a documentao. Documente suposies, parmetros de mto-
dos, documente o mximo que voc puder. As pessoas no reuti li zaro o que no podem
encontrar ou entender.
A prxima semana
Na prxima semana, voc continuar sua introduo a roo, aprendendo a respeito dos trs pi la-
res que fonnam a base da tcoria da POO: encapSlllamenlo, herana e polimorfismo.
Cada pilar ser dividido em duas lies. A primeira lio apresentar o pi lar e a teoria subjacen-
te. A segunda lio fornecer experincia prt ica com os conceitos apresentados no dia anterior.
Essa estratgia espelha a estratgia de preleo/laborat ri o, usada com sucesso por mui tas uni-
versidades e escolas.
Voc completar todos esses laboratrios usando a linguagem de programao Java da Sun Mi
crosystem. Voc pode obter gratui tamente todas as ferramentas usadas neste livro, atravs da
World Wide Web. O Dia 3, assi m como o Apndice B, " Resumo do Java", no fi nal do livro, o
conduziro na obteno e configurao de seu ambiente de desenvolvi mento.
NOTA
Resumo
Por que Java 7
Exi stem dois motivos para se usar Java como fer ramenta de ensino. Primei ro,
o Java o abstrai perfeitamente dos det alhes da mquina e do sist ema opera-
cional. Em vez de ter de se preocupar com alocao e desalocao de mem-
ria, voc pode simplesmente se concentrar no aprendizado dos objetos.
Finalmente, aprender boas prticas orientadas a obj etos em Java prtico.
Voc pode pegar o conhecimento e fazer um trabalho. Al gumas li nguagens
silo mais orientadas a objetos do que o Java. Entretanto, f cil fazer o Java
funcionar.
Hoje, voc fez um passeio pela programao orientada a objetos. Voc comeou vendo a evolu-
o dos pri ncipais paradigmas de programao e aprendeu al guns dos fundamentos da roo.
Agora, voc deve entender as idias conceit uais por trs da 00, como o que uma classe e como
os objetos se comunicam.
Introduo programao orientada a objet os 19
Defini es so import antes, mas nunca devemos perder o rumo do que estamos tentando fazer
usando 00, nos atendo ao ' como' do que est ivennos fazendo. As seis vanlagens e objeti vos resu-
mem o que a programao orientada a objetos espera cumprir:
1. Natural
2. Confi vel
3. Reuti li zvel
4. Manutenvel
5. Extensvel
6. Oportuna
Voc nunca deve perder esses objetivos de vista.
Perguntas e respostas
P o que posso fer para dominar a POO?
R Li vros como este so uma boa maneira de comear em sua jornada para dominar a 00.
importante construir uma base slida; uma que voc possa desenvolver.
Uma vez que tenha uma base, voc precisa comear a praticar 00 ativamente. O verda-
deirodomnio s vem com a experincia. Comece como um desenvolvedorem um proje-
to 00. Conhea profundamente o assunto. Quando voc se tornar mais famil iarizado
com a 00, comece a se envolver na anlise e no projeto de seus trabalhos.
Tambm aj uda encontrar um mentor. Encontre al gum que esteja desejoso de passar al -
gum tempo compartilhando sabedori a. Instruir-se com os outros a maneira melhor e
mais rpida de aprender POO.
Finalmente, continue seu estudo pessoal. Leia livros, artigos, participe de conferncias.
Voc sempre pode absorver mais informaes.
Workshop
As perguntas e respostas do teste so fornecidas para seu melhor entendiment o. Veja as respos-
tas no Apndice A, "Respostas".
Teste
I. o que programao procedural?
2. Qual vantagem a programao procedural tem cm relao programao no estruturada?
3. O que programao modular?
Dia 1
4. Quais vantagens a programao modul ar tem em relao programao procedural?
S. Liste uma deficincia da programao procedural e da programao modular.
6. O que programao orientada a objetos?
7. Quais so as seis vantagens e objetivos da programao orientada a objetos?
8. Explique um dos obj etivos da programao orientada a objetos.
9. Defina os seguintes lermos:
Classe
Objeto
Comportamento
10. Como os obj etos se comunicam ent re si?
I I. O que um construtor?
12. O que um acessor?
13. O que um mutante?
14. O que thl S?
Exerccios
Alegre-se! Para hoj e, voc no tem exerccios escritos. Em vez disso, d um passeio.
SEMANA 1
DIA
Encapsulamento: aprenda a
manter os detalhes consigo
mesmo
Esperamos que o Dia I, " Introduo programao orientada a objetos", tenha aguado seu in-
teresse e que voc provavelmente tenha mui tas perguntas. Conforme voc pode imaginar, existe
muito mai s na programao orientada a objetos do que algumas defi nies simples. Ao adotar
uma estratgia de 00 para desenvolvimento de software, voc no pode simplesmente sair pro-
gramando. Em vez di sso, voc deve ler um planejamento cuidadoso e lima boa base nas impor-
tantes teorias existentes por trs da POO. Infelizmente, no h uma maneira prti ca de se tornar
um especialista em POO cm poucos anos, imagine em 21 dias! Em vez di sso, voc precisa voltar
e perguntar, "o que estou lentando fazer?" Voc est tentando se tornar um especiali sta terico
ou um profissional prtico? Voc sabe, preciso ser um pouco mai s prt ico se quiser aprender
00 suficient emente para fazer seu trabalho. Felizmente, voc no precisa de um doutorado para
entendere apl icar 00 em seus projetas de soft ware eficientemente. O que voc precisa de uma
mente aberta e o desejo de aprender - ou desaprender, em muitos casos.
Hoje e no restante da semana, voc dar uma olhada prt ica nas teorias subjacent es a POO: as
ferramentas de 00. Essas teorias devem lhe dar uma base suficiente para comear a experimen
tar a POO. Ent retanto, o domnio no vir rapidament e. Assim como qual quer outra habili dade,
seus conheci mentos de POO melhoraro e aumentaro apenas com estudo e prt ica.
Dia 2
Hoje voc vai aprender:







Sobre os trs pilares da programao orientada a objetos
Como apl icar encapsulamento efi cazmente
Como programar de forma abstrata
Como os ti(X)s abstratos de dados formam a base do encapsulamento
A diferena entre interface e implementao
Sobre a importncia da responsabi li dade
Como o encapsulamento ati nge os objetivos da 00
Os trs pilares da programao orientada a
objetos
Para edi fi car seu entendimento c domnio de 00, voc deve primeiro ter uma base slida a partir
da qual possa expandi r sua compreenso. Primeiro, voc precisar identi ficar, definir e explorar
os conceitos bsicos da 00. Somente quando voc tiver uma boa base das teorias bsicas de 00
que poder aplic-la corretamente no software que escrever. Tal discusso o leva naturalmente
aos trs conceitos que devem estar present es para que uma I inguagem seja considerada realmen-
te orient ada a objetos. Esses trs conceitos so freqentcmente referidos como os Irs pilares da
programao ori entada a objetos.
Novo TERMO
Os Irs pi/ares da programao orienlada a obj etos si'lo: eI1CapSIlItl/lIeIllO, herana e
poIiIllOlfi:m/O.
Como a 1>00 baseada neles, os trs pilares so semelhant es a uma torre de bl ocos: remova o
bloco inferior e tudo mais vir abaixo. O encapsul amento, que voc abordar hoje, uma pea ex-
tremamente importante do quebra-cabea, pois ele forma a base da herana e do pol imorfismo.
Encapsulamento: o primeiro pilar
Em vez de ver um programa como uma nica entidade grande e monolt ica, o encapsul amento
permite que voc o divida em vrias partes menores e independentes. Cada parte possui imple-
metllai'lo e realiza seu trabal ho independentemente das out ras partes. O encapsul amento man-
tm essa independncia, ocultando os detalhes internos ou seja, a implementao de cada parte,
atravs de uma interface externa.
Novo TERMO
Encapsulamento a caracterstica da 00 de ocultar partes independentes da imple-
mentao. O encapsulamento pennite que voc construa partes ocultas da imple-
mentao do soft ware, que at injam uma funcionalidade e ocultam os detalhes de implementao
do mundo exteri or.
Encapsulamento: aprenda a manter os det al hes consigo mesmo 23
NOTA
Se voc no estiver famil iarizado com o termo encapsulamento, talvez reco-
nhea os termos mdulo, componente ou bean. Voc pode usar esses termos
em vez de 'software encapsulado'.
Uma vez encapsulado, voc pode ver uma entidade de software como lima caixa preta. Voc
sabe o que a caixa preta faz, pois conhece sua interface externa. Conforme a Figura 2.1 ilustra,
voc si mpl esmente envia mensagens para a caixa preta. Voc no se preocupa com o que aconte-
ce dentro da caixa; voc s6 se preocupa com o fato de que isso acontea.
FIGURA 2. 1
Uma caixa preta.
INTERFACE
Men,egem
Mensagem
INTERFACE
NovO TERMO
Uma il/lelje/ce li sta os servios fornecidos por um componente. A interface um
contrato com O mundo exterior, que define exatamente o que uma entidade externa
pode fazer com o objeto. Uma interface o painel de controle do objcto.
Uma interface importante, pois ela diz o que voc pode fazer com o compo-
nente. O mais interesse o que uma interface nAo informa: como o compo-
nente far seu trabalho. Em vez disso, a interface oculta a implementao do
mundo exterior. Isso li bera o componente para alteraes na sua implementa-
o a qualquer moment o. As mudanas na implementao no mudam o cdi-
go que usa a classe, desde que a interface permanea inalterada. As alteraes
na interface necessitaro de mudanas no cdigo que exerce essa interface.
Novo TERMO
Dia 2
Talvez voc esteja familiari zado com o t ermo de programao APl (Int erface de
Programa Apli cati vo). Uma interface semel hante a APl para um objeto. A in-
terface lista t odos os mtodos e argumentos que o objeto entende.
A implementao define como um componente realmente fomece um servio. A im-
plementao define os detalhes int ernos do componente.
Um exemplo de interface e implementao
Consi dere a classe Log a seguir:
publi c class Log {
}
public void debug( String message ) {
pri nt ( "DEBUG ". message ) i
}
publiC void info( String message ) {
print( "INFO ", message }i
}
public void warn ing( Stri ng message ) {
pr i nt( "WARN ING ", message )i
}
public void er ror( Str ing message } I
print{ "ERROR ", message }i
}
public void fatal( Stri ng message ) I
print( "FATAL ", message ) ;
System.exit( O ) i
}
private void print ( String message , Str ing severity ) {
Sys tem.ou t. println{ severity + ": " + message )j
}
A classe Log contm objctos para relatar mensagens de depurao, infonnativas, de aleT1a e de
erro, durante a execuo. A interface da classe Log constituda de todos os compoT1amentos di s-
ponveis para o mundo exterior. Os eomponamentos disponveis para o mundo exterior so conhe-
cidos como interface pblica. A interface pblica da classe l og inclui os seguintes mtodos:
public void debug( St ring message )
public void i nfo( String message )
publ i c void warning( String message )
public void er ror ( String message )
public void fatal ( String message )
Encapsulamento: aprenda a manter os detal hes consigo mesmo 25
Tudo mais na definio da classe, alm dessas ci nco declaraes de mtodo, implementao.
Lembre-se de que a implementao define como algo fei to. Aqui, o 'como' o fato de que log
imprime na tela. Entretanto, a interface oculta completamente o 'como'. Em vez disso, a inter-
face define um contrato com o mundo exterior. Por exemplo, publ'i c vo'id debug ( String message )
uma maneira de dizer ao mundo exterior que, se voc passar uma Stri ng, ela reportar uma
mensagem de depurao.
O que importante notar o que a interface no diz. debug O no diz que impri mi r na tela. Em
vez disso, o que feito com a mensagem deixado para a implementao. A implementao p0-
deria escrever na tela, descarregar em um arquivo, gravar em um banco de dados ou enviar uma
mensagem para um cliente monitorado pela rede.
Pblico, privado e protegido
Voc pode ter notado que a interface pblica no incl ui
private void print( Stri ng message , String severity ).
Em vez disso, a classe log restringe o acesso a pri nt O .
O que aparece e o que no aparece na interface pblica governado por di versas palavras-chave.
Cada li nguagem 00 define seu prprio conjunto de palavras-chave, mas fundamentalment e es-
sas palavras-chave acabam tendo efeitos semelhantes.
A maioria das linguagens 00 suporta trs nveis de acesso:
Pbli co - Garante o acesso a todos os obj etos.

Protegido - Garante o acesso instncia, ou seja, para aquele objeto, e para todas as sub-
classes(mai s informacssobre subclasses no Dia4, "Herana: obtendo algo para nada").

Pri vado - Garante o acesso apenas para a instncia, ou seja, para aquele objeto.
O nvel de acesso que voc escolhe muito import ante para seu projeto. Todo comportamento
que voc queira tornar visvel para o mundo, precisa ter acesso pblico. Tudo que voc quiser
ocultar do mundo exterior precisa ter acesso protegido ou privado.
Por que voc deve encapsular?
Quando usado cuidadosamente, o encapsulamento transforma seus objetos em componentes
plugveis. Para que outro objeto use seu componente, ele s precisa saber como lIsar a interface
pbl ica do componente. Tal independncia tem trs vantagens importantes:
Independncia significa que voc pode reutili zar o objeto em qualquer parte. Quando
voc encapsular corretament e seus objetos, eles no estaro vinculados a nenhum progra-
ma em particular. Em vez disso, voc pode us-los sempre que seu uso fizer sentido. Para
usar o objeto em qualquer lugar, voc simplesmente exerce sua interface.
O encapsulamento pennite que voc tome transparentes as alteraes em seu objeto. Des-
de que voc no altere sua interface, todas as alteraes pennanecero transparentes para
Dia 2
aqueles que estiverem usando o objeto. O encapsulamento penn ite que voc atualize seu
component e, fornea uma implementao mais eficiente ou corrija erros - tudo isso sem
ter de tocar nos outros objetos de seu programa. Os usurios de seu objeto se benefi c iaro
automaticamente de todas as alteraes que voc fi zer.
Usar um objeto encapsulado no causara efeitos colaterais inesperados entre o objeto e o
restante do programa. Como o objeto tem implementao independente, ele no tera ne-
nhuma oll1ra interao com o restante do programa. alm de sua interface.
Agora, voc est em um ponto onde podemos falar sobre algumas generalidades a respeito do
encapsulamento. Voc viu que o encapsulamento pennite escrever componentes de software
com implementaes independentes. As trs caractersticas do encapsulamento eficaz so:
Abstrao
Ocultao da implementao
Divi so de responsabilidade
Vamos ver mais profundamente cada caracterstica, para aprender a melhor maneira de obter o
encapsulamento.
Abstrao: aprendendo a pensar e programar
de forma abstrata
,
Embora as linguagens 00 estimulem o encapsul amento, elas no o garantem. E fci l construir
cdigo dependente e frgil. O encapsulament o efi caz vem apenas com um projeto cuidadoso.
abslrao e experincia. Um dos primei ros passos para o encapsulamento eficaz aprender
como abstrair software e os conceitos subjacentes eficientemente.
o que abstrao7
Abstrao o processo de simplificar um probl ema difici!. Quando comea a resolver um pro-
blema, voc no se preocupa com cada detalhe. Em vez disso, voc o simplifica, tratando apenas
dos detalhes pertinentes a uma soluo.
,
Imagine que voc tenha de escrever um simulador de fluxo de trfego. E poss vel que voc mo-
dele classes para sinais de trnsito, veculos, condies da pista, aut o-estradas, ruas de mo du-
pla, ruas de mo nica, condies climticas etc. Cada um desses elementos afetaria o fluxo do
trfego. Entretanto, voc no modelari a insetos e pssaros no sistema, mesmo que eles possam
aparecer em uma via real. Alm disso, voc omitiria tipos especficos de carros. Voc simplifica
o mundo real e inclui apenas as partes que realmente afetam a simul ao. Um carro muito im-
portante para a simul ao, mas o fato de ser um Cadillac ou fazer com que o carro controle seu
nvel de combustvel suprfl uo para a simulao de trfego.
A abstrao tem duas vantagens. Primeiro, ela permite que voc resolva um problema faci lmen-
te. Mais importante, a abstrao o ajuda a obter reuti lizao. Muitas vezes, os componentes de
Encapsulamento: aprenda a manter os det al hes consigo mesmo 27
software so demasiadamente especializados. Essa especial izao, combinada com uma inter-
dependncia desnecessria entre os componentes, torna diflci l reutilizar um cdigo existente em
outra parte. Quando possivel, voc deve se esrorar por criar objetos que possam resolver um do-
mnio inteiro de problemas. A abst rao penni te que voc resolva um problema uma vez e de-
pois use essa soluo por todo o domnio desse problema.
NOTA
Embora seja desejvel escrever cdigo abst rat o e evitar uma especi ali zao
demasi ada, duro escrever cdigo abstrat o, especial mente quando voc co-
mea a praticar a POO.
Existe uma li nha tnue entre muita e pouca especializao. A linha pOde ser
di scernida apenas com a experinci a. Entretant o, voc precisa saber desse po-
deroso conceito.
Dois exemplos de abstrao
Considere dois exemplos.
Primeiro, imagine pessoas em fil a em um banco, esperando por um caixa. Assim que um caixa se
toma disponvel, a pri mei ra pessoa da fil a avana para a janela aberta. As pessoas sempre dei-
xam a fil a na ordem de que o pri meiro a entrar o pri meiro a sai r (FI FO): essa ordem sempre
mantida.
FIGURA 2 .2
Uma fi la em
11111 IXII/co.
ENTRADA A
I I
L _ _ _
Cliente 5
Banco de 00
3
SAlDA
Cliente 1 Ceixe 1
Cliente 2 C. iu 2

C. ix.3
Dia 2
Segundo, considere um estabelecimento de sanduches do tipofasl food. Quando um novo san-
duche fi ca pronto, ele colocado atrs do lti mo sanduche que est no escani nho; veja a Figura
2.3. Desse modo, o primeiro sanduche ret irado tambm o mais anti go. FIFO o esquema do
restaurant e.
FI GURA 2.3
Sandlliches fic(lndo
P"OIlfO.f.
Embora cada um desses exemplos seja especfico, voc pode encontrar uma descrio
genri ca que funcione em cada situao. Em outras palavras, voc pode chegar a uma
abstrao.
Cada domni o um exemplo de fila do tipo primeiro a entrar, pri meiro a sair. No importa quais
tipos de elementos apaream na fil a. O que importa que os elementos ent ram no final da fil a e
saem dela a panir da frente, confonne il ustrado na Figura 2.4.
FIGURA 2.4
UII/tI abSfra(((io de
ambos os domnios.
ENTRADA

Abstraindo os domnios, voc pode cri ar uma fila lima vez e reutiliz- Ia em qualquer problema
que modele um domni o onde exista uma ordenao FIFO de elementos.
Abstrao eficaz
Neste ponto, voc pode formul ar algumas regras para a ahstrao eficaz:




Trate do caso geral e no do caso especifico.
Ao confrontar vrios problemas diferent es, procure o que for comum a todos. Tente ver
um conceito e no um caso especfico.
No se esquea de que voc tem um problema a resolver. A abstrao vali osa, mas no
descuide do problema na esperana de escrever cdigo abstrato.
A abst rao pode no estar prontamente aparente. A abstrao pode no saltar sua frente
na pri meira, segunda ou terceira vez que voc resolver um problema que est suj eito a ser
abstrado.
Encapsulamento: aprenda a manter os detal hes consigo mesmo 29
Prepare-se para a falha. quase impossvel escrever uma abstrao que funcione em to-
das as situaes. Voc ver por que, posterionnente ainda hoje.
ALERTA
NeTA
No caia na parali sia da abstrao. Resolva os problemas que voc encontrar
primei ro. Veja a abstrao como um bnus e no como o objet ivo final. Caso
contrrio, voc vai se deparar com a possibil idade de prazos finais perdidos e
abstrao incorreta. Existem ocasi es para abstrair e ocasies em que a abs-
trao no apropriada.
Uma boa regra g e r ~ abstrair algo que voc tiver implementado trs vezes de
maneira anloga. A medida que voc ganhar experincia, aprender a esco-
lher a abst rao mais rapidamente.
Nem sempre voc pode reconhecer oportunidades para uma abstrao. Tal vez
voc tenha de resolver um problema vrias vezes, antes que uma abstrao se
torne aparente. s vezes, diferentes situaes ajudam a encontrar uma abstra-
o efi caz e, mesmo ento, a abstrao pode precisar de alguma converso. A
abstrao pode demorar a amadurecer.
A abstrao pode tomar um componente encapsulado mais reutili zvel, pois ele est personali-
zado para um domino de problemas e no para um uso especfi co. Entretanto, h mais coisas im-
portantes quanto ao encapsulamento do que a simples reut ili zao de componentes. O
encapsulamento tambm importante porocul tar os detalhes internos. O tipo abstrat o de dados
um bom lugar para ver em seguida, na busca do encapsulamento eficaz.
Guardando seus segredos atravs da
ocultao da implementao
A abstrao apenas uma caracterst ica do encapsulamento eficaz. Voc pode escrever cdigo
abstrato que no encapsulado. Em vez di sso, voc tambm precisa ocultar as implementaes
internas de seus objetos.
A ocultao da impl ementao tem duas vantagens:
Ela protege seu objelo de seus usurios.

Ela protege os usurios de seu objeto do prprio objeto.
Vamos explorar a primeira vant agem - proteo do objeto.
Dia 2
Protegendo seu objeto atravs do T AD (Abstract Data
Type - Tipo Abstrato de Dados)
o Tipo Abstrato de Dados (TAD) no um conceito novo. Os TADs,junto com a prpria 00,
cresceu a partir da li nguagem de programao Si mula, introduzida em 1966. Na verdade, os
TADs so decididamente no 00; em vez disso, eles so um subconj unto da 00. Entretanto, os
TADs apresent am duas caracterst icas interessantes: ahstrao e tipo. essa idia de tipo que
importante, pois sem ela, voc no pode ter um verdadeiro encapsulament o.
NOTA
o verdadeiro encapsulamento imposto em nivel de linguagem, atravs de
construes internas da linguagem. Qualquer outra forma de encapsul amento
simplesmente um acordo de cavalheiros, que facilmente malogrado. Os
programadores o contornaro porque podem fazer isso!
Novo TERMO
Um TAD um conj unto de dados e um conjunto de operaes sobre esses dados. Os
T AOs pernlitem que voc defina novos tipos na linguagem, ocultando dados inter-
nos e o estado, atrs de uma interface bem definida. Essa interface apresenta o TAO como uma
uni ca unidade atmi ca.
Os TA Os so uma maneira excelente de introduzi r encapsulament o, pois eles o li beram de con-
siderar o encapsulamento sem a bagagem extra da herana e do polimorfismo: voc pode se con-
centrar no encapsulament o. Os TAOs tambm pennitem que voc explore a noo de tipo. Uma
vez que o tipo seja entendido, fcil ver que a 00 oferece uma maneira nat ural de estendcr uma
linguagem, definindo tipos personali zados do usuri o.
o que um tipo?
Quando programar, voc criar diversas vari veis e atribuir valores para elas. Os ti pos defi nem
as di ferentes espcies de valores que esto disponveis para seus programas. Voc usa tipos para
construir seu programa. Exemplos de alguns tipos comuns so inlegers (inteiros), longs (inteiros
longos) e fl oats (reais). Essas definies de ti po informam exatamente quai s espcies de tipos es-
to disponvei s, o que os ti pos fazem e o que voc pode fazer com eles.
Usaremos a seguinte definio de tipo:
Novo TERMO
Os tipos definem as diferentes espcies de valores que voc pode usar em seus pro-
gramas. Um tipo define o domn io a panir do qual seus valores vlidos podem ser ex-
trados. Para inteiros posit ivos, so os nmeros sem panes fracionarias e que so maiores ou
iguais a O. Para tipos estruturados, a definio mais complexa. Alm do dom inio, a definio de
tipo inclui quais operacs so vlidas no tipo e quais so seus resultados.
NOTA
Encapsulamento: aprenda a manter os detalhes consigo mesmo 31
a t ratamento formal de tipo est fora dos objetivos de um li vro sobre paa para
ini ciantes.
Os ti pos so unidades atmicas da computao. Isso signifi ca que um tipo uma unidade inde-
pendente. Pegue o inteiro, por exemplo. Quando soma dois int eiros, voc no pensa sobre a adi -
o de bits indi viduais; voc pensa apenas a respeito da adio de dois numeroso Mesmo que os
bits representem o inteiro, a linguagem de programao apresenta o inteiro apenas como um n-
mcro para O programador.
Pegue o exemplo Item do Dia I. A criao da classe Itemadiciona um novo tipo em seu vocabul-
rio de programao. Em vez de pensar a respeito de uma id , uma descrio e um preo de produto
como entidades separadas, provavelmente regies desconectadas da memria ou variveis, voc
pensa si mplesmente em termos de I tem. Assim, os tipos permitem representar estruturas comple-
xas em um nvel mais simples e mai s conceituai. Eles o protegem dos detalhes desnecessrios. Isso
o libera para trabalhar no nvel do problema, em vez de trabalhar no nvel da implementao.
Embora seja verdade quc um tipo protege o programador dos detalhes subjacentes, os tipos ofe-
recem uma vantagem ainda mais importame. A definio de um tipo protege o tipo do programa-
dor. Uma defi nio de tipo garante que qualquer objeto que interaja com o tipo, o faa de maneira
correta, consistente e segura. As restries impostas por um tipo impedem os objetos de terem uma
interao inconsistente, possivelmente destrutiva. A delarao de um tipo impede que o tipo seja
usado de maneira no projetada e arbitraria. Uma declarao de tipo garante o uso correio.
Sem uma definio clara das operaes pennitidas, um tipo poderia interagir com outro tipo da
maneira que quisesse. FreqUentemente, tal interao indefi nida pode ser destrutiva.
Pense novamente no Item do Dia I. Imagine que ti vssemos alterado um pouco a definio de
I tem:
public class Unencapsulatedltem {
I
II
public double unft_pri ce ;
public double discount ; !!lITI(I porcentagem de desconto a ser aplicada no preo
publ ic int quantity;
public String description;
publ ic String id;
Voc notar que Iodas as variveis internas agora esto publicamenlc di sponvci s. E se algum
escrevesse o programa a segui r, usando o novo Unencapsul atedItem:
publ i c static void main( String {] args ) {
Unencapsulatedltem moni t or z
new UnencapsulatedItem(
}
Dia 2
"17\" SVGA Monitor ",
1
299 .00 ) ;
monitor .discount 1. 25; II invlido, o desconto deve ser menor que 100%!
double pri ce mon itor.getAdj ustedTot al();
System.out. pr i nt ln( "Incorrect Total: $" + prlce ) ;
monitor.setOlscount{ 1.25 ); II invl ido
I I entretanto, o configurador capturarli o erro
pr i ce monitor.get Ad justedTotal O;
System. out .println{ "Correct Total:$" + price ) ;
A Figura 2.5 mostra o que acontece quando voc execut a o mtodo mainO.
FIGURA 2.5
Um 10/(// illwlido.
Abrindo o tipo Unencapsu 1 a ted I tem para acesso liberado, out ros podem chegar e deixar uma ins-
tncia de Une nca psu 1 ated I t em em um estado invlido. Nesse caso, ma i n () cria um Unencapsu 1 a-
tedltem e, em seguida, aplica diretamente um descont o invlido. O resultado um preo
negati vo ajustado!
Os TADs so ferramentas de encapsul amento valiosas, pois eles permitem que voc defina no-
vos tipos da linguagem que so seguros de usar. Assim como novas palavras so acrescentadas
no idioma ingls a cada ano, um TAD permite que voc cri e novas palavras de programao,
onde voc precisa expressar lima nova idia.
Uma vez defi nido, voc pode usar um novo tipo como qualquer outro. Assim como voc pode
passar um inteiro para um mtodo, tambm pode passar um TAO para um mtodo. Isso conhe-
cido como sendo um objeto de pri meira classe. Voc pode passar objetos de primeira classe
como parmetros.
Encapsulamento: aprenda a manter os detal hes consigo mesmo 33
Novo TERMO
Novo TERMO
Um objelO de primeira c/o.se aquele que pode ser usado cxatamcnte da mesma ma
neira que um tipo interno.
Um objelo de segllnda c/asse um tipo deobjelO que voc pode definir, mas no ne
ccssariarncnte usar, como faria com um tipo interno.
Um exemplo de TAO
Vamos considerar o exemplo da fila abstrata apresentado anteriormente. Ao implementar uma
fila, voc di spe de vrias escolhas de implementao. Voc pode implementar a fila como uma
I ista encadeada, uma li sta duplamente encadeada, um vetor ou uma matriz. Entretanto, a imple
mentao subjacente no muda o comportamento definido da fi la. I ndependentemente da im pIe
mentao, os itens ainda entram e saem de acordo com a ordem FIFO.
A fila uma forte candidata para um TAO. Voc j viu que no precisa conhecer a implementa
o subjacente para usar a fil a. Na verdade, voc no quer ter de se preocupar com a impl emen
tao. Se voc no transformar a fila em Ulll TAO, cada objeto que preci sa de uma fila precisar
rei mplementar a estrutura de dados. Cada objeto que quiser manipular os dados na fi la precisar
entender a implementao e entender como fazer para interagir com ela corretamente. Voc j
viu os perigos do uso no projetado!
Em vez disso, voc deve construi r a fila como um TAO. Um TAD de fi la bem encapsulado ga
rante acesso consistent e e seguro aos dados.
Ao sentarse para projetar um TAO, voc precisa perguntarse o que o TAD faz. Neste caso, o
que voc pode fazer com uma fi la? Voc pode:
Colocar elementos na fil a: enqueue
Remover elementos da fi la: dequeue
Consultar o estado da fi la
Ver o elemento da frente sem remov lo: peek
Cada um dos mtodos se transformar em uma entrada na interface pbl ica de Queue.
Voc tambm preci sa nomeara TAO. Neste caso, o nome do TAO Queue. O TAO definido
como segue:
publi c interface Queue {
I
public voi d enqueue( Object obj );
publ i c Object dequeue();
publ ic boolean i sEmpty();
publ ic Obj ect peek();
Note que a interface da fila no diz nada a respeito de como a fila contm seus dados internos.
Note tambm que a interface no fornece acesso li berado a qualquer dos dados int ernos. Todos
os detalhes fi cam ocultos.
Dia 2
Em vez disso, agora voc tem um novo tipo, uma fila. Agora, voc pode usar esse tipo em qual-
quer um de seus programas.
Como se trata de um objeto de primeira classe, voc pode usara fi la como parmetro. Voc pode
tratar a abstrao como uma unidade, pois todas as partes so independentes. Isso poderoso;
pois permite ao programador ser mai s expressivo. Em vez de pensar em termos de ponteiros e
listas, o programador pode pensar em um nvel muito mais alto: em termos do problema a ser re-
solvido. Quando o programador diz fila, a palavra inclui todos os detalhes de uma lista e de UIll
ponteiro, mas tambm permite que ele ignore esses detalhes e pense em uma estrutura de dados
FIFO de alt o nivel.
Conforme voc ver. medida que continuar. um tipo pOderia ser composto
de outros ti pos. atravs de restries. Embora isso oculte os det athes. t ambm
aumenta sua capacidade de se expressar. Os tipos que contm outros tipos po-
dem abranger muitos conceitos.
Por exemplo, quando voc programa e diz i nt. o signi f icado muito simples;
voc simplesmente declarou um nico inteiro. Entret anto, quando voc diz
Queue, sua declarao muito mais expressiva. H mui t o mais ocorrendo den-
tro de Queue do que dent ro de int.
Vamos considerar a interface mais um pouco. Note que essa interface mui to genrica. Em vez
de di zer que essa uma fil a de inteiros ou hamburgers, a interface simplesmente coloca e reti ra
objetos da fi la. Em Java, voc pode tratar todos os objetos como Objec t . Entretanto, cada lingua-
gem fornece seu prpri o mecanismo semel hante. Declarando os parmetros desse modo, voc
pode colocar qualquer objeto que queira na fila. Assim, essa defi nio torna o tipo Queue ltil em
muitas sit uaes diferentes.
ALERTA
As interfaces genricas tm seus prprios perigos. Uma Queue de inteiros muito
exata. Voc sabe que cada element o em Queue um intei ro. Entret anto, uma
Queue de objetos fracamente tipada. Quando voc extrai um elemento, pode
no saber qual seu t ipo.
Para um encapsulamento realmente efi caz, existem mai s algumas caractersticas que voc preci-
sar tratar. Tocamos no aspecto da ocultao da implementao. Mas, e quant o ao outro lado da
moeda - proteger os usuri os de seus objetos?
Protegendo outros de seus segredos atravs da ocultao
da implementao
At aqui, voc vi u que uma interface pode ocultar a implementao subjacente de um obj eto.
Quando oculta a implementao atrs de uma interface, voc protege seu objeto de uso no pro-
Encapsulamento: aprenda a manter os detalhes consigo mesmo 35
jetado ou destrutivo. Proteger seu objeto de uso no projetado uma vantagem da ocultao da
implementao. Entretanto, existe outro lado na histria: os usuri os de seus objetos.
A ocullao da implementao leva a um projeto mais flex vel , pois ela impede que os usurios
de seus objetos se tomem fortemente acoplados implementao subjacente dos objetos. Ento,
no apenas a ocultao da implementao protege seus objelos, como tambm protege aqueles
que usam seus objetos, esti mul ando um cdigo fracamente acoptado.
Novo TERMO
Novo TERMO
o cdigofracamente acoplado independente da implementao de outros compo-
nentes.
o cdigo fortemel1te acoplado fortemente vinculado implementao de outros
componentes.
Voc poderia estar se perguntando, "para que serve cdigo fracamente acoplado?"
Quando um recurso aparece na interface pblica de um objeto, todo mundo que usa o recurso se
toma dependente do fato de ele existir. Se o recurso desaparecer repenti namente, voc preci sar
alterar o cdigo quc tiver se desenvolvido de forma dependente a esse comportamento ou atri buto.
Novo TERMO
Cdigo dependeme dependente da existncia de detcnninado tipo. O cdigo de-
pendente inevitvel. Entretanto, existem graus para a dependncia aceitvel e para
a superdependncia.
Existem graus para a dependncia. Voc no pode eliminar a dependncia total mente. Ent retan-
to, voc deve se esforar para minimizar a dependncia entre objetos. Nonnahnente, voc limita
tal dependncia programando uma interface bem defi nida. Os usurios s6 podem se tomar de-
pendentes quanto ao que voc decide colocar na interface. Entretant o, se alguma implementao
do objeto se tornar partc da interface, os usurios do objelo podero se tornar dependentes dessa
implementao. Tal cdigo fortemente acoplado el imina sua li berdade de alterar a
o de seu objcto. Uma pequena alterao na i mplementao de seu objcto poderia necessitar de
uma cascata de alteraes por todos os usurios do objeto.
o encapsulamento e a ocultao da implementao no so mgica. Se voc
precisar alterar uma interf ace, precisar atualizar o cdigo que dependente
da interface antiga. Ocul t ando os detalhes e escrevendo software para uma in-
terface, voc cria software que fracamente acoplado.
o cdigo fonemente acoplado anula o objetivo do encapsulamento: criarobjelos independentes
e reutilizveis.
Dia 2
Um exemplo real de ocultao da implementao
Um exemplo concreto de ocultao da implementao esclarecer esta lio. Considere a se-
guinte definio de classe:
publlc cl ass Customer {
}
II ... vrios mtodos de
publlc I tem (} items;
cliente
Ileste

array contm t odos os itens selecionados
Um Customer contm itens selecionados. Aqui, Customer torna o array I tem parte de sua interfa-
ce externa:
publ1c static void main( String [] args ) {
Customer customer new Customer {) ;
}
II . . . seleciona alguns itens .. .
II preo dos itens
double total 0.0;
for( lnt 1 O; 1 < customer.items.length; i++) {
Item i tem customer.items[i] ;
total total + item.getAdjus tedTotal();
}
Esse mtodo main() pega um cliente, adiciona alguns itens e totaliza o pedido. Tudo funciona,
mas o que acontece se voc quiser mudar a maneira corno um Customer cont m itens? Suponha
que voc quisesse introduzi r uma classe Bas ket. Se voc mudar a implementao, precisar at u-
alizar todo o cdigo que acessa diretamente o array Item.
Sem ocult ao da implementao, voc perde sua liberdade de melhorar seus objetos. No exemplo
Cus temer, voc deve tomar o array I tem privado. Fornea acesso aos itens atravs de acessores.
NeTA
A ocultao da implementao tem seus inconvenientes. Exi stem ocasies em
que voc poderia precisar saber um pouco mais do que a interface pode infor-
mar.
No mundo da programao, voc desejar uma caixa preta que funcione den-
tro de det erminada tolerncia ou que use a quantidade certa de preciso. Voc
poderia saber que precisa de inteiros de 64 bits, pois est t ratando com nme-
ros mui to grandes. Ao definir sua interface, importante no apenas fornecer
uma interface, mas tambm documentar esses tipos de detalhes especificas
sobre a implementao. Entretanto, assim como em qualquer outra parte da
interface pblica, uma vez que voc declara um comportamento, no pode ai-
terlo.
Encapsulamento: aprenda a manter os detal hes consigo mesmo 37
A ocuhao da implementao permite que voc escreva cdigo que independente e fracamen-
te acoplado com outros componentes. O cdigo fracament e acoplado menos frgil e mais flex-
vel para alterar. Um cdigo flexivel facil ita a reuti lizao e o aprimoramento, pois as alteraes
em uma part e do sistema no afetar out ras partes no relacionadas.
DI CA
Como voc obtm ocultao da implementao eficaz e cdigo fracamente
acoplad07
Aqui esto algumas dicas:
S permita acesso ao seu TAO atravs de uma interface baseada em mto-
do. Tal interface garante que voc no exponha informaes sobre a im-
plementao.
o No fornea acesso involuntrio a estruturas de dados internas, retornan-
do pontei ros ou referncias acidentalmente. Aps al gum obter uma refe-
rncia, a pessoa pode fazer tudo com ela.
o Nunca faa suposies sobre os outros tipos que voc usa. A no ser que
um comport amento aparea na interface ou na documentao, no conte
com ele.
o Cuidado enquanto escrever dois tipos intimamente relacionados. No
programe acidentalmente em supOSies e dependncias.
Diviso da responsabilidade: preocupando-se
, . , .
com seu propno negocIo
A ocultao da implementao evol ui naturalmente para uma discusso sobre a diviso da res-
ponsabilidade. Na seo ant erior, voc viu como poderi a desacoplar cdigo ocultando detalhes
da implementao. A ocultao da implementao apenas um passo na direo da escrita de
cdigo fracamente acoplado.
Para ter realmenle cdigo fracamente acoplado, voc tambm deve ter uma di viso da responsa-
bilidade correta. Di viso da responsabilidade correta signifi ca que cada objeto deve executar
uma funo - sua responsabilidade - e execut- la bem. A diviso da responsabilidade correta
tambm significa que o objeto coesivo. Em outras palavras, no faz sent ido encapsul ar muitas
funes aleatrias e variveis. Elas precisam ter um forte vinculo conceituaI entre si. Todas as
funes devem trabalhar no senti do de uma responsabil idade comum.
NOTA
Dia 2
A ocultao da implementao e a responsabilidade andam lado a lado. Sem
ocultao da implementao, a responsabi lidade pode faltar em um objet o.
de responsabil idade do objeto saber como fazer seu trabalho. Se voc deixar a
impl ementao aberta para o mundo exteri or. um usuri o poder comear a
atuar diretamente na implementao - dupl icando assim a responsabi l idade.
Assim que dois objetos comeam a fazer a mesma tarefa, voc sabe que no
t em uma diviso da responsabilidade correta. Quando voc observar a exis-
t ncia de lgica redundante, precisar refazer seu cdigo. Mas no se sinta
mal; refazer o t rabalho uma part e esperada do ciclo de desenvolvimento 00.
A medida que seus projetos amadurecerem, voc encontrar muit as oportuni-
dades para melhor-los.
Vamos considerar um exemplo real de diviso da responsabi lidades: o relacionamento entre ge-
rent e e programador.
Imagine que seu gerente venha at voc, fornea as especificaes de sua parle em um projeto e,
em seguida, o deixe trabalhar. Ele sabe que voc tem um trabalho a fazer e que sabe como razero
melhor trabalho possvel.
Agora, imagine que seu chefe no to esperto. Ele explica o projeto e pelo que voc ser res-
ponsvel. Ele lhe garante que est l para facilitar seu trabal ho. Mas, quando voc comea, ele
puxa uma cadeira! Pelo resto do dia, seu chefe fica em cima de voc e fornece instrues passo a
passo, enquant o voc codifica.
Embora o exemplo seja um tani a extremo, os programadores programam dessa maneira em seu
cdigo, o tempo todo. O encapsulament o como o gerente efi ciente. Como no mundo real, co-
nhecimento e responsabi lidade precisam ser delegados para aqueles que sabem como fazer o tra-
balho da melhor ronna possvel. Muitos programadores estrut uram seu cdigo como um chefe
autoritrio trata seus funcionrios. Esse exemplo fac ilmente transportado para os termos da
programao. Vamos considerar um exemplo assi m:
public class Badltem {
private double unit _pricei
private double adjusted_pr1ce i
private double discounti
II
uma porcentagem
II
preo
private i nt quantitYi
private String descriptioni
pri vate St ring i d i
publ ic Badltem( St ring id o String descri ption,
int quantity. doubl e pri ce ) {
this . id 1d i
this.descriptlon descriptioni
i l( quantity >- O ) {
de desconto para aplicar no
}
Encapsulamento: aprenda a manter os detalhes consigo mesmo 39
this.quantity quantity;
}
else {
this.quantity O;
}
this.unit_price z price;
}
public double getUnitPrice() {
return unit_price;
}
II aplica uma porcentagem de desconto no preo
public void setOiscount( double discount ) (
if( discount <- 1. 00 ) {
this.discount : discount ;
}
}
publiC double getOiscount() I
return discount;
}
publiC int getQuantity() (
return quantity;
)
public void setQuantity( int quantity ) {
thi s.quantity - quantity ;
}
publiC String getProductID() I
return id;
}
public String getDescription() {
return description;
}
publ i C double getAdjustedPrice() {
return adjusted_price ;
}
publ iC voi d setAdjustedPrice( double pr ice) I
adjusted_price price;
}
Dia 2
BadItem no cont m mais a responsabilidade de calcular o preo ajustado. Ento, como voc
gera um preo ajustado? Considere o mtodo mainO a seguir:
public static voi d ma i n( String [] args ) I
I
II cr i a os itens
BadItem milk = new BadItem( "1 Gallon Milk
R
, 2, 2.50 );
II apl ica cupons
milk. set Oi scount( 0.15 ) ;
II obtm os preos ajus tados
double milk_price milk.getQuantity() * milk.getUnitPrice() ;
double milk_discount = milk.getDiscount() * milk_price ;
milk.setAdjustedPrice( milk_price - milk_discount );
System. out.println( "Your milk costs : \t $" + milk.getAdj us tedPriceO )i
Agora, em vez de si mplesmente solici tar a Item seu preo ajustado, voc precisa se comportar
como o gerente ineficiente. Voc preci sa dizer ao objeto item o que fazer, passo a passo.
Ter de chamar varias funes para calcular o total ajustado, retira a responsabilidade do item e a
coloca nas mos do usurio. Reti rar a responsabil idade dessa maneira to rui m quanto expor
implementaes internas. Voc acaba com responsabil idade duplicada por todo o seu cdigo.
Cada objeto que desejar calcular o total aj ustado precisar repeti r a lgica encontrada no mtodo
ma ioO.
Ao escrever suas interfaces, voc preci sa certificar-se de que no esteja si mplesment e apresen-
tando a implementao atravs de um conjunto de nomes diferente. Lembre da fila - voc no
quer mtodos chamados addObjec tToLi s tO, updateEndl i stPoi nterO etc. Esses tipos de com-
portamentos so especficos da implementao. Em vez disso. voc ocul ta a implementao,
atravs dos comport amentos enqueueO e dequeueO. de n vel mais alto ( mesmo que, interna-
mente, voc possa atuali zar ponteiros c adicionar o objeto a uma li sta). Em te rmos de BadI tem,
voc no desejar ter de chamar um mtodo ca 1 culateAdjustedPri ce O, antes de poder recupe-
rar o preo aj ustado atravs do mtodo getAdjustedPri ce (). Em vez disso, getAdjustedPri ce ()
deve saber efetuar o clculo.
Quando voc tem objetos que no dividem corretamente a responsabil idade, acaba com cdigo
procedural , centrado nos dados. O mtodo mai n para calcular o preo aj ustado mui to procedu-
ral o Um mtodo maio que instrusse um obj eto Queue em cada passo de seu processo enqueue()
seria procedural. Se voc simplesmente enviar uma mensagem para um objeto e confiar que ele
faa seu trabalho, esse o verdadeiro desenvolvimento orientado a objetos.
O encapsulamento esta completamente ligado ocultao de detal hes. A responsabilidade colo-
ca o conhecimento de certos detalhes onde eles pertencem. importante que os objetos tenham
apenas uma ou um pequeno numero de responsabilidades. Se um objeto tiver responsabili dades
Encapsulamento: aprenda a manter os detal hes consigo mesmo 41
demais, sua implementao se tomar mui to confusa e dificil de manter e estender. Para alterar
uma responsabil idade, voc correr o risco de alterar out ro comportamento inadvertidament e, se
um objeto conti ver muitos comportamentos. Ele tambm central izar muito conhecimento, que
estari a melhor espalhado. Quando um objeto fica grande demais, ele quase se toma um progra-
ma completo e cai nas armadi lhas procedurais. Como resultado, voc se depara com todos os
problemas que encontraria em um programa que no usasse nenhum encapsulamento.
Quando voc verifi car que um objeto executa mai s de uma responsabi lidade, precisar mover
essa responsabilidade para seu prprio obj eto.
A LERTA
A ocultao da implementao apenas um passo para o encapsulamento efi -
ciente. Sem divises de responsabi l idade corretas, voc simplesmente acaba
com uma li sta de procedimentos.
Neste ponto, voc pode melhorar a definio de encapsulamento.
NovO TERMO
Encapsulamel1to efelil'o abstrao mais ocultao da implementao mais res-
ponsabilidade.
Retire a abstrao e voc ter um cdigo que no reutilizvel. Reti re a ocultao da implementa-
o e voc fi car com um cdigo fortemente acopladoe frgil. Retire a responsabilidade e voc fi-
car com um cdigo centrado nos dados, procedural, rortemente acoplado e descentrali zado.
Sem todas as trs partes, voc no pode ter um encapsulamento efet ivo, mas a falta de responsa-
bilidade o deixa com a pior situao de todas: programao procedural em um ambiente ori enta-
do a objetos.
Dicas e armad do encapsulamento
Ao se aplicar encapsulamerHo, existem vrias di cas a seguir e armadilhas a evit ar.
Dicas e armadilhas da abstrao
Ao escrever uma classe, voc pode ter problemas, se tentar trabalhar de forma abstrata demais.
impossvel escrever lima classe que satisfaa todos os usurios e cada situao. Imagine que
voc ti vesse de escrever um objeto pessoa para um sistema de folha de pagamento de uma em-
presa. Esse objeto pessoa vai ser muito diferente de um objelo pessoa no simulador de nuxo de
trfego que discutimos anteriormente.
Dia 2
A abstrao pode ser perigosa. Mesmo que voc t enha abstraldo algum el e-
mento, ele poder no funci onar em todos os casos. mui to difcil escrever
uma classe que sat isfaa as necessidades de todos os usuri os. No caia na fi -
xao da abstrao - resolva seus problemas primeirol
Tudo se resume a fazer o sufi cienle para resolver o problema imediato. Inclui r todos os detalhes
necessrios para o objeto pessoa funcionar nos dois contextos seria muito dispendioso. Isso pode
provocar lodos os problemas que voc viu hoje, devido responsabil idade embaralhada. Embo-
ra voc possa ligar seu objeto pessoa s duas situaes, ele no ser mais um objeto pessoa abs-
trato. Voc perde toda a simplificao que a abstrao oferece.
ALERTA

No coloque em uma classe mais do que o necessri o para resol ver o proble-
ma. No tente resol ver todos os probl emas; resol va o problema imediato. So-
mente ento voc dever procurar meios de abstrair o que fez .
E claro que existem ocasies onde um problema complexo, como um clcul o dificil ou uma si-
mulao complicada. Estamos falando de complexidade do ponto de vista da responsabi lidade.
Quanto mais responsabilidades um objeto assume, mais complexo ele ser e mais dificil ser
mant-lo.
DICA
Lembre-se de que adicionar uma nova classe em seu si st ema o mesmo que
cri ar um novo tipo. Ter essa noo em mente ajuda a f ocalizar o que voc est
realmente f azendo. Ao falar sobre seu probl ema, voc ver que estar falando
em termos dos obj etos e das interaes e no de dados e mtodos.
Finalmente, a verdadeira abstrao s pode vir com o tempo.
A verdadeira abstrao normalmente nasce a part ir de usos reais c no do fato de um programa-
dor se sent ar e decidi r criar um obj elo reuti lizvel. Como diz o ditado, a necessidade a me da
inveno. Os objetos funcionam da mesma maneira. Normalmente, voc no pode sentar-se e
escrever um objeto abstraIO realmente reutilizvel, logo na primeira vez. Em vez disso, os obje-
tos reutilizveis nonnalmente so derivados de um cdigo amadurecido, que foi posto prova e
que enfrentou muitas alteraes.

A verdadeira abslrao tambm vem com a experincia. E um objeli vo a ser buscado no dom nio
da POO.
Encapsulamento: aprenda a manter os detal hes consigo mesmo 43
Dicas e armadilhas do TAO
A transformao de um TAD em uma classe especifica da linguagem. Entretanto, existem al-
gumas consideraes independentes da li nguagem que voc pode fazer a respeito das classes.
A maioria das linguagens 00 fomece palavras-chave que o aj udam a defi nir classes encapsula-
das. Primeiro, existe a prpria defin io de classe. A classe como o TAD, mas com alguns re-
cursos import antes, que voc vcr nos prximos dias.
Dentro de uma classe, normalmente voc tem mtodos e varivei s internas-os dados. O acesso
a essas variveis e mtodos fomecido por funes de acesso. Tudo na interface do TAD deve
parecer fazer parte da interface pblica do obj eto.
Os TADs no so diretament e anlogos classe da 00. El es no tm herana
e recursos de pOlimorfismo. A importncia desses recursos se t ornar eviden-
te quando voc estudar o Dia 4 e o Dia 6, aprendendo a prever
o
Dicas da ocultao da implementao
o que expor e o que ocultar em sua interface nem sempre fcil de decidir. Entretanto, podemos te-
cer algumas consideraes independentes da linguagem sobre o acesso. Apenas os mtodos que
voc pretende que outros usem devem estar na interface pblica. Os mtodos que apenas o tipo usar
devem estar ocul tos. No exemplo da fi la, dequeue () e enqueue() devem estar na interface pbl ica.
Entretanto, voc deve ocultar mtodos auxil iares, como updateFrontPointerO e addToListO.
Voc sempre deve ocultar as variveis internas, a no ser que elas sejam constantes. Achamos
que elas no devem estar apenas ocultas, mas tambm acessveis apenas para a prpria classe.
Voc vai expl orar esse conceito mais detidamente, no Dia 4. Abrir varivei s internas para acesso
externo expe sua implement ao.
NeTA
Voc pode abrir variveis internas para uso externo apenas se sua linguagem
tratar desses valores como trata mtodos. O Delphi e o Borland C++ tratam de
variveis i nternas dessa maneira.
Se usurios externos puderem acessar mtodos e valores sem saber que esto
mexendo em um valor, ento estar correto abri los. Em t al linguagem, uma
vari vel interna exposta seria igual a um mtodo que no recebe parmetros.
Infelizment e, no so muitas li nguagens 00 que Iratam valores e mt odos da
mesma maneira.
finalmente, no crie interfaces que apresentam apenas a representao interna com um nome di -
ferente. A interface deve apresentar comportamentos de alto n vel.
Dia 2
Como o encapsulamento atende os objetivos da
programao orientada a objetos
o Dia I mostrou que o objetivo da programao ori entada a objetos produzir software:
I. Natural
2. Confivel
3. Reuti lizvel
4. Manutenivel
5. Extensvel
6. Oportuno
o encapsulamento atende cada um desses objetivos:
Natural: o encapsulament o permite que voc divida a responsabil idade da manei ra como
as pessoas pensam naturalment e. Atravs da abstrao, voc fica li vre para modelar o
problema em termos do prprio problema e no em termos de alguma implementao es-
pecfica. A abstrao permite que voc pense e programe no geral.
Confivel: isolando a responsabilidade e ocultando a implementao. voc pode validar
cada componente individual. Quando um component e for vali dado, voc poder us- lo
com confiana. Isso possi bili ta testes de unidade completos. Voc ai nda precisa realizar
testes de integrao, para cert ifi car-se de que o software construdo funciona corretamente.
Reutil izvel: a abstrao fornece cdigo flexvel e utili zvel em mais de uma situao.
Manuten vel: o cdigo encapsulado mais fcil de manter. Voc pode fazer qualquer al -
terao que queira na implementao de uma classe, sem danificar cdigo dependente.
Essas alteraes podem incluir mudanas na implementao, assim como a adi o de no-
vos mtodos na interface. Apenas as alteraes que violam a sernmica da interface exigi-
ro mudanas no cdigo dependente.
Extensivel: voc pode mudar implementaes sem danificar cdigo. Como resultado, voc
pode fazer melhorias de desempenho e mudar funcionalidade sem dani fi car o cdigo exis-
tente. Alm di sso, como a implementao fica oculta, o cdigo que usar o componente ser:l
atualizado automaticamente, para tirar proveito de todos os novos recursos que voc intro-
duzir. Se voc fi zer tais alt eraes, certifique-se de fazer os testes de unidade novamente!
Danificar um objeto pode ter um efeito de domin por todo o cdigo que use o objeto.
Oportuno: dividindo seu sofuvare em partes independentes, voc pode dividi r a tarefa de
criar as partes ent re vrios desenvolvedores, acelerando assim o desenvolvi mento.
Uma vez que esses componentes estejam construidos e validados, eles no precisaro ser recons-
truidos. Assim, o programador fica livre para reutil izar funcionalidade, sem ter de recri -Ia.
Encapsulamento: aprenda a manter os detal hes consigo mesmo 45
Advertncias
Voc pode estar pensando, "mas eu no preciso de 00 para abstrair e encapsular meu cdigo".
Quer saber? Voc est certo - voc no precisa de 00 para ter cdigo encapsulado. Os prprios
TADs no so 00. E bastante possvel ter encapsulamento em praticamente qualquer li nguagem.
Entretanto, h um problema. Em outros tipos de li nguagens, voc freqentemente precisa criar
seus prprios mecanismos de encapsulamento. Como no existe nada na linguagem que o obrigue
a respeitar seus padres, voc precisa estar atento. Voc precisa se obrigar a seguir suas diretrizes.
Voc tambm ter de recriar suas diret rizes e seu mecani smo para cada programa que escrever.
Isso est bem para um desenvolvedor. Mas e para dois desenvolvedores? Dez? Uma empresa in-
teira? Quanto mais desenvolvedores so adicionados, mais di fici l ter todos na mesma pgina.
Uma verdadeira linguagem 00 fornece um mecanismo para encapsulamento. Ela impe o meca-
nismo de um modo que voc no consegui ria sozinho. A li nguagem encapsula os detalhes do me-
canismo de encapsulamento do usurio. Uma linguagem 00 fornece algumas palavras-chave. O
programador simplesmente usa as palavras-chave e a linguagem cuida de todos os detalhes.
Ao trabalhar com os recursos fornecidos pela linguagem, a linguagem apresenta a todos os pro-
gramadores o mesmo mecanismo consistent e.
Resumo
Agora que voc entende de encapsulamento, pode comear a programar com objetos. Usando
encapsulamento, voc pode tirar proveito das vantagens da abstrao, da ocultao da imple-
mentao e da responsabilidade em seu cdigo dirio.
Com a abstrao, voc pode escrever objetos que so tei s em vrias situaes. Se voc ocultar
corretamente a implementao de seu objeto, estar livre para fazer quaisquer mel horias que
queira em seu cdigo - a qualquer momento. Finalmente, se voc dividir corretamente a res-
ponsabilidade entre seus objetos, evi tar lgica duplicada e cdigo procedural.
Se voc fec har este li vro agora e nunca mais consult-lo, ter aprendido novas habil idades de
0 0 sufi cientes para escrever componentes independentes. Entretant o, a histria da 00 no ter-
mina com o encapsulamento. Cont inue a ler e voc aprender como tirar proveito de todos os re-
cursos oferecidos pela POO.
Perguntas e respostas
P Como \' oc sabe quais mClodos dcvc incluir em uma inlerface?
,
R E si mples saber quais mtodos deve incl uir. Voc precisa incluir apenas os mtodos
que tornam o objeto ti l; os mtodos de que voc precisa para que outro objeto faa seu
trabalho.
Dia 2
Quando voc comear a escrever uma interface, desejar produzi r a menor interface que
ai nda satisfaa suas necessidades. Tome sua int erface o mais si mples possvel. No in-
cl ua mtodos que voc ' poderia' precisar. Voc pode adi cion-los quando realmente
precisar deles.
Conhea certos ti pos de mtodos de convenincia. Se voc fizer um obj eto conter outros
objetos, normal meme desejar evitar a criao de mtodos que si mplesmeme encami-
nham uma chamada de mtodo para um dos objetos conti dos.
Por exempl o, digamos que voc tenha um objeto carrinho de compras que contenha
itens. Voc no deve adicionar um mtodo de convenincia no carrinho, que consultar
um item para saber seu preo e retom-lo. Em vez disso, voc deve ter um mtodo que
permi ta obter o item. Quando voc tiver o it em, poder solici tar o preo em si.
P Voc mencionou as palavras-chave publ i c, protected e private. Existem outros mo-
dificadores de acesso?
R Cada linguagem define seus modificadores de acesso de sua prpria maneira. Entretanto,
a maioria das linguagens 00 define esses trs nveis. A linguagem Java tambm tem um
modificador de acesso do pacote padro. Voc especifica esse nvel omi tindo um modifi-
cador. Esse nvel restringe o acesso a apenas as classes do mesmo pacote. I)ara mais in-
formaes sobre pacotes, consulte o Apndice Bt "Resumo do Java".
P Os modificadores de acesso tambm tm o papel de mecanismo de segurana?
R No. Os modificadores de acesso s restringem o modo como OUl ros objelos podem inte-
ragir com detenninado objeto. Os modificadores no tm nada a ver com a segurana do
computador.
Workshop
As perguntas e respostas do teste so fornecidas para seu melhor entendimento. Veja as respos-
tas no Apndice A, ' Respostas".
Teste
I. Como o encapsulamento at inge os objetivos da programao orientada a objetos?
2. Defina abstrao e d um exemplo demonstrando abstrao.
3. Defi na implement ao.
4. Defina interface.
5. Descreva a diferena ent re interface e implementao.
6. Por que a diviso clara da responsabil idade importante para o encapsulamento eficaz?
Encapsulamento: aprenda a manter os detal hes consigo mesmo 47
7. Defina tipo.
8. Defina TAO (Tipo Abstrato de Dados).
9. Como voc obtm ocultao da implementao efi caz e cdigo fracamente
acoplado?
10. Quais so alguns dos perigos inerent es abstrao?
Exerccios
,
I. Considere a est rutura de dados de pilha clssica. Urna pilha uma estrutura ,. Ult imo a
entrar, pri mei ro a sair" (LI FO). Ao contrrio de urna fi la FI FO, voc s pode ad icionar e
remover elementos a parti r da mesma extremidade de uma pilha. Assim como em uma
fila, urna pilha permite que voc verifique se e la est vazia e escolha o prime iro elemento
que pode remover.
Defi na um TAO para a classe pilha.
2. Pegue o TAO de pil ha do Exercicio I e esboce uma implementao. Quando terminar,
defina uma segunda implementao.
3. Examine os exercicios I e 2. A interface que voc projetou no Exerccio I era adequada
para as duas implementaes formuladas no Exercicio 2? Se ass im foi, quai s vantagens a
int erface forneceu? Caso contrrio, o que faltou na interface ori ginal?
SEMANA 1
DIA
Encapsulamento: hora de escrever
algum cdigo
Ontem, voc aprendeu tudo sobre encapsulamento. Ao iniciar as lies de hoje, voc dever ter
uma boa idia do que encapsulamento, como aplic-lo efi cazment e e em quais erros comuns
,
deve prestar ateno. Neste ponto, o que voc no tem experincia prti ca COlU a tcnica. E cla-
ro que voc conhece a Icoria, mas nada melhor do que se aprofundar no cdigo. Para o restante
do dia, voc completar vrios laboratrios que devero cimentar as lies do Dia 2.
Hoje voc aprender:




Como confi gurar o ambiente Java
Sobre as classes bsicas
Como implement ar o encapsulamento
A respeito do pacote de pri mi tivas Java
laboratrio 1: configurando o ambiente Java
Voc usar a linguagem de programao Java para completar todos os laboratrios desta se
mana, assi m como o projeto fi nal. Para programar em Java, voc precisa obter uma verso do
Java 2. Para completar estes laboratri os, voc precisa ter pelo menos a verso 1.2 do SDK.
Dia 3
Se voc ainda no tem, ter de fazer download e instalar um kit de desenvolviment o agora. Exis-
tem muitos kits de desenvolvimento diferentes disponveis. Ent retanto, voc pode obter facil-
mente a verso mai s recente, a parti r do endereo http: //www.javasoft. com/ j2se/ .
A Sun suporta trs platafonnas pri ncipais: Solari s, Linux e Wi ndows. Quando este livro estava
sendo produzido, a verso mais recente da Sun era Java 2 SOK, Standard Edi tion, v 1.3.
A IBM tambm oferece vri os ki ts de desenvolvimento, no endereo
http://www.i bm.com/java/jdk/index.html.
Alm das plataformas suportadas pela Sun, a IBM tambm fornece suporte a vrias plataformas,
como OS/2, AS/400 e AIX.
Cada kit de desenvolviment o vem com instrues de instalao adequadas. Siga essas instrues
para instalar o kit em sua mqui na de desenvolvimento. Voc tambm pode consultar o Apndi-
ce B, " Resumo do Java", para obter mai s ajuda.
Voc tambm pode optar por usar um popular IDE Java , como Fort e, JBuilderoll Visual Age for
Java. Estes exemplos e laboratrios tambm funci onaro nesses ambientes.
Este livro pressupe uma famil iaridade bsica com programao, mas voc no precisa de um
conhecimento profundo de Java para completar estes laboratrios. Se voc precisar de alguma
ajuda para conhe<::er os fundamentos da linguagem Java, consulte o Apndice B.
Exposio do problema
Na verdade, voc precisa do boi antes do carro. Ant es de poder programar, voc precisa obter e
configurar um ambiente de desenvolvimento Java. Se voc ai nda no fez isso, obtenha um kit de
desenvolvi mento Java e siga os passos de li neados no Apndice B para installo. Uma vez insta-
lado, o apndice o conduzi r na configurao do caminho das classes, ass im como na compila-
o e execuo de seu primeiro programa Java. Quando voc concluir este labof'cl trio, saber se
sua instalao de Java funciona. Voc tambm saber tudo que precisa para compilar e executar
seus programas Java.
laboratrio 2: classes bsicas
muito importante que voc se recorde das lies dos dias 1 e 2, enquanto escreve suas primei-
ras classes.
No Dia I, voc aprendeu alguns fundamentos sobre classes e objetos. O Dia 2 mostrou como
voc podc se benefi ciar do encapsulamento para produzir objetos bem definidos.
A bibli oteca de classes Java contm um rico conjunto de estruturas de dados clssicas, como lis-
tas e tabelas hashi ng. Considere a classe OoubleKey da Listagem 3.1.
Encapsulamento: hora de escrever algum cdigo
LI STAGEM 3.1 OoubleKey.java
public class OoubleKey {
I
private String keyl , key2:
II um construtor sem argumentos
public DoubleKeyD (
keyl "keyl ";
key2 "key2":
I
II um construtor com argumentos
public DoubleKey( String keyl , Str ing key2 ) {
this.keyl keyl:
this.key2 key2;
I
II acessor
publ ic String getKeylO (
return keyl :
I
II mutante
public void setKeyl( St r ing keyl ) {
thi s . keyl keyl :
I
II acessor
public String getKey2() {
return key2 :
I
II mu tante
public void setKey2( St ring key2 ) {
this.key2 = key2:
I
II igual e cdigo hashi ng omitidos por brevidade
51
Quando coloca um objeto em qualquer implementao de java .ut; 1 .Map. voc pode especificar
qualquer objeto como chave para esse objeto. Quando precisa recuperar um objeto, voc sim-
plesmente usa a chave para recuperar o valor. Ooubl eKey permite que voc use hashing em duas
chaves Stri ng, em vez de em uma.
Dia 3
Voc notar que Ooubl eKey tem dois construt ores:
public OoubleKey() I
keyl "keyl-j
key2 "key2
M
;
J
public OoubleKey( String keyl . String key2 ) {
this.keyl = keyl;
this . key2 key2 i
J
Os construtores aparecem em duas formas: aqueles sem argumentos (construtores lI oargs) e
aqueles com argumentos.
Novo TERMO Conslr Ufores l10args so construtores que no recebem nenhum argumento.
NOTA
Construtor noarg um termo Java. O equi valente em C++ construtorpedro.
Os construtores sem argumento instanciam um objeto COm valor padro. enquanto aqueles que
aceitam argumentos usam os argumentos para inicializar o estado interno dos obj etos.
pub 1 i c Ooub 1 eKey () um exemplo de construtor noarg. enquanto pub 1 i c Ooub 1 eKey ( S tri ng
keyl. String key2 ) aceita argumentos.
Confonne o Dia 1 ensinou, mtodos como public St ring getKeyl O e publ ic Stri ng get Key20
so conhecidos como acessorcs, pois eles pcnnitem que voc acesse os valores internos do objeto.
O mundo Java reconhece doi s tipos de acessores: de configurao e de obten-
o. Os de configurao permitem que voc confi gure uma varivel de instn-
cia. enquanto os de obteno permitem que voc leia uma varivel de
instncia.
A Sun Mi crosyst ems desenvolveu uma conveno de atribuio de nomes em
torno de acessores de configurao e de obt eno, conheci da como JavaBean
Design Patterns. JavaBeans uma maneira padronizada de escrever seus
componentes. Se seus componentes obedecem a esse padro, voc pode co-
nect-Ias em qualquer IDE compatvel com JavaBean. Tal IDE poderia permitir
a construo visual de seus programas, usando os beans.
As convenes de atribuio Java so simples. A conveno JavaBean para
atribuio de nomes para acessores de obt eno e de configurao :
public void set<VariableNome>( <type> value )
publ1c <type> get<VariableName>()
onde <type> o tipo da varivel de instncia e <VariableName> o nome da
vari vel de inst ncia.
Encapsulamento: hora de escrever algum cdigo 53
Tome como exemplo um objeto Pessoa. Um objeto Pessoa tem um nome. Os
acessores de obteno e de configurao do nome poderiam ter o segui nt e
formato:
pub l ic void setName( String name )
publi c String getName()
Finalmente, voc chama mtodos como publ ic void setKeyl ( String keyl ) e publ ic void
setKey2( String key2 ) de mutantes, pois eles permitem alterar o estado interno do objeto.
Doub1 eKey demonstra o uso correto do encapsulament o. Empregando uma interface bem defini-
da, DoubleKey oculta sua implementao do mundo exteri or. Doubl eKey tambm bastante abs-
trata. Voc pode reutili zar Doubl eKey onde precisar usar hashing com duas chaves String.
Finalment e, Doubl eKey di vide corretam ente a responsabilidade, fornecendo apenas os mtodos
necessri os para atuar como uma chave.
Exposio do problema
No Di a 2, voc viu um Banco 00. No Banco 00, os clientes entram em uma fi la, enquanto es-
peram por um caixa. Mas no se preocupe, voc no vai escrever uma classe Queue. A linguagem
Java tem bastante suporte interno para estruturas de dados clssicas. Em vez disso, voc vai pro-
gramar uma classe de conta - a li nguagem Java ainda deixa o programador com alguns traba-
lhos a fazer.
Sej a essa uma conta corrente, uma conta poupana ou uma conta de mercado financeiro, todas
elas tm algumas caracteristicas compartilhadas. Todas as cont as tm um saldo. Uma cont a tam-
bm permitir que voc depos ite valores, saque valores e consulte o saldo.
Hoje, voc vai escrever uma classe de cont a. O Laboratrio 2 vem completo, com uma classe
Te11 er. A classe Te 11 er tem um mtodo ma in () que voc usar para testar a impl ementao de
sua conta.
A classe l eller espera uma interface pblica especfica. Aqui esto as regras:
Voc deve chamar a classe conta de Account.
A classe deve ter os dois construtores a seguir:
pub 1 i c Account ()

pub1; c Aceount( double in Hial_deposH )
O construtor noargs configurar o saldo inicial como 0.00. O segundo construt orconfigu-
rar o saldo inicial como i nitlal_deposit .
A classe deve ter os trs mtodos a seguir. O pri mei ro mtodo credita na conta o valor de
funds:
publlc vo"id depositFunds( double funds )
O mtodo seguinte debita na conta o valor de funds:
Dia 3
publ ic doubl e withdrawFunds( doubl e funds )
Entretanto, wi thdrawFunds () no deve permiti r um saque a descoberto. Em vez disso, se
funds for maior que o saldo, apenas debita o resto do saldo. wi thdrawFunds() deve retor-
nar a real quant idade sacada da conta.
O terceiro mtodo recupera o saldo corrente da conta:
pu bll c double ge tBalanee ()
Alm dessas regras, voc pode adicionar quaisquer outros mtodos que possa considerar tei s.
Entretanto, certifique-se de implementar cada um dos mtodos exatamente como listado an-
teriorment e. Caso contrrio, o caixa no poder fazer seu trabalho!
Uma vez que voc lenha terminado de escrever a classe Aceount , certifique-se de compi lar as
classes Account e Te 11 er. Uma vez fei to isso, execute o ma i n de Te 11 er, digitando ja '.Ia Te 11 er.
Se voc fez seu trabalho corretam ente, dever ver a sada ilustrada na Figura 3.1.
FIGURA 3 .1
A M/ida correia
de rel/er.
A prxima seo di scuti r as solues do Laboratrio 2. No prossiga at con-
cluir o Laboratri o 21
Solues e discusso
A Li stagem 3.2 apresenta uma possvel implementao de Account.
Encapsul amento: hora de escrever algum cdigo
LISTAGEM 3.2 Account .java
public class Account {
I
II dados privados
private double balancei
II const rutor
public Account( double init_deposit ) {
balance init_depos iti
I
publi C Account() {
II n!o precisa fazer nada. balance ter O como padro
I
II deposita dinheiro na conta
publ ic void deposltFunds( double amount ) {
balance balance + amount ;
I
II consu l ta o sal do
publ ic double get8al ance() I
return balance:
I
II saca fundos da conta
publi c double withdrawFunds( double amount ) I
I
if(amount > balance)1 II ajusta o valor
amount balance i
balance balance - amount i
return amounti
I
55
A classe Account ilustra os conceitos importantes existent es por trs do encapsul amento.
Account bastante abstrata. Ela funcionar como a base para mui tos tipos diferentes de cont as. A
classe Account oculta sua implementao atrs de uma interface bem definida. Finalmente, a
classe Account mostra uma divi so correta de responsabili dades, pois contm todo o conheci-
mento de como debi tar e creditar no saldo da conta. O conhecimento de como executar essas ta-
refas no 'vaza' para fora do objeto.
Dia 3
Entretanto, Accounl no perreita; ainda h espao para melhori a. Por questo de brevidade,
essa soluo de cl asse Accounl pula a validao do argumento. alm da verificao de saque a
descoberto si mples. Para usar no mundo real, voc precisaria incluir cdigo para validar todos os
parmetros dos mtodos.
laboratrio 3: o encapsulamento
o Di a 2 abordou trs caractersticas do encapsulamento eficaz:
Abstrao
Ocultao da implementao
Di viso da responsabilidade
Cada caracterstica urna habi lidade importante a ser domi nada, enquant o voc projeta e escre-
ve suas classes. Voc precisa aplicar todas as trs caractersticas pam ter objetos bem encapsulados.
Vamos apli car essas trs caractersticas em um jogo de cartas.
Primeiro, vamos aplicar a abstrao. Lembre-se de no abusar da abstrao. Voc ai nda tem um
problema para resolver e no pode resolver todos os problemas. Assim, voc deve pri meiro ten-
tar resolver os problemas que conhece!
O qu voc pode dizer generi cament e a respeito de jogos de carta j ogados com um baralho de
pquer padro?
Um bom lugar para comear no prprio mao de cartas. Um baral ho padro contm 52 cartas.
Voc pode embaralhar um mao, assim como escolher uma carta do baral ho, em qualquer posi -
o. Do mesmo modo, voc pode retomar uma carta para qualquer posio no mao. Qualquer outra
extrao apenas uma especial izao da escolha de uma carta a partir de qualquer parte do mao.
O que voc pode dizer a respeito das cartas em si?
Todas as cartas compartilham lima estrutura comum. Cada carta tem um naipe: ouros, copas, es-
padas ou paus. Cada cart a tambm tcm um valor: 2 a 10, valete, dama, rei ou s. A ni ca direren-
a de uma carta para outra o valor desses dois atributos.
Levado a um extremo, voc poderia tentar descrever cada tipo de mao de cartas, sejam elas car-
tas de beisebol ou de tar. Novamente, quando voc comea a abstrair, precisa cert ificar-se de
no abstrair em demasia.
E quanto a ocultao da implementao?
A no ser que voc roube enquanto joga baralho, nunca ver o que est no mao, at receber uma
carta. Voc tambm no insere cartas que no fazem parte do baral ho.
Final mente, e quanto responsabilidade?
Encapsul amento: hora de escrever algum cdigo 57
No mundo real, as cartas em si no fazem mui to. Uma carta simplesmente exibe seu nai pe e seu
valor. Uma cana tem um estado: face para cima ou face para baixo. Do mesmo modo, um bara-
lho no faz muito no mundo real. Em vez disso, o carteador aque le que embaralha e distribui as
cartas. O baralho simplesmente contm as cartas de j ogo.
No mundo dos computadores, uma cana conter seu naipe, valor e estado. Em um programa
simples, uma cana tambm saber como ser apresentada. Um baral ho criar e conter as cartas.
Finalmente, o caneador saber embaral har as cart as e distribuir uma carta.
NeTA
Posteri ormente, voc aprender a importncia de separar a exibio de seu mo-
delo/dados. Entretanto, para nossos objetivos aqui, voc pode mi sturar os dois.
Exposio do problema
Use as classes de projeto de descrio de carta de pquer para representar as cartas, o mao de
cartas e o caneador. EllIo, voc deve escrever um pequeno mtodo mai n() , que instancie o car-
teador e seu mao de canas, embaralhe as cartas e, em seguida, imprima o baral ho.
Este laboratrio deixa a voc mui ta margem de moviment o, enquanto projeta suas cartas, o bara-
lho e o carteador. Ao pensar nas classes que voc criar, certi fi que-se de considerar a ocul tao
da implementao e a di viso da responsabilidade. Coloque a responsabi lidade apenas onde ela
pertence e, quando voc a colocar, certifique-se de que ela no 'vaze'.
NeTA
Veja java.lang.Math.randomH para a gerao de nmeros aleatrios. A funo
randomO ser til para embaralhar o mao. Voc pOde obter a documentao
completa das APls Java no endereo http://www.javasoft.com/.
Por exemplo, (i nt ) fMath.randomO * 52) fornecer um nmero entre O e 51.
A prxima seo discutir as solues do Laboratrio 3. No prossiga at com-
pletar o laboratrio 3!
Solues e discusso
A Listagem 3.3 apresenta uma possivel classe Ca rdo
LI STAGEM 3,3 Card. j ava
public cl ass Card {
private int ranki
Dia 3
LI STAGEM 3.3 Ca rd. java (con t inuao)
private i nt suit;
priva te boolean face _up ;
II constantes usadas pa ra i nstanciar
II na i pes
publ ic static final i nt OIAMONOS 4
o
publ i c static final i nt HEARTS 3
o
publ i c static fina l i nt SPAOES 6;
public stati c fi nal
'o,
CLUBS 5;
II valores
pu bl ic static fi na l in t
'"O
2 ;
publi c static fi na 1 i nt THREE 3 ;
publi c static fi nal int FOUR 4
o
publi c static fi nal i nt FIVE
5
o
publ ic st atic fi na 1 int
SI'
6;
publ ic st atic fina l
'o,
SEVEN
,.
o
publ ic stat ic fi nal i nt EIGHT
8
o
publ ic static fina l i nt NINE 9 ;
publ ic stat i c fina l
, o,
TEN 10;
publ ic static f inal i nt JACK 74
o
publ i c st at i c f inal i nt QUEEN 81 ;
publi c stati c f i na 1
, o,
KING 75 ;
publ ic stati c fi na 1 i nt ACE 65;
II cria uma nova cart a - usa apenas as cons tantes para i ni cia l izar
pu blic Card( i nt suit, int rank ) I
}
II Em um programa real . voc preci sari a fazer a val i dao dos argumentos.
this.suit sui t;
this.rank rank;
publi c int getSuit () {
ret urn suit;
}
publ ic i nt getRank() {
return rank;
}
publ iC voi d faceUp() {
face_up true;
}
publ i c voi d fa ceOown() I
Encapsul amento: hora de escrever algum cdigo
LISTAGEM 3 .3 Ca rd. java (continuao)
}
}
publl C boolean l sFaceUp() {
return face_up;
}
public String display() {
St ring di spl ay ;
H( ra nk > 10
} I
display Str ing .valueOf( (char) rank
} el se (
di splay

String . valueOf( rank );
}
switch ( suit ) (
case OIAMONOS:
return dlsplay + String.val ueOf(
case HEARTS:
return displ ay + St r ing. val ueOf(
case SPAOES:
retur n display + St r ing.val ueOf{
default:
return display + Str i ng.va l ueOf(
}
}
} ;
(char) OIAMONOS ) ;
(char) HEARTS } ;
(char) SPAOES } ;
(char) CLUBS };
59
A definio da classe Card comea defini ndo vrias constantes. Essas constantes enumeram os
valores e naipes de carta vli dos.
Voc notar que, uma vez instanciado, no possvel mudar o valor da cm1a. As insI!i ncias de
Card so imutveis. Tornando a carta imutvel , ningum poder alterar erroneamente o valor de
uma carta.
Novo TERMO Um objelo imlltvel aquele cujo estado no muda, uma vez construido.
A classe Card responsvel por conter seu nai pe, assim corno o valor. A carta tambm sabe
como retornar urna representao de String de si mesma.
A Li stagem 3.4 apresenta uma possvel implementao de Oeck.
LISTAGEM 3.4 Oeck.java
public class Oeck {
}
}
private java.util . LinkedList deck :
publiC OeckO {
bulldCardsO;
}
public Card get( int index) {
if( index < deck . size() ) {
return (Card) deck.get( index ) :
}
return null :
}
publ iC void replace( int index. Card card ) {
deck.set( index. card ) ;
}
publ ic int size() (
return deck.size():
public Card removeFromFront() (
if( deck.size() > O ) (
Card card (Card) deck.removeFirst() ;
return card;
}
return null;
}
public void returnToBack( Card card ) {
deck.add( card );
}
private void buildCards() {
}
deck new java. util.LinkedListO ;
deck.add( new Ca rd( Card .CLUBS . Card .TWO )} :
deck.add( new Card( Card.CLUBS. Card. THREE ) };
deck.add( new Card( Card.CLUBS . Card.FOUR )} ;
deck.add( new Card( Card.CLUBS. Card.FIVE )}:
/1 a definio compl eta foi cortada por brevidade
/1 veja a l istagem compl eta no cdigo-fonte
Encapsul amento: hora de escrever algum cdigo 61
A classe Deck responsvel por instanciar as cartas e, em seguida, fornecer acesso a elas. A clas-
se Oeck fornece mlodos para recuperar c rclomar as cartas.
A Li stagem 3.5 apresenta a implementao de Oeal er.
LISTAGEM 3.5 Oea 1 er . java
publ i c class Dealer I
I
private Deck deck i
publiC Dea l e r ( Deck d li
deck =d i
I
public voi d shuffle() 1
I
Il torna o array de cartas aleatrio
int num_ca rds deck.size()i
for( in t i .. O; i < num_c ards; i ++ ) I
I
int index " (int)( Math.random() * num_cards )i
Card card_i .. ( Card ) deck.get( i ) ;
Card card_index a ( Card ) deck.get( index )i
deck.replace( I. card_index ) i
deck.replace( index , card i )i
public Card dealCard() I
if( deck.size() > O ) I
return deck. remove FromFront() ;
I
return null;
I
A classe Dealer responsvel por embaral har o mao e di stribuir as cartas. Essa implementao
de Oeal er honesta. Outra implementao de Deal er poderia dar as cartas a partir do final do ba-
ralho!
Todas as trs classes tm uma diviso da responsabilidade clara. A classe Card representa cartas
de pquer, a c lasse Deck contm as cartas e a classe Oea ler distribui as cartas. Todas as trs clas-
ses tambm ocultam sua implementao. Nada sugere que a classe Oeck tenha realmente uma
UnkedUs t de cartas.
Dia 3
Embora Ca rd possa definir vrias constantes, isso no compromete a integridade de sua imple-
mentao, pois a classe Ca rd est livre para usar as constantes como quiser. Ela tambm est li-
vre para mudar os valores das constantes a qualquer moment o.
O mtodo bui l dCards() de Deck destaca uma deficincia da ocultao da implementao. Voc
poderi a instanciar cartas com nmeros de 2 a 10 em um lao for. Se voc examinar as constan-
tes, ver que 1WO a TEN contam de 2 alO, seqencialment e. Tal lao mui to mais simples do que
instanciar cada carta individualmente.
Entretanto, tal suposio o vincul a aos valores correntes das constantes. Voc no deve penn itir
que seu programa se torne dependente de determinado valor, escondido na constante. Em vez
disso, voc deve usar a constante cegamente, chamando Cardo TWO , Card. THREE, etc. Voc no
deve fazer quaisquer tipos de suposies sobre o valor. Card poderia redefini r os valores das
constantes a qualquer momento. No caso de bui 1 dCards () , fc il cair na tentao de usar os va-
lores das constantes di rctamcnle.
Aqui, o contrato entre Card e o usurio das constantes de Card so os nomes das constantes e no
seu valor subjacente. O Dia 12, "Padres avanados de projeto", apresentar urna soluo um
pouco mais elegante do que esse uso de constantes.
laboratrio 4: estudo de caso -
de primitivas Java (opcional)
os pacotes
o Laboratrio 4 um laboratrio opcional. Embora a concluso do laboratrio
d a voc mais idias sobre a programao orientada a objetos, sua concluso
no necessria para ter xito nos prximos dias.
Cada linguagem orientada a objetos tem suas prprias regras para detenninar o que e o que no
um objeto. Algumas linguagens orientadas a objetos so mais 'puras' que outras. Uma lingua-
gem puramente ori entada a objetos, como a Smalltalk, considera ludo um objeto, at mesmo
operadores e primitivas.
Novo TERMO Uma linguagem ori entada a objetos pllra suporta a noo de que ludo um objeto.
Em uma linguagem puramente orientada a objelos, tlldo- classes, primitivas, operadores e at
blocos de cdigo - considerado um objeto.
A linguagem Java tem suas prpri as regras para determinar o que e o que no um objcto. Na
linguagem Java nem tudo um obj eto. Por exemplo, a linguagem Java declara diversos valores
de primiti vas. As primitivas no so consideradas objetos na linguagem Java. Essas pri mitivas
compreendem boolean, char, byte, short, i nt, 10ng, float c double.
Encapsulamento: hora de escrever algum cdigo 63
Novo TERMO Uma linguagem orielllada a objelos no considera tudo um objclO.
As primiti vas oferecem algumas vantagens em relao os objetos. Para usar uma primiti va, voc
no precisa instanciar uma nova instncia usando new. Como resul tado, usar uma primi tiva muito
mais eficiente do que usar um objeto, pois ela no sofre da sobrecarga associada aos objetos.
Por outro lado, s vezes voc achar o uso de primitivas limitant e. Voc no pode tratar pri miti-
vas como objctos. Isso signifi ca que voc no pode us-Ias em lugares que exigem um objelo.
Considere java . uti 1 . Vector, da colco de classes genricas. I)ara colocar um valor no vetor,
voc precisa chamar o mtodo add () do vetar:
public boolean add( Object o ) i
Para armazenar um valor no vetor, o valor deve ser um obj eto. Colocado de maneira simples, se
voc quiser colocar lima pri mitiva em um vetor, estar sem sorte.
Para cont ornar essas fa lhas, a linguagem Java tem vrios pacotes de primitivas, incluindo Boo-
lean, Character, Byte, Ooubl e, Fl oa t, Integer, l ong e Short. Essas classes so chamadas de pa-
cotes, pois elas contm, ou possuem, um valor de pri miti va.
Novo TERMO
Um pacole um objeto cujo nico propsito conter outro objcto ou primiti va. Um pa-
cote fornecer qualquer nmero de metodos para obter e manipularo valor possudo.
Vamos considerar a interface pblica de Boolean, que est delineada na Listagem 3.6.
LISTAGEM 3.6 java.1ang.Boolean
publ i C final cl ass Boolcan impl ements Se r ial izable I
publi c Boolean( boolean value ) ;
I
publ i c Boolean( String s l i
publiC st atic final
public static final
publi c static final
Bool ean
Boolean
ClASS
FAlSE;
TRUEi
TYPEi
publiC static boolean getBoolean( St ring name }i
publi c stati c Boolean valueOf( String s )i
publ iC boolean booleanValue() ;
public boolean equals( Object obj li
publ ic int hashCode();
publ i c Stri ng toSt r i ng( )i
NOTA
Dia 3
Final se ref ere ao conceito de impedir que classes descendentes alterem esse
el emento, quando herdadas. A herana ser discutida no Dia 4, -Herana: ob-
tendo algo para nadaM.
Impfements est relacionado constr uo de ' interface' especial da lingua-
gem Java, discuti da no Apndice B, ' Aesumo do Java' .
Internamente, o pacote Bool ean conter uma primitiva booleano Assim, para passar um valor
boa 1 ean para um vetor, voc precisaria primeiro instanciar um pacote Boo1 ean. possuir a pri-
mitiva boo 1 ean e passar esse pacote para o vetor.
A interface Boo 1 ean introduz outros recursos das linguagens orientadas a objetos: mto-
dos de cl asse e vari veis de classe.
At agora, todos os mtodos e variveis que voc viu eram mtodos de instncia e va-
riveis de instncia. Isto , cada varivel e cada mtodo est ligado a alguma instnci a de
objeto. Para chamar o mtodo ou acessar a varivel. voc deve ter uma instncia do objeto.
O fat o de que voc precisa de uma instncia freqentemente lgico. Considere o m
todo booleanvalueO de Boolean. O mtodo booleanValueO um mtodo de inst ncia. O
valor que o mtodo retorna depender do est ado interno das instncias de Boo I ean indi-
viduais. Uma inst ncia pode possuir o valor true, out ra pode possuir o valor fal se. O
valor retornado depender do val or que a instncia contm int ernamente.
Agora, considere o mtodo get8001 ean() de Boolean. Esse um mtodo de classe. Se
voc estudar a definio de getBooleanO, notar a pal avra-chave static. Na li ngua-
gem Java, a palavra-chave statle declara que o mtodo ou varivel um mtodo ou
var ivel de classe.
Ao contrri o das variveis e mtodos de instncia, os mtodos e varivei s de classe no
esto vinculados a nenhuma instncia. Em vez disso, voc acessa mtodos de cl asse
atravs da prpria cl asse. Assim, para chamar getBooleanO, voc no precisa de uma
instncia (contudo, voc ainda poderia chamar o mtodo como se el e fosse um mtodo
de instncia). Em vez disso, voc pode simplesmente chamar Boolean.getBoolean(). A
resposta de getBoolean() no depende do estado de nenhuma instncia. Por isso, ele
pode escapar impunemente, sendo declarado como um mtodo de classe.
Novo TERMO
Variveis de classe so variveis que pertencem cl asse e no a uma
instncia especfi ca. As variveis de cl asse so compartilhadas entre
todas as inst ncias da classe.
Novo TERMO
Mtodos de classe so mtodos que pertencem classe e no a uma
instncia especifica. A operao executada pelo mtodo no depen-
dente do estado de qualquer instncia.
As variveis de classe funcionam da mesma manei ra. Voc no preci sa de uma instn-
cia para acess-Ias. Entretanto, elas tambm t m outro uso. Como a vari vel mantida
no nfvel da classe, todas as instncias comparti lham a mesma varivel (e, se for pbli ca,
todos os objetos podero compartilh-Ia). As variveis de cl asse diminuem os requisi-
t os de memria. Considere publ i e statle final Boolean FAlSE'. Essa uma constante que
possui o valor fa I se. Como ela esttica, todas as instncias comparti lham essa mesma
constante. Cada instncia no precisa de sua prpria cpi a. Considere a classe, Counte<!-
Object, a seguir:
Encapsul amento: hora de escrever algum cdigo
publlC class CountedObject {
I
private static i nt instances;
,u Cri a novo CountedObject */
public CountedObj ectO {
i nstances++:
I
oubl ic s tat ic int oetNumberi ns tancesO I
return instances:
I
oublic static void mainr Strino n aros) I
CountedObiect obi = null:
I
for{ int i = O: i < 10: i++ I I
obi new CountedObiect():
I
Svstem.ouLorintlnl "Instances created: " +
ob:i .oetNumberInstances II \:
/I note oue isso tambm funcionari
Svstem.ouLorintlnl "Instances created: +
CountedObiect.oetNumberlnstancesO \:
65
CountedObject declara uma varivel de classe chamada instances. Ela tambm declara
um mtodo de classe para recuperar o valor, getNumberInstances (). Dentro do constr utor,
o valor incrementado sempre que uma instncia criada. Como todas as instncias
compartilham a varivel, a varivel i nstances atua como um contador. medida que
cada objeto criado, ela incrementa o contador.
O mtodo ma i n () cria 10 instncias. Voc notar que pOde usar uma instncia para fazer
a chamada de getNumberlnstances{) ou a prpria classe.
Se voc vai ou no declarar um mtodo ou varivel esttica uma deciso de projeto.
Se o mtodo ou varivel for independente do estado de qualquer instncia, provavel-
mente uma boa idia torn-lo um mtodo ou varivel de classe. Entretanto, voc no
pode declarar variveis e mtodos que so dependentes da instncia, como estticos,
como o mtodo booleanValueO de Boolean.
Voc pode ter feito algumas observaes a respeito de Boo I ean. Se voc estudar a interface, nota-
r que no h meios de mudar a valor bool ean possudo, uma vez que tenha inslanciado a instn-
cia de Boolean! Como voc no pode mudar seu valor, diz-se que as instncias de Boolean so
imutveis.
Existem ocasies em que usar um objeto imutvel fundamental. Se voc estiver fami liari zado
com linhas de execuo, um obj cto imutvel inerent emente seguro quanto a linha de execuo,
pois seu estado nunca pode mudar.
Dia 3
Entretanto, existem ocasies em que os objetos imutveis causam mais danos do que trazem
vantagens. No caso dos pacotes de pri mitivas, a sobrecarga da instanciao de um pacote para
cada primiti va pode se tornar dispendiosa.
Exposio do problema
Para o Laboratri o 4, voc precisa criar um pacote de primit iva Bool ean mutvel. No mnimo,
esse pacote deve pennitir que voc obtenha e confi gure o valor possudo. O pacote tambm
deve fornecer dois construtores: um construt or noargs e um construtor que recebe o valor inicial
do pacote.
Sinta-se livre para adicionar quaisquer outros mtodos que considere conveniente. Entretanto,
no se esquea de seguir as regras do encapsul amento eficaz.
Talvez voc ache interessante examinar a discusso do Apndice B sobre a palavra-chave sta-
tic. se decidir fornecer todos os mtodos oferecidos pelo pacote de primitivas Bool ean.
ALERTA
A prxima seo discutir as solues do Laboratrio 4. No prossiga at com
pletar o Laboratrio 4!
Solues e discusso
A Li stagem 3.7 apresenta uma possvel soluo para o Laboratri o 4.
LISTAGEM 3.7 MyBoolean.java
publi c class MyBoo l ean {
II algumas cons tantes, por convenincia
publi c static final Class TYPE K Boolean.TYPE;
private boolean va l ue;
II construtor sem argumento - tem false como padro
publi c MyBooleanO {
val ue fal se ;
}
II configura o valor inicial como value
publi c MyBool ean( boolean value ) {
t his. val ue vai ue;
}
publ ic boolean booleanVa lueO {
Encapsul amento: hora de escrever algum cdigo 67
LI STAGEM 3.7 MyBoolean.java (continuao)
}
return value :
}
publiC void setBooleanValue{ boolean va l ue ) I
this . value E value:
}
II para getBoolean e valueOf. podemos simplesmente delegar para Boolean
II voc vai aprender mais sobre delegao no Captulo 4
public static boolean getBoolean( St ring name ) I
return Boolean.getBoolean( name );
}
public static MyBoolean valueOf( St ring s ) {
ret urn new MyBoolean( Boolean.getBoolean( s ) ) ;
}
II definies de hashCode . equals e toString omit i das por brev i dade
MyBoolean mantm a interface pbl ica encontrada em Boolean, com trs excees:



MyBoo 1 ean adiciona um mutant e: pub 1 i c voi d setBoo 1 eanVa 1 ue ( boa 1 ean va 1 ue ). Esse
mutante permi te que voc mude o valor dos pacotes.
MyBool ean redefi ne val ueOf () de modo que retorne uma instncia de MyBoolean, em vez
de Boolean.
MyBool ean remove as constantes TRUE e fAlSE. Agora que MyBoolean mutant e, esses va-
Iares no se tornam constantes adequadas, pois seus valores podem ser alterados por qual-
quer um, a qualquer momento.
A soluo do Laboratrio 4 tambm fornece um vislumbre do Dia 4, "Herana: obtendo algo
para nada". Mtodos como va 1 ueOfO demonstram a delegao. A soluo de cdigo-fonte com-
pleta do Laboratrio 4 tambm proporciona urna viso da herana e da sobrecarga, atravs dos
mtodos toString() I hashCode() e equals().
Perguntas e respostas
P No Laboratrio 3, voc escreveu, "Essa implementao de Deal er honesta. Outra
implementao de Dea1 er poderia distribuir as cartas a partir do final do baralho! "
O que voc quer dizer com outra implementao?
R Voc pode dizer que os mtodos shu ffl eC) e dea 1 Ca rdO constit ucm a intcrface pblica
de Dea ler. A classe Dea 1 er apresentada honesta. Ela di stribui as cartas a partir do incio
Dia 3
do baral ho. Voc poderia escrever outro carteador, chamado OishonestDealer, que ti-
vesse a mesma interface pbl ica. Entretanto, esse carteador poderi a distribuir as cartas a
partir do final do baralho.
Voc chama esse carteador de outra implementao, porque ele reimplementa uma inter-
face igual quela encont rada em Oea 1 er. Entretanto, essa classe implementa a funcionali-
dade oculta no mtodo de forma ligeiramente di ferente.
P O encapsulamento pode ser prejudicial?
R Na verdade, o encapsulament o pode ser prejudicial. Imagine que voc tenha um compo-
nente que efetue clculos matemticos. Suponha que voc prec ise manter determinada
preciso, quando concluir seu clcul o. Infelizmente, o componente pode encapsular
completamente a quantidade de preciso que mantm. Voc poderia acabar com um va-
lor incorrelo, se a implementao usasse uma preciso diferente daquela que precisa.
Voc pode acabar com erros estranhos, se al gum alterar o componente.
Ass im, o encapsulamento pode ser prejudicial, se voc precisar de um controle preciso
sobre as maneiras pelas quais um objeto manipula seus pedidos.
A nica defesa a boa documentao. Voc deve documentar todos OS detalhes e suposi-
es importantes da implementao. Uma vez documentados, voc no poder fazer al-
teraes facilmente cm quaisqucr dctalhcs ou suposies documentados. Assim como no
componente matemti co, se voc fizer uma alterao, correr o risco de prejudicar todos
os usuri os desse objeto.
Workshop
As perguntas e respostas do teste so fornecidas para seu melhor entendimento. Veja as respos-
tas no Apndice A, " Respostas".
Teste
I. Examine a c lasse Account do Laboratrio 2. Qual(is) rntodo(s) (so) mutante(s)?
Qual(is) rntodo(s) (so) acessor(es)?
2. Quais so os dois tipos de construtores? A partir das sol ues de laboratrio, encont re
um exemplo de cada ti po de construtor.
3. (Opcional) Boolean, conforme discut"ido no Laboratrio 4, declara trs variveis pbli-
cas. Neste caso, o uso de vari veis pbl icas aceitvel. Voc pode explicar por que est
certo usar variveis pbl icas nesse caso?
4. (Opcional) Como voc pode tomar a soluo do Laboratri o 3 mais eficiente?
Encapsulamento: hora de escrever algum cdigo 69
5. Por que voc acha que a soluo do Laboratrio 3 no criou uma classe Card separada
para cada nai pe?
6. No Laboratri o 3, voc explorou a di viso da responsabilidade. Quais vantagens a divi
so da responsabil idade proporciona s classes Ca rd, Deck e Dealer?
Exerccos
I. (Opcional) Pegue o Laboratrio 2 e abstraia Ooub leKey ainda mais. Refaa o projeto de
Doubl eKey de modo que ela possa aceitar qualquer tipo de objeto como chave - no ape
nas urna String.
Para que sua nova classe Ooub 1 eKey funcione, voc precisar alterar a definio dos mto-
dos equal s () e hashCode{). Esses mtodos foram omitidos por brevidade nas solues im
pressas. Entretant o, os mtodos esto disponveis no cdigo fonte completo das solues.
2. (Opcional) No Laboratri o 3, as instncias de Card sabem como se apresentar. Entrctan
to, a classe Oeck no sabe como se apresentar sozinha. Refaa o projeto de Oeck de modo
que as instncias de Oeck saibam como se apresentar.
SEMANA 1
DIA
Herana: obtendo algo para nada
Nos trs ltimos dias, voc se concentrou em aprender sobre o primeiro pilar da programao
orientada a objelos: encapsulamento. Embora o encapsulamento seja um conceito fundamenta l
na POO, h mais na histria do que apenas suportar TADs e mdulos si mples. Na verdade, a
POO ofereceria muito pouco cm relao ao estilo de programao antigo, se ludo que ela fizesse
fosse oferecer encapsulamento simples. claro que a POO oferece muito mais.
A POO vai alm, adicionando dois outros recursos: herana e polimorfismo. Voc vai passar os
prximos dois dias considerando a herana, o segundo pilar da POO.
Hoje voc vai aprender:
O que herana
Os diferentes tipos de herana
Algumas das armadi lhas da herana
Dicas para a herana eficaz
Como a herana atende aos objetivos da 00
o que herana?
Ontem, voc viu como o encapsulamento penniteescreverobjetos bem definidos e indepcnden
teso O encapsulamento permite que um objeto IIse outro obj eto, atravs de mensagens. O liSO
apenas uma das maneiras pelas quais os obj etos podem se relacionar na POO. A POO tambm
fornece uma segunda maneira de relacionamento entre os objetos: herana.
Dia 4
A herana permite que voc baseie a defi ni o de uma nova classe em uma classe previamente
existente. Quando voc baseia uma classe em outra, a definio da nova classe herda aut omati-
camente todos os atributos, comportamentos e implementaes presentes na classe previamente
existente.
Novo TERMO
Herana um mecanismo que pennite a voc basear uma nova classe na definio
de uma classe previamente existente. Usando herana, sua nova classe herda todos
os atributos e comportamentos presentes na classe previamente existente. Quando uma classe
herda de outra, todos os mtodos e atributos que aparecem na interface da classe previamente
existente apareceri\o automaticamente na interface da nova classe.
Consi dere a classe a segui r:
publi c class Empl oyee {
I
private String f1rst_name

private String last_name

privat e double wage

public Employee( String first_name . Stri ng last_name. double wage ) {
this .first name f i rst_name

this.last name last_name

t his.wage wage

I
public double getWage() {
return wage

I
public String getFirstName() I
return fi rst_name

I
publ iC String getLastName() I
return last_name

I
Instncias de uma classe como Emp 1 oyee podem aparecer em um aplicat ivo de banco de dados
de folha de pagamento. Agora, suponha que voc precisasse modelar um func ionrio co-
missionado. Um funcionrio comiss ionado tem um salrio-base, mais uma pequena comisso
por venda. Alm desse requisito simples, a classe Corrmi ssi onedEmployee exatamente igual
classe Empl oyee. Afinal, um objeto COfllTri ssi onedEmployee um objeto Employee.
Usando-se o encapsulamento di reto, existem duas maneiras de escrever a nova classe COIIIlli ss i -
onedEmpl oyee. Voc poderi a si mplesmente repetir o cdigo encontrado em Emp loyee e adicionar
Herana: obtendo algo para nada
o cdigo necessrio para cont rolar comisses e calcular o pagamento. Entretanto, se voc fizer
isso, ter de mant er duas bases de cdigo separadas, mas semel hantes. Se voc precisar corrigir
um erro, ter de faz-lo em cada lugar.
Assi m, simplesmente copiar e colar o cdigo no boa uma opo. Voc precisar tentar outra
coisa. Voc poderia ter uma varivel employee dentro da classe Corrrni ss ionedEmpl oyee e dele-
gar todas as mensagens, como getWageO e getfirstNameO, instncia de Employee.
Novo TERMO
Delegaao o processo de um objeto passar uma mensagem p.1ra outro objeto, para
atender algum pedido.
Entretanto, a delegao ainda o obriga a redefinir tooos os mtooos encontrados na interface de
Emp 1 oyee para passar tooas as mensagens. Assim, nenhuma dessas duas opes parece sati sfatria.
Vamos ver COmO a herana pode corri gir esse problema:
publi c class CommissionedEmployee extends Employee {
}
private double commission;
private int units;
II o custo por unidade
II controle do nmero de unidades vendidas
publiC CommissionedEmployee( String firs t _name. String last_name.
double wage. double commission ) (
}
super( fi rs t _name , last_name , wage ); II chama o construtor original
II para inicializar corretamente
11 0 valor da comisso
this.commission commission;
publ ic double calculatePay() I
return getWage() + ( commission * uni ts ) ;
}
public void addSales( lnt units ) {
thiS.units this.units + units ;
}
public void resetSales() {
units O;
}
Aqui, CommissionedEmpl oyee baseia sua definio na classe Empl oyee j existente. Como
Commi ss i onedEmp I oyee herda de Emp 1 oyee. getFi rs tName O, getLas tName O, getWage O.
first_name. l ast _name e wage se tomaro tooos parte de sua defi nio.
Dia 4
Como a interface pblica de Empl oyee se toma parte da interface de Conmi ssionedEmployee, voc
pode enviar para ConmissionedEmpl oyee qualquer mensagem que poderia enviar para Employee.
Considere o mtodo ma inO a seguir, que faz exatamenle isso:
publ i c static yoid ma;n(String [) args ) 1
J
Commiss1onedEmployee c
new Coomi ss i onedEmp I oyee ("Mr. " Sa 1 es" 5. 50 . 1. 00) ;
c.addSal es(5);
System.out.println( KFirst Name: " + c.get FirstNameO ) ;
System.out.println( "last Name : + c.get l astNameO ) ;
System.out.pri ntln( "Base Pay:$ + c. getWageO };
System.out.pri ntln( "Total Pay:$ " + c.calculat ePayO ) ;
A Figura 4. I ilustra o que voc ver aps a execuo desse cdigo.
FIGURA 4 .1
S(l(/a ge/'(/da a punir de
COIIlfIiss ionedflllp I oyee.
Por que herana?
Conforme voc viu no lt imo exemplo, s vezes o relacionament o de liSO do encapsulamento
simples no suficiente. Entretanto, h mais na herana do que si mplesmente herdar urna inter-
face pblica e impl ementao.
Conforme voc ver posteriormente no dia de hoje, a herana permite classe que est herdando
redefi nir qualquer comportamento de que no goste. Tal recurso permite que voc adapte seu
soft ware, quando seus requi sitos mudarem. Se voc precisar fazer uma alterao, bastar escre-
ver uma nova classe, que herde a antiga funcionalidade. Ento, sobreponha a funcionalidade que
precisa mudar ou adicione a funcional idade que est fal tando e pronto. A sobreposio interes-
sante. pois permite mudar a maneira como um objeto funciona sem tocar na definio original da
classe! Voc pode deixar seu cdigo bem testado e validado intacto. A sobreposio funciona
mesmo que voc no tenha o cdigo-fonte original de uma classe.
A herana tem outro uso mui to importante. No Dia I, "Int roduo programao ori ent ada a ob-
jelos", voc viu como uma classe agrupa objetos relacionados. A herana pemlite que voc agrupe
classes relacionadas. A POO sempre se esfora por produzir software natural. Assi m como no
mundo real, a POO pennite que voc agrupe e classifi que suas classes.
Herana: obtendo algo para nada

"E um" versus "tem um": aprendendo
quando usar herana
Para apresemar os mecanismos de herana, a primei ra seo abordou o que conhecido como
herana de implemelltao. Conforme voc viu, a herana de implementao permite que suas
classes herdem a implementao de outras classes. Ent retanto, somente porque uma classe pode
herdar de Qlura no significa que isso deve ser feito!
Ento, como voc sabe quando deve usar herana? Felizmente, existe uma regra geral a ser se-
guida, para evitar uma herana incorreta.
Quando voc est considerando a herana para reut i lizao ou por qualquer outro moti vo, preci-
sa primeiro perguntar-se se a classe que est herdando do mesmo tipo que a classe que est sen-
do herdada. O fato de pensar em termos de tipo enquant o se herda freqUentemente rererido
como teste ' um' .
,
Novo TERMO
E 1111/ descreve o relacionamento em que uma classe considerada do mesmo tipo de
outra.
Para usar ' um' , voc diz a si mesmo, "um objeto ConmissionedEmployee ' um' Empl oyee".
Essa declarao verdadeira e voc saberi a imediatamente que a herana vlida nessa sit ua-
o. Agora, pare e considere a interface Iterator Java:
public interface I terator 1
J
publ ic boolean hasNext();
publ ic Object next()j
public void remove()j
Digamos que voc qui sesse escrever uma classe que implementasse essa interrace. Se voc lem-
brar do Dia 2, poder perceber que uma implementao de Queue poderia ser til na const ruo
de sua interrace Iterator. Voc poderia usar toda a implementao de Queue previamente exis-
tente, para conter os elementos da interface Itera tor. Quando voc precisa verificar hasNext ()
ou remove () , pode simplesmente chamar o mtodo Queue correto e retornar o resultado.
Nesse caso, a herana fornecer um modo rpido de implementar lima interface Iterator. Entre-
tanto, ames de comear a codificar, no se esquea do teste ' um'.
"Uma interface Itera tor ' uma' Queue". Claramenle essa declarao fa lsa. Esquea-se de her-
dar de Queue!
NOTA
Uma Queue pode ' ter uma' interface Iterator que saiba como percorrer os ele-
mentos.
Dia 4
Existi ro muitas situaes onde o teste ' um' falhara, quando voc quiser reuti lizar alguma im-
plememao. Fel izment e, existem outras maneiras de reutil izar implementao. Voc sempre
pode usar composio e delegao (veja o quadro a seguir). O teste ' tem um' salva o dia.
NovO TERMO
Tem U/II descreve o relacionamento em que uma classe contm uma instncia de ou-
tra classe.
NovO TERMO
Composi(io significa que urna classe implementada usando-se variveis intemas
(chamadas de variveis membro), que contm instncias de outras classes.
Composio uma forma de reutilizao que voc j viu. Se voc no puder herdar,
nada o impede de usar instncias da out ra classe dentro da nova classe. Quando voc
quiser usar os recursos de outra classe, use simplesmente uma i nstncia dessa classe
como uma de suas partes constituintes. claro que voc sofre as limitaes apresenta
das anteriormente.
Considere novamente o exemplo Queuej lterator. Em vez de herdar de Queue, a interface
Iterator pode simplesmente criar uma instncia de Queue e armazen-Ia em uma vari-
vel de instncia. auando a interface Iterator precisa recuperar um elemento ou verifi-
car se est vazia, ela pode simplesmente delegar o trabalho para a instncia de Queue,
como demonstrado na Figura 4.2.
FIGURA 4.2
Uma illll!lface Iterator
delegando chamadas de
miooo para Queue.
HasNextU
InstAncia de lteflllQl'
IsEmptyU InslAncia
de allelle
Quando usa composio, voc escolhe cuidadosamente o que vai usar. Atravs da dele-
gao, voc pode expor alguns ou todos os recursos de seus objetos constituintes. A Fi-
gura 4.2 ilustra como a interface I terator direciona o mtodo hasNext () para o mtodo
isEmptyO de Queue.
importante indicar que a delegao difere da herana de duas maneiras importantes:
1. Com a herana. voc tem apenas uma instnci a do objeto. Existe apenas um obje-
t o indi visvel, pois oque herdado se torna uma part e intrinseca da nova classe.
2. A delegao geralment e fornece ao usurio apenas o que est na interface publ i-
ca. A herana normal d mais acesso aos detalhes internos da classe herdada. Va-
mos falar a respei to de t al acesso em detal hes, no final da li o de hoj e.
Herana: obtendo algo para nada 77
Aprendendo a navegar na teia emaranhada
da herana
Os conceitos de ' um' e composio mudam a natureza da discusso sobre herana da ambicio-
sa reutil izao da implementao para inter-relacionamentos de classe. Uma cl asse que herda de
outra deve se relacionar com essa classe de alguma maneira, para que os relacionamentos ou hie-
rarqui as de herana resultant es faam sent ido.
Novo TERMO
Uma hierarquia de herana um mapeamento do tipo rvore de relacionamentos
que se ronnam entre classes como resultado da herana. A Figura 4.3 ilustra uma hierar-
quia real extrada da linguagem Java.
FIGURA 4.3
Fermat
Um exemplo de hierarqllia
de j ovo. text o
tmefemm MluageF"""' 1 Num"-rf"ormM
Simpleo.tlForrnet
ChoiceForm.1t Ded .... IForm.t
A herana define a nova classe, afilha, em termos de uma classe antiga, a progenitora ou me.
Esse relacionamento filha-progenitora ou filha-me o relacionamento de herana mais sim-
ples. Na verdade, todas as hi erarquias de herana comeam com uma progenitora e uma fil ha.
Novo TERMO
Novo TERMO
A classe filha a classe que est herdando; tambm conhecida como subclasse.
A classe progenitora ou me a classe da qual a fi lha herda diretamente; ela tambm
conhecida como superclasse.
A Figura 4.4 ilustra um relacionamento progenitora/filha. NumberFonnat a progenitora das duas
filhas Chol ceFo nnat e Dec i ma lFonnat .
Dia 4
FIGURA 4.4
NumlMlrl'ormat
Uma progellitor a com
\'{;rias filhas.
ChoiceFonnet OeclmalFormat
Agora que voc j viu mais algumas definies, pode refinar a defini o de herana.
Novo TERMO
Herana um mecanismo que pemlite estabelecer relacionamentos ' um' entre
classes. Esse relacionamento tambm pennite que uma subclasse herde os atributos
e comportamentos de sua superclasse.
NOTA
Quando uma filha herdar de uma progenitora, a filha obt er todos os atributos
e comportamentos que a progenitora possa ter herdado de outra classe.
Confonne voc viu, para que a hierarquia de herana faa sentido, deve ser possivel fazer na fi-
lha tudo que possivel fazerem sua progenitora. isso que o teste ' um' realmente testa. A uma
mha s6 permit ido aumentar a funcionalidade e adicionar funcionalidades. Uma fi lha nunca
pode remover funcionali dade.
Se voc verificar que uma filha precisa remover funci onali dade, isso ser uma
indicao de que ela deve aparecer antes da progenitora na hierarqui a de he-
rana!
Assim como pais e filhos da vida real, as fi lhas e progenitoras da classe sero semelhantes entre
si. Em vez de compartilhar genes, as classes compartilham informaes de ti po.
NOTA
Como na vida real dos filhos, uma classe pode ter apenas uma progenitora flsi-
ca. Tudo depende de como a linguagem implementa herana.
Algumas l inguagens permitem que uma classe tenha mai s de uma progeni to-
ra. Isso conhecido como herana mlt ipla.
Algumas linguagens restringem a filha a uma progenitora.
Outras l inguagens, como Java, permitem apenas uma progenitora por imple-
mentao, mas fornecem um mecanismo para herdar mlti plas interfaces
(mas no a implementao, apenas as assi naturas de mtodo).
Herana: obtendo algo para nada
Assim como as filhas reais, as classes fil has podem adicionar novos comportamentos e atributos
a si mesmas. Por exemplo, uma fil ha real pode aprender a tocar piano. mesmo que a me nunca
tenha aprendido. Do mesmo modo, uma filha pode redefinir um comportamento herdado. For
exemplo, a me pode ter sido m aluna de matemtica. A filha pode eSlUdar mais e se tornar uma
boa aluna de matemtica. Quando voc quer adicionar novo comportamento em uma classe, pode
fazer isso adicionando um novo mtodo na classe ou redefinindo um comportamento ant igo.
Mecnica da herana
Quando uma classe herda de out ra, ela herda implementao, comportamentos e atributos. Isso
signi fi ca que todos os mtodos e atributos disponveis na interface da progenit ora aparecero na
interface da filha. Uma c lasse construda atravs de herana pode ter trs tipos importantes de
mtodos e at ributos:
Sobreposto: a nova classe herda o mtodo ou atributo da progenitora, mas fornece uma
nova definio.
o Novo: a nova classe adiciona um mtodo ou atributo completamente novo.
o Recursivo: a nova classe simplesmente herda um mtodo ou at ributo da progenitora.
A maioria das li nguagens 00 no permite que voc sobreponha um atributo.
Entretanto, o atributo sobrepost o foi i ncludo aqui para sermos completos.
Primeiro, vamos considerar um exemplo. Em seguida, exploraremos cada tipo de mtodo e atri-
buto.
public class TwoDimcns1onal Point (
private double x_coord;
private double y_coordi
publiC TwoDimensional Poi nt( double x,double y ) (
setXCoordinate( x );
setYCoordinate( y ) i
}
public double getXCoordi nate() {
return x_coord;
}
public void setXCoordinate ( double x ) {
x coord = Xi
}
}
publ ic double getYCoordinate() I
relurn y_coord;
}
Dia 4
public void setYCoordinate( double y ) 1
y_coord y;
}
public String toString() (
}
return "I am a 2 dimensional poinl.\n " +
~ y x coordinate is: " + getXCoordinateO + "\ n" +
"My y coordinate is: " + getYCoordinateO:
publi C class ThreeDimensionalPoint extends TwoDimensionalPoint (
}
}
private double z_coord :
public ThreeOimensionalPoint( double x. doubl e y. double z ) (
super( x.y) ; II inicializa os atributos herdados
}
II chamando o construtor progenitor
setZCoordinate( z ) ;
publiC double getZCoord inale() {
return z_coord:
}
public void setZCoordinate( double z ) {
z coord z'
- .
publiC Stri ng toString()
I
return "I am a 3 dimens i onal point. \ n" +
"My x coordinate is:
..
+ gelXCoordinate() + U\n" +
"My Y coordinate is:
..
+ getYCoordinate() + "\n" +
"My z coordinate is:
..
+ getZCoordinate();
}
Aqui, voc tem duas classes ponto que representam pontos geomtricos. Voc poderi a usar pon-
tos em uma ferramenta de traado de grficos, em um modelador visual ou em um planejador de
vo. Os pontos tm mui tos usos prticos.
Aqui, TwoOimens ionalPoint contm coordenadas x e y. A classe define mtodos para obter e
configuraras pontos, assi m como para criar uma representao de String da instncia do ponto.
Herana: obtendo algo para nada
ThreeDimensionalPoinl herda de TwoDimensionalPoint. ThreeDimensionalPoi nl acrescenta a
coordenada z, assi m corno um mtodo para recuperar a valor e para confi gurar o valor. A classe
tambm fornece um mtodo para obter uma representao de String da instncia. Como Thr ee-
Dimensional Poinl herda de TwoDimensional Poi nt, ela tambm tem os mtodos contidos dent ro
de TwoDimensionalPoint.
Esse exemplo demonstra eada tipo de mtodo.
Mtodos e atributos sobrepostos
A herana perrnite que voc pegue um mtodo ou atributo previamente existente e o redefina. A
redefinio de um mtodo permite que voc mude o comportamento do objeto para esse mtodo.
Um mtodo ou at ributo sobreposto aparecer na progenitora e na filha. Por exemplo, ThreeDi-
mensionalPoint redefine o mtodo toStringO que aparece em TwoDlmenslonalPoint:
II de TwoDimensionalPoint
publ ic String toString() {
return "I am a 2 dimensional poinl. \n" +
"My x coordinate is: + getxCoordinateO + "\n" +
"My Y coordinate is: + getYCoordinateO:
}
TwoOimens iona I Point define um mtodo toSt r i ng() que identifi ca a instncia como um ponto
bidimensional e impri me suas duas coordenadas.
Th reeOimensionalPoint redefi ne o mtodo toSt ringO para identi fi car a instncia como um
ponto tridimens ional e imprime suas trs coordenadas:
II de ThreeOimensional Point
public String toString() {
return "I am a 3 dimensional
"My x coordinate is:
"My Y coordinate is:
"My z coordinate is:
}
Considere o mtodo mainO a seguir:
point.\n" +
"
+ getXCoordinate()
"
+ getYCoordinate()
"
+ getZCoordinate();
publ ic stati c void main( String [] args ) {
+ "\n" +
+ "\n" +
TwoDimensionalPoinl two : new TwoDi mensionaIPoint(1.2);
ThreeDimens ionalPoint three = new ThreeOimensionalPoi nt(1.2.3);
Syslem.out. pr int ln (two.toString( :
Syslem.out. pr int ln(three . toStri ng( ;
}
A Figura 4.5 ilustra o que voc ver aps executar o mtodo mai nO.
FIGURA 4.5
TestaI/do o lIItodo
t oString() sobreposto.
Dia 4
Conforme voc pode ver na Figura 4.5, ThreeDimensionalPoint retorna sua representao de
String sobreposta.
Sobrepor um mtodo tambm conhecido como redefinir um mtodo. Redefinindo um mtodo, a filha
fomece sua prpria implementao personalizada do mtodo. Essa nova implementao fomeccr um
comportamento novo para o mtooo. Aqui , ThreeDimensionalPoint redefine o comportamento do
mtooo toStri ngO, para que ele seja correlamente transfonnado em um objeto String.
Novo TERMO
Sobrepor O processo de uma filha pegar um mtodo que aparece na progenitora e
reescrev lo para mudar o comportamento do mtodo. A sobreposio de um mto
do tambm conhecida como redefinio de um mtodo.
Ento, como o objelo sabe qual definio deve usar?
A resposta depende do sistema 00 subjacente. A maiori a dos sistemas 00 procurar primei ro a
defini o no objeto para o qual passada a mensagem. Se uma defi nio no for encontrada l. o
ambiente em tempo de execuo percorrer a hierarquia, at que uma defi nio seja encont rada.
importante perceber que assim que uma mensagem manipulada e que por isso que a so-
breposio funciona. A definio da filha ser a primeira a ser chamada, poi s a primeira encon-
trada. O mecanismo igual para mtodos e atributos recursivos, que veremos posteriorment e.
A Figura 4.6 ilustra a propagao de mtodo entre os objetos ponto para LIma chamada de get X-
Coordi nate (). Uma chamada de mtodo para getXCoord i na te () percorrer a hierarqui a at en-
contrar LIma defi ni o para o mtodo.
FIGURA 4.6
Pl'op(/ga(10 de
mellsagem emre
os objeto.f pomo.
5 D
5 D
I (Irl" d' -,1
, I
;/ o L ___ .....J;:;
L I
Herana: obtendo algo para nada 83
Ao considerarmos a sobreposio de um mtodo ou at ribul o, importante perceber que nem to-
dos os mtodos e atributos esto disponveis para sua filha sobrepor. A maioria das linguagens
orientadas a objelos tem alguma noo de controle de acesso. As palavras-chave controle de
acesso defi nem exatamente quem pode ver e acessar mtodos e atributos. Generi camente, esses
nveis de acesso caem em trs categorias, conforme discutido brevemente no Dia 2:



Privado: um nvel de acesso que restringe o acesso apenas classe.
Protegido: um nvel de acesso que restringe o acesso classe e s filhas.
Publico: lIm nvel de acesso que permite o acesso a todos e a qualquer um.
Os mtodos e atributos protegidos so aqueles aos quais voc deseja que apenas as subclasses te-
nham acesso. No deixe tais mtodos pblicos. Apenas aqueles com amplo conhecimento da
classe devem usar mtodos e at ributos protegidos.
Voc deve tornar privados todos os atributos no-constantes e qualquer mtodo destinado unica-
mente prpria classe. O nvel privado impede que qualquer outro objeto chame o mtodo, ex-
ceto quanto ao prprio objeto. No torne protegidos os mtodos privados, apenas para o caso de
alguma subclasse querer acess-los algum dia. Use o nvel protegido apenas para os mtodos
que voc sabe que uma subclasse deseja usar. Caso contrrio, use o nvel privado ou pblico. Tal
prtica rgida significar que talvez voc tenha de voltar ao seu cdigo posteriormente e mudar o
nvel de acesso de um mtodo. Entretanto, isso leva a um proj eto mais conciso do que um que
abra tudo para uma subclasse.
NOTA
Vollar e mudar niveis de acesso pode parecer uma prtica ruim. Entretanto, as
hierarqui as de herana nunca devem acontecer por acidente. Em vez disso, as
hierarquias devem ser desenvolvidas naturalmente, enquanlO voc programa.
No h vergonha em refazer suas hierarquias com o passar do tempo. A POO
real um processo iterativo.
Contudo, lembre-se de que tornar tudo privado uma regra geral . Existem ca-
sos em que esse consel ho no funcionar a seu favor . Tudo depende do que
voc estiver programando. Por exemplo, se voc vender bibliotecas de classe
genricas sem fornecer o cdigo-fonte, provavelmente dever ter o nvel pro-
tegido como padro, para que seus clientes possam usar herana para esten-
der suas classes.
Na verdade, existem ocasies em que voc desejar projetar uma subclasse
com a herana em mente. Em tal caso, faz senti do estabelecer um protocolo de
herana. Um protocolo de herana uma estrutura abstrata, vislvel apenas
atravs dos element os protegidos da classe. A classe progenitora chamar es-
ses mtodos e a classe filha poder sobrepor esses mtodos para aumenlar o
comportamento. Voc vai ver um exemplo assim, amanh.
Usando essas definies e regras, fcil ver que os mtodos e atri butos protegidos e publicos
so os mai s importantes para a herana.
Dia 4
Novos mtodos e atributos
Um novo mtodo ou atributo um mtodo ou atributo que aparece na fil ha, mas no aparece na
progenitora. A filha acrescenta o novo mtodo ou atributo em sua interface. Voc viu novos m-
todos no exemplo ThreeDimens ional Poi nt . ThreeDimensiona I Poi nt acrescenta os novos mta-
dos getlCoordinate() e setZCoordinateO. Voc pode adicionar nova funcionalidade na
interface de sua fi lha, adicionando novos mtodos e at ri butos.
Mtodos e atributos recursivos
Um mtodo ou at ri buto recursivo definido na progenitora ou em alguma outra ancestral, mas
no na fi lha. Quando voc acessa o mtodo ou atributo, a mensagem enviada para cima na hie-
rarquia, at que uma definio do mtodo seja encontrada. O mecanismo igual quele apresen-
tado na seo sobre mtodos e atributos sobrepostos.
Voc viu mlodos recursivos no cdigo-fonte de TwoDi mens i ona I Poi nt e ThreeDi mens i ona 1 Po-
i nt. getXCoord1 na te () um exemplo de mtodo recursivo, pois ele definido por TwoDimens i-
onal Point e no por ThreeDimensiona 1 Poi nt.
Os mtodos sobrepostos tambm podem se comportar de forma recursiva. Embora um mtodo
sobreposto aparea na filha, a maioria das linguagens orientadas a objetos fornece um mecanis-
mo que permite a um mtodo sobreposto chamar a verso da progenitora (ou de algum outro an-
cestral) do mtodo. Essa capacidade permite que voc enfat ize a verso da superclasse, enquant o
define novo comportamento na subclasse. Na linguagem Java, a palavra-chave super d acesso
implementao de uma progeni tora. Voc ter a chance de usar super nos laboratrios do Dia 5,
"Herana: hora de escrever algum cdigo".
NOTA
Nem todas as tinguagens fornecem a palavra-chave super. Para essas lingua-
gens, voc precisar tomar o cuidado de iniciali zar corretamente qualquer c-
digo herdado.
No referenciar corretamente as classes herdadas pode ser uma fonte sutil de
erros.
Tipos de herana
Ao todo, existem trs maneiras principais de usar herana:
I. Para reutilizao de implementao
2. Para diferena
3. Para substituio de tipo
Herana: obtendo algo para nada
Esteja avisado de que alguns tipos de reutilizao so mais desejveis que outros! Vamos explo-
rar cada uso em detalhes.
Herana para implementao
Vocj viu que a herana possibil ita que lima nova classe reuti lize implementao de outra clas-
se. Em vez dc recortar e colar cdigo ou instanciar e usar um componente atravs de composi-
o, a herana torna o cdigo automaticamente disponvel, como parte da nova classe. Como
mgica, sua nova classe nasce com funcionalidade.
A hierarquia Emp 1 oyee e a mal gui ada Queue/ Itera tar demonstram a reutil izao de i mplemen-
tao. Nos dois casos, a filha reut ili zou vrios comportamentos encont rados na progenitora.
DI CA
Lembre-se de que, quando programa com herana de implementao, voc
est preso implementao que herda. Escolha as classes que herdar com
cuidado. Voc precisar ponderar as vantagens da reutilizao em relao a to-
dos os faiaS negativos de reutilizar algumas implementaes.
Entretanto, uma classe corretamente def inida para herana far bastante uso
de mtodos protegidos refinados. Uma classe que herda pode sobrepor esses
mtodos protegidos para alterar a implementao. A sobreposio pode dimi -
nuir o impact o da herana de uma implementao mal feita ou inadequada.
Problemas da herana da implementao
At aqui, a herana de implementao parece excelente. Cuidado, contudo - o que parece lima
tcni ca til na superficie se mostra uma prtica perigosa no uso. Na verdade, a herana de imple-
mentao ti fonna mais defici ent e dc herana e nonnalmenle voc deve evit-Ia. A reutilizao
pode ser fcil , mas, conforme voc ver, ela tem um alto preo.
Para entender as fal has, voc precisa cons iderar os tipos. Quando uma classe herda de oulra, ela
assume automaticamente o tipo da classe herdada. A herana de tipo corret o sempre deve ter
precedncia, ao se projetar hierarquias de classe. Voc ver os motivos posteriormente, por en-
quant o, assuma isso como verdade.
D uma olhada no exemplo Queue/ lterator novamente. Quando Iterator herda de Queue,
ela se torna uma Queue. Isso significa que voc pode tratar Iterator como se fosse do tipo
Queue. Como Iterator tambm uma Queue, ela tem toda a funcionalidade que estava pre-
sente na Queue. Isso significa que os mtodos como enqueueO e dequeue() tambm fazem
parte da interface pblica de Iterator.
Superficia lment e, isso no parece ser um problema, mas d uma olhada melhor na definio de
Iterator. Uma interface Iterator simplesmente defi ne dois mtodos, um para recuperar um
elemento e outro para testar se restam quaisquer elementos no I terador. Por definio, voc no
pode adicionar itens em um Iterador; entretanto, Queue define o mtodo enqueue() justamente
Dia 4
para um caso assim. Em vez disso, voc s pode remover element os. Voc no pode pegar um
elemento e, ao mesmo tempo, deix-lo dentro da interface I terator. Novamente, Queue define o
mtodo peek () ,j ustamente para esse caso. E simples ver que usar Queue como uma base herdada
para I terator no uma boa escol ha; isso fornece comportamentos que si mplesmente no per-
tencem a uma interface Iterator.
NOTA
Algumas linguagens permitem que uma classe simplesmente herde imple-
mentao, sem herdar as informaes de tipo. Se sua linguagem permite tal
herana, ento o exemplo Queue/I terator no muito problemtico. Entretan-
to, a maioria das linguagens no permite a separao de interface e implemen-
t ao, durante a herana. Das linguagens que fazem a separao, algumas
fazem isso automaticamente. Outras ainda, como C++, permitem a separao,
mas exigem que o programador a solicite expli citamente. Tal linguagem exige
que o programador projete e solicite a separao explicitamente, enquanto co-
difica a cl asse. Obviamente, pode ser muito fcil ignorar o fato de que voc
precisar separar a implementao e o t ipo, se no tomar cuidado.
Este livro usa uma definio de herana simples. A discusso sobre herana
pressupe que ela inclui implementao e interface, quando uma classe herda
de outra.
Uma herana pobre o monstro de Frankenstein da programao. Quando voc usa herana uni-
camente para reutil izao de implementao, sem quaisquer outras consideraes, freqUente-
mente pode acabar com um monstro construido a partir de partes que no se encaixam.
Herana para diferena
Voc viu a herana para diferena no exemplo de TwoOimens i onal Point e ThreeOimensional Po -
int. Voc tambm a viu no exemplo Employee.
A programao peta diferena permi te que voc programe especificando apenas como uma clas-
se filha difere de sua classe progenitora.
Novo TERMO
Programa(:t;o por diferena significa herdar uma classe e adicionar apenas o cdigo
que tome a nova classe diferente da classe herdada.
No caso de Th reeOimens i ona 1 Po int, voc v que ela difere de sua classe progenitora pelo acrs-
cimo de uma coordenada Z. Para suportar a coordenada Z, ThreeOimens i onal Poi nt adiciona dois
novos mtodos para configurar e recuperar o atribut o. Voc tambm v que ThreeOimens f ona1-
Point redefine o mtodo toStringO.
A programao por di ferena um conceito poderoso. Ela permite que voc adicione apenas o
cdigo necessrio o suficiente para descrever a diferena entre a classe progenitora c a classe fi -
lha. Isso permite que voc programe atravs de incrementos.
Herana: obtendo algo para nada
Um cdigo menor e mais fcil de gerenciar toma seus projetos mais simples. E como voc pro-
grama menos li nhas de cdigo, teoricamente deve introduzir menos erros. Assi m, quando pro-
grama pela diferena, voc escreve cdigo mais correto em um espao de tempo mais curto.
Assi m como a herana de implementao, voc pode fazer essas al teraes increment ais sem al -
terar o cdigo existente.
Atravs da herana, existem duas maneiras de programar pela diferena: adicionando novos
comportamentos e atributos. e redefini ndo comportamentos c atributos antigos. Cada caso co-
nhecido como especializao. Vamos ver detalhadamente a especial izao.
Especializao
Novo TERMO
Especializao O processo de uma classe filha ser projetada em tennos de como ela
diferent e de sua progenitora. Quando tudo estiver dito e feito, a definio de classe
da filha incluir apenas os elementos que a tomam diferente de sua progenitora.
Uma classe fil ha se especializa em relao sua progenitora, adicionando novos atributos e m-
todos em sua interface, assim como redefinindo atributos e mtodos previamente existentes. A
adio de novos mtodos ou a redefinio de mtodosj existentes permite que a filha expresse
comportamentos que so diferentes de sua progenitora.
No se confunda com o tenno especiali zao. A especializao permite apenas que voc adicio-
ne ou redefina os comportamentos e atributos que a fil ha herda de sua progeni tora. A especiali-
zao, ao contrri o do que o nome possa sugerir, no permite que voc remova da fi lha
comportamentos e atri butos herdados. Uma classe no obtm herana seletiva.
O que a especial izao faz rest ri ngir o que pode e o que no pode ser um ponto tridimensional.
Um ThreeOimensiona 1 Point sempre pode ser um TwoDimensional Point. Entretanto, incorreto
dizer que um TwoDimensi onal Poi nt sempre pode ser um ThreeDimensional Point.
Em vez di sso, um ThreeDimensiona 1 Poi nt uma especializao de um TwoDimensional Poi nt e
um TwoOimens ionalPoint uma generali zao de um ThreeDimensionalPoint.
A Figura 4.7 i lustra a di ferena entre general izao e especial izao. Quando voc percorre uma
hierarquia para baixo, voc se especial iza. Quando voc percorre uma hierarquia para cima,
,
voc generaliza. A medida que voc generaliza, mais classes podem cair sob esse agrupamento.
,
A medida que voc especiali za, menos classes podem sati sfazer todos os critrios para serem
classi ficadas nesse nvel.
FIGURA 4.7
Quando percorre /filia
hierarquia para cima.
\'oc gellerali: a. Qllalldo
perco,.re lima hierarqllia
para boi.to. !"oc
especia!i:a.
Dia 4
Como voc v. especializao no signi fica uma restrio de funcionalidade, ela significa restri-
o da categori zao de tipo. A especializao no precisa acabar com ThreeOi mens; ona 1 Poi nt.
Na verdade, ela no precisa necessariamente nem mesmo comear com TwoOi mens i ona 1 Poi nt. A
herana vai ter a profundidade que voc quiser. Voc pode lIsar herana para formar estruturas
de hierarquia de classe complexas. A noo de hierarquia int roduzida anteriormente leva a mais
dois termos novos: Gnceslral e descendente.
NOTA
Apenas porque voc pode ter hierarquias compli cadas no significa que deve
t-Ias. Voc deve se esforar por ter hierarquias pouco profundas e no hierar-
quias demasiadamente profundas. medida que uma hierarquia se aprofun-
da, ela se torna mais difcil de manter.
Novo TERMO
Dada alguma filha, uma ances/ral uma classe que aparece na hierarquia de classes
antes da progenitora. Conforme a Figura 4.8 il ustra, Format uma ancestral de Oeci-
mal Format .
Novo TERMO
Dada lima classe, toda classe que aparece depois dela na hierarquia de classes uma
descendellle da classe dada. Conforme a Figura 4.8 ilustra, Oec i mal Format uma
descendente de Fermat.
FIGURA 4.8
OecimolFormat
desceI/deli/e de
Formot.
Formal
NumberFormat
-'-
ChoiceFormlll OecimalFormlll
Herana: obtendo algo para nada 89
Digamos que tivssemos a hierarquia de herana de classes mostrada na Figura 4.9. Dizemos
que OneDl mensional Point a progenitora de TwoDimensional Point e ancestral de ThreeDimen-
si onalPoint e de FourOimensionalPoint. Tambm podemos dizer que TwoDimensionalPoint,
ThreeDi mens i ona 1 Poi nt c FourOi mens i ona 1 Pai nt so todas descendentes de OneOimens i ona 1 -
Pa int. Todos os descendentes companil ham os mtodos e atributos de seus ancestrais.
FIGURA 4.9
II hierarqllia
de pallfo.
I . ~ ~ ~ M I ... ___
1 TwoOI......w ..... PoI'" I.
4 TII ... Di ...... 1 .... IPo!m 1'41 I
1 F ..... .oimI_ .. ~
Podemos fazer mais algumas declaraes interessantes sobre a hierarquia de classes. OneDimen-
sianalPoint a rai z e FaurOi mensionalPaint uma folha.
Novo TERMO
NovO TERMO
A c/euse raiz (tambm referida comum ente como classe base) a classe superior da hi-
erarquia de herana. A Figura 4.9 mostra que OneOimens i ona 1 Poi nt uma classe raiz.
Uma c/(I.uefolha uma classe sem filhas. Na Figura 4.8, Decimal Format uma clas-
se fol ha.
imponantc notar que as descendentes refl etiro as alteraes feitas nas ancestrais. Digamos
que voc encontre um erro em TwoOimens i ona 1 Point. Se voc corrigir TwoOimensional Point, to-
das as classes de ThreeOimens i ona 1 Poi nt at FourOi mens i ona 1 Poi nt tiraro provei to da altera-
o. Assim, se voc corri gi r um erro ou tomar lima implement ao mais efi ciente, todas as
classes descendentes da hierarquia tiraro proveito disso.
Herana mult ipla
Em todos os exemplos voc viu herana simples. Algumas implementaes de herana
permitem que um objeto herde di reta mente de mais de uma classe. Tal implementao
de herana conhecida como herana mltipla. A herana mltipla um aspecto con-
troverso da POO. Atguns dizem que ela s torna o software mais diflcil de entender, pro-
jetar e manter. Outros tm grande confiana nela e dizem que uma linguagem no est
completa sem ela.
De qualquer modo, a herana mltipla pode ser valiosa, se usada cuidadosa e correta-
ment e. Existem vri os problemas introduzidos pela herana mlti pla. Entretanto, uma
discusso completa do que a herana mltipla pode e no pode fazer est fora dos obje-
tivos deste dia.
Dia 4
Herana para substitui o de tipo
o tipo fina l de herana a herana para substi tuio de tipo. A substitui o de tipo penni te que
voc descreva relacionamentos com capacidade de subst ituio. O que um rel acionamento
com capacidade de substituio?
Considere a classe li ne:
publi c class l i ne (
}
private TwoOimens i ona lPoi nt pI :
private TwoOimensionalPoint p2:
publiC Li ne( TwoDimensionalPoi nt pI, TwoDimensionalPoint p2 ) (
thi s.pl pI:
this.p2 p2:
)
publ ic TwoDimensionalPoint getEndpoi nt l() {
return pI:
}
publi c TwoDi mensionalPoint getEndpoi nt2() {
return p2:
publ ic double getDistanceO I
doubl e x
}
Math.pow( (p2.getXCoordinate( ) pl.getXCoordinate( , 2 );
doubl e y
Math.pow( (p2.getYCoordinate() - pl . getYCoordinate(, 2 ) ;
doubl e di st ance Math. sqrt( x + y ) ;
return di stance :
public TwoDi mensional Poi nt getMidpoint () I
}
double new_x (p l . ge t XCoordinate() + p2 .getXCoordinate() ) / 2;
double new_y (pl .get YCoordinate() + p2 .getYCoordinate() ) / 2:
ret urn new TwoOimensionalPoi nt ( new_x . new_y ) :
}
Li ne recebe dois objetos TwoDimensional Poi nt como argumentos e fornece alguns mtodos para
recuperar os valores, um mtodo para calcular a distncia entre os pontos e um mtodo para cal-
cular o ponto mdi o.
Um relacionamento com capacidade de substi tuio significa que voc pode passar para o cons-
trutor de l ine qualquer objelo que herde de TwoDimensional Point.
Herana: obtendo algo para nada 91
Lembre-se de que, quando uma filha herda de sua progenitora, voc di z que a filha ' uma' pro-
genitora. Assim, como um objclo ThreeOimens iona 1 Poi nt ' um' objeto TwoDimensional Poi nt,
voc pode passar um objeto ThreeDimensiona 1 Poi nt para o construtor.
Considere o mtodo mainO a seguir:
publi c sta tic void main( Str ing [] args } I
I
ThreeDimensionalPoint pi = new ThreeDimensionalPoint( 12, 12, 2 };
TwoDimensional Point p2 z new TwoDimensionalPoint( 16 , 16 );
Line 1 z new Line( pi, p2 );
TwoOimensi onalPoint mi d = 1. ge tMidpoint() ;
System.out.println( "Midpoint: (" +
mid.getXCoordinate() +
" " +

mid.getYCoordinate() +
"l" );
System.out.println( "Distance:" + l.getOistanceO );
Voc notar que o mtodo principal passa um objeto TwoDi mens ional Poi nt e um objeto Th ree-
Dimens iona 1 Poi nt para o construtor de L i ne. A Figura 4.1 O iI ustra o que voc ver, se executar o
mtodo mainO.
FIGURA 4.10
Tes/(mdo re/aciollamelllos
com capacidade de
.mbslillli{i o.
NOTA
Tente imaginar as possibilidades que os relacionament os com capacidade de
substituio oferecem a voc. No exemplo da linha, eles poderiam possibili tar
uma maneira rpida de trocar de um modo de visualizao em 3D para um
modo de visualizao em 20 em uma GU!.
Capacidade de conexilo um conceito poderoso. Como voc pode enviar a uma filha qualquer
mensagem que pode ser enviada para sua progenitora, passiveI trat-Ia como se ela pudesse ser
Dia 4
substi tuda pela progenitora. Esse o moti vo pelo qual voc no deve remol/er comport amentos
ao criar uma fil ha. Se voc fizer isso, a capacidade de conexo ser invalidada.
Usando a capacidade de conexo, voc pode adicionar novos subtipos em seu programa, a qual
quer momento. Se seu programa for feito para usar uma ancestral, ele saber como usar os novos
obj etos. O programa no precisar se preocupar com o ti poexato do obj eto. Desde que tenha um
relacionamento com capacidade de substit uio com o ti po que espera que possa usar.
ALERTA
Saiba que os relacionamentos com capacidade de substituio s6 podem ir at
um n(vet acima na hierarquia de herana. Se voc programar seu obj eto para
aceitar determinado tipo de objeto, no poder passar para ele a progenitora
do objeto esperado. Entretanto, voc pode passar para ele qualquer descen-
dente.
Pegue como exemplo o construtor de Une:
public Line( TwoDimensionalPoint pl,TwoDimensionalPoint p2 )
Voc pode passar para o construtor um objeto TwoDemenslonalPoint ou qualquer
descendente de TwoDimens i ona 1 Po i nt . Entretanto, voc no pode passar para o
const rutor um objeto OneDimensionalPoint, pois essa classe aparece antes de
TwoDimensionalPoint na hierarquia.
Novo TERMO Um slIbtipo um ti po que estende outro tipo atravs de herana.
A capacidade de substit uio aumenta sua oport unidade de reutil izao. Digamos que voc te-
nha escrito um pacote para conter obj etos TwoDirnens i ona 1 Poi nt. Devido a capacidade de cone-
xo, voc tambm pode usar o pacote para qualquer descendente de TwoOirnens ional Poi nt.
A capacidade de subst it uio importante, pois ela pennite que voc escreva cdigo genrico.
Em vez de ter vri as instrues case ou testes if/else para ver que ti po de ponto O programa eSla-
va usando, voc si mplesmente programa seus objetos para tratar com objetos do tipo TwoOimen
si ona 1 Poi nt.
Dicas para a herana eficaz
A herana vem com seu prprio conjunto de problemas de projeto. Embora seja poderosa, na
verdade a herana fornece a corda para voc se enforcar, quando usada incorretamente. As dicas
a seguir o ajudaro a usar a herana eficazmente:



Em geral, use herana para reutilizao de interface e para definir relacionamentos de
substituio. Voc tambm pode usar herana para estender uma implementao, mas 50--
mente se a classe resultante passar no teste ' um' .
Em geral, prefira a composio em vez da herana para reut ili zao de implementao
simples. Use herana apenas se voc puder apl icar o teste ' um' na hierarquia resultante.
No use herana para reutilizao de implementao ambiciosa.
Scmpre use a regra ' um'.
Herana: obtendo algo para nada
As hierarquias de herana corretas no acontecem sozinhas. Freqlientemente, voc descobrir
hierarquias medida que prosseguir. Quando isso acontecer, refaa seu cdigo. Em outras oca-
sies, voc precisar projetar deliberadament e suas hierarquias. De qualquer modo, existem al-
guns princpios de projeto a seguir:


Como regra gera l, mantenha suas hi erarquias de classe relat ivament e rasas.
Projete cui dadosamente a hierarquia de heranas e remova as caractersticas comuns das
classes base abstratas. As classes base abstraIas pennilem que voc defina um mtodo
sem fornecer uma implementao. Como a classe base no especi fica uma implementa-
o, voc no pode instanci-Ia. Ent retant o, o mecanismo abstraio obri ga uma classe que
esteja herdando a fornecer uma implementao. As classes abstratas so valiosas para he-
rana planejada. Elas ajudam o desenvolvedor a ver o que elas precisam implementar.
NeTA
Se sua linguagem no fornece um mecanismo abstrato. cri e mtodos vazios e
documente o fat o de que subclasses devem implementar completamente es-
ses mtodos.


As classes freqUentemente compartilham cdigo COmum. No h sentido em ter vrias
cpias de cdigo. Voc deve remover o cdigo comum e isol-lo em uma (mica classe
progenitora. Entretanto, no o coloque muito aci ma. Coloque-o apenas no primeiro nvel
acima de onde ele necessri o.
Simplesmente no possvel planejar sempre suas hierarquias completamente. As carac-
tersticas comuns no aparecero at que voc escreva o mesmo cdigo algumas vezes.
Quando voc ver caracterst icas comuns, no tenha medo de refazer suas classes. Esse
trabalho freqlentemente referido como refazer.
O encapsulamento to important e ent re progenitora e filha quanto entre classes no relaciona-
das. No relaxe quanto ao encapsulamento, quando voc estiver herdando. A prti ca de usar uma
interface bem definida to vl ida entre progenitora e fi lha quanto entre classes completamente
no relacionadas. Aqui esto algumas dicas que o aj udaro a evit ar a quebra do encapsulamento,
quando voc herdar:



Use interfaces bem definidas entre a progenitora e a fi lha, exatamente corno as usaria en-
tre classes.
Se voc adicionar mtodos especificamente para uso por subclasses, certifique-se de tor-
n-los protegidos, para que apenas a subclasse possa v-los. Os mtodos protegidos per-
mitem que voc oferea s suas subclasses um pouco mai s de controle, sem abrir esse
cont role para toda classe.
Em geral , evite abrir a implementao interna de seu objeto para subclasses. Uma sub-
classe pode se tomar dependente da implementao, se voc fi zer isso. Tal acoplamento
tem todos os problemas delineados no Dia 2.
Aqui esto alguns segredos fi nais para a herana eficaz:



Dia 4
Nunca se esquea de que a substituio o objet ivo nmero um. Mesmo que um objeto
deva ' intuit ivamente' aparecer em uma hierarquia, isso no quer di zer que ele deve apare-
cer. Apenas porque possvel ou porque sua intuio clama, no significa que voc deve
fazer isso.
Programe pela di ferena para manter o cdi go fcil de gerenciar.
Sempre prefira a composio herana para reutilizao de implementao. Geralmente
mais fcil alterar as classes envolvidas na composio.
Resumo
Existem dois tipos de relacionamentos fornecidos pela POO: um relacionamento de /(so entre
objetos e um relacionamento de herana entre classes. Cada relacionamento fornece urna forma
de reutili zao. Entretant o, cada um vem com suas prprias vantagens e problemas.
A simples instanciao e uso freqUentemente limitam a nexibilidade de uma classe. Atravs da
reutili zao simples, no h meios de reut il izar ou estender uma classe. Em vez disso, voc fica
com uma instanciao simpl es ou recorte e colagem. A herana supera essas defi cincias, forne-
cendo um mecanismo interno para a reutil izao segura e eficiente do cdigo.
A reuti lizao de implementao proporciona a voc um modo rpido e grosseiro de usar cdigo
previamente existente em suas novas classes. Ao cont rri o da operao de recorte e colagem
simples. existe apenas uma cpia do cdigo para manter. Entretanto, simplesment e herdar para
reuti li zar imprevi dente e limita seus projetos.
A implement ao para diferena permite que voc programe suas novas classes em termos de
como el as diferem da classe original. Voc s programa os atributos que diferenciam a filha da
progenitora.
Finalmente, a herana para substituio penni te que voc programe genericamente. Com a subs-
tituio, voc pode trocar de subclasses para a progenitora a qualquer moment o, sem dani ficar
seu cdigo. Isso permite que seu programa seja flexvel para futuros requisitos.
Como a herana atende aos objetivos da 00
A herana preenche cada um dos objelivos da POO. Ela ajuda a produz ir software que :
i. Natura l
2. Confivel
3. Reutili zvel
4. Manutenvel
5. Extensvel
6. Oportuno
Herana: obtendo algo para nada
Ela atinge esses objetivos, como segue:
o Natural: a herana permite que voc modele o mundo mais naturalrnente. Atravs da heran-
a, voc pode fonnar hierarquias de relacionamento complexas entre suas classes. Como
seres humanos, nossa tendncia natural querer categorizar e agrupar os objetos que esto
em tomo de ns. A herana pennite que voc traga essas tendncias para a programao.


A herana tambm abrange o desejo do programador de evitar trabalho repetitivo. No
faz sentido fazer trabalho redundante.
Confivel: a herana resulta em cdigo confivel.
A herana si mplifi ca seu cdigo. Quando programa pela diferena, voc adiciona apenas
o cdigo que descreve a diferena entre a progenit ora ea filha. Como resultado, cada clas-
se pode ter cdigo menor. Cada classe pode ser altamente especializada no que faz. Me-
nos cdi go significa menos erros.
A herana permite que voc reuti li ze cdigo bem testado e comprovado, como a base de
suas novas classes. A reutilizao de cdigo comprovado sempre mais desejvel do que
escrever novo cdigo.
finalmente, o mecanismo de herana em si confivel. O mecani smo incorporado lin-
guagem, de modo que voc no precisa construir seu prprio mecanismo de herana e
cert ificar-se de que todo mundo segue suas regras.
Entretanto, a herana n1l0 perfeita. Ao usar subclasses, voc deve estar vigi lante com re-
lao introduo de erros sutis destruindo inadvertidamente dependncias no expostas.
Prossiga com cuidado, quando herdar.
Reutilizvel: a herana auxilia a reuti lizao. A prpria natureza da herana permite que
voc use classes antigas na construo de novas classes.
A herana tambm perrn it e que voc reuti li ze classes de maneiras nunca imaginadas pela
pessoa que escreveu a classe. Sobrepondo e programando pela diferena, voc pode alterar
o comportamento de classes existentes e us-las de novas maneiras.
o Manuten vel: a herana auxil ia a manutenibil idade. A reuti !izao de cdigo testado sig-
nifica que voc ter menos erros em seu novo cdigo. E quando voc encontrar um erro
em uma classe, todas as subclasses tiraro proveito da correo.
Em vez de se aprofundar no cdigo e adicionar recursos diretamente, a herana permite
que voc pegue cdigo previamente existente e o trate como a base da construo de uma
nova classe. Todos os mtodos, atributos e infornlacs de tipo se tomam parte de sua
nova classe. Ao contrrio do recorte e colagem, existe apenas uma cpia do cdigo origi-
nal para manter. Isso ajuda na manuteno, di minuindo a quantidade de cdigo que voc
precisa manter.
Se voc fosse fazer alteraes diretamente no cdigo existente, poderia danificar a classe
base e afetar partes do sistema que usem essa classe.
196 Dia.
Extensvel: a herana torna a extenso ou especializao de classe possvel. Voc pode
pegar uma classe antiga e adicionar nova funcionalidade a qualquer momento. A progra-
mao pela diferena e a herana para capacidade de conexo est imulam a extenso de
classes.
Oportuno: a herana o aj uda a escrever cdigo oport uno. Voc j vi u como a reutili zao
simples pode di mi nuir o tempo de desenvolvimento. Programar pela diferena signi fi ca
que existe menos cdigo para escrever; portanto, voc deve terminar mais rapidamente.
Capacidade de substituio significa que voc pode adicionar novos recursos, sem ter de
alterar muito o cdigo j existente.
A herana tambm pode tornar os testes mais fceis, pois voc s precisa testar a nova
funcionalidade e qualquer interao com a funci onalidade antiga.
Perguntas e respostas
P Hoje, foram li stados trs motivos separados para usar herana. Esses motivos pre-
cisam ser mutuamente exclusivos ou posso combin-los? Por exemplo, quando eu
herdo pela diferena, parece que tambm poderia herdar para implementao.
R No, os moti vos por trs da herana no precisam ser mutuamente exclusivos. Voc po-
deria usar herana e acabar sati sfazendo cada um dos mot ivos.
P Herdar para reutilizao de implementao parece ter uma conotao negath'a. A
reutilizao mio um dos principais motivos para se usar programao orientada a
objetos?
R A relllilizao apenas um dos objet ivos da roo. A roo uma estratgia de programa-
o que permite modelar as solues para seus problemas de uma maneira mais natural:
atravs de objetos. Embora a reut ilizao sej a importante, voc no deve simplesmente
busc-Ia, ignorando os outros objetivos da 00. Lembre do exemplo lterator/Queue.
Aquele era um model o natural de uma interface Iterator? claro que no!
Alm disso, a herana para reutilizao de implementao apenas uma maneira de obter a reu-
ti I izao. FreqUentemente, a delegao a melhor maneira de obter reuti lizao de impl ementa-
o simpl es. A herana si mplesmente no a ferrament a correta, se seu objeti vo apenas
reut ili zar uma implementao. A herana a ferramenta correta quando voc quer programar
pela diferena Oll estabelecer capacidade de substit uio de tipo.
Workshop
As perguntas e respostas do teste so fornecidas para seu melhor entendimento. Veja as respos-
tas no Apndice A, "Respostas".
Herana: obtendo algo para nada 97
Teste
I. Quais so algumas das li mitaes da reutilizao simples?
2. O que herana?
3. Quais so as trs formas de herana?
4. Por que a herana de implementao perigosa?
5. O que programao pela diferena?
6. Ao herdar uma classe, pode-se ter trs tipos de mtodos e atributos. Quais so esses trs
tipos dc atributos e mtodos?
7. Quai s vantagens a programao pela diferena oferece?
8. Considere a hierarquia da Figura 4.11 , extraida da segurana do Java.
FIGURA 4.11 P mluion
A hierarquia Permi ss i on.
B .. icP,rm;uion Un ...,r..edf'"miuion
Stc:urifvl'ermlulon
Se voc voltar sua ateno para a classe Pcnni ss i on, quais classes so suas !ilhas? Quais so des-
cendentes?
Consi derando a hierarquia int ci ra, qual classe a classe raiz? Quais classes so classes fol has?
Finalmente, Permission uma ancestral de SecurityPermission?
9. O que herana para substitui o de tipo?
10. Como a herana pode destruir o encapsulamento? Como voc pode impor o encapsula-
mento ao usar herana?
Exerccios
I. Dada a defini o da classe a seguir, quais problemas poderi am ocorrer, se ela fosse her-
dada?
publ lc class Point (
public Point( i nt x, i nt y) I
,
,
this . x x:
this.y "' y;
Dia 4
publ1c Po1nt getlocation{) {
return new POint( x, y ):
,
public void move( int x, i nt y ) {
thi s.x x;
this.y ., y;
,
public void setlocation( int x, int y ) {
this.x x

thiS.y .. y:
,
pub l ic void setlocation( Point p ) {
th;s.x = p.x;
this.y .. p.y:
,
public ;nt X;
public int y;
2. Como voc evitari a esses problemas?
SEMANA 1
DIA
Herana: hora de escrever algum
cdigo
A herana uma ferramenta poderosa. Hoje, voc vai explorar o uso dessa nova ferramenta,
atravs de vari os exerccios prticos de laboratrio. No final da liO de hoje, voc dever se sen-
tir um pouco mais vontade com a teoria apresentada no Dia 4.
Hoje voc aprender:
Corno usar herana enquanto programa
Como as classes abstraIas o ajudam a planejar a herana
Sobre a impOrlincia do relacionamento 'e um' e ;tem um'
o Como a linguagem Java pode ter violado os relacionament os ' um' e ' tem um'
laboratrio 1: herana simples
A Li stagem S. l apresenta a classe base MoodyObject personificada.
LI STAGEM 5.1 MoodyObject.java
public class MoodyObject (
II retorna o humor
protected String getMood() I
1 100 Dia5
LI STAGEM 5 . 1 MoodyObject.java (continuao)
}
return "moody" i
}
II pergunta ao objeto como ele se sente
public voi d queryHood() I
System.out.print ln("I feel " + getMood O + " today!")i
}
MoodyObject define um mtodo pblico: queryMood (). queryMood () imprime o humor do objeto
na linha de comando. MoodyObject tambm declara um mtodo protegido, getMood (). queryMood ()
usa getMood () internamente para obter o humor que coloca em sua resposta. As subclasses po-
dem si mplesmente sobrepor getMoodO para especializar seu humor.
Se uma subclasse qui sesse mudar a mensagem escrita na linha de comando, ela precisari a sobre-
por queryHood ().
Exposio do problema
Neste labomtrio, voc criar duas subclasses: SadObject e HappyObject. As duas subclasses devem
sobrepor getHood() para fornecerem seu prprio humor especialmente personal izado.
SadObject e HappyObject tambm devem adicionar alguns mtodos prpri os. SadObject deve
adicionar um mtodo: publ i c voi d cry(). Do mesmo modo, HappyObject deve adic ionar um
mtodo: pub 1 i c voi d 1 augh (). 1 augh () deve escrever ' hahaha' na linha de comando. Do mes-
mo modo, cry() deve escrever ' boa hoo' na linha de comando.
A Listagem 5.2 configura um driver de teste que voc deve compilar e executar quando tiver
concludo a escri la de HappyObject e SadObj ect.
LI STAGEM 5.2 MoodyOriver.java
publi c class MoodyOriver {
public f i nal static void ma in( String [] args ) {
MoodyObject moodyObject c new MoodyObject() i
SadObject sadObj ect new SadObject ();
HappyObject happyObject " new HappyObject( ) ;
System. out.print ln( -How does the moody object feel today?M ) i
moodyObject . queryMood()i
Sys t em. out . pr1nt l n( "" l i
Sys t em. out . print ln( "How does the sad object feel today?M )i
sadObjec t.queryMood( ); Il note que a sobreposi o muda o humor
SadObject.cry() ;
System.ouLprint ln( ,,- ) ;
Herana: hora de escrever algum cdigo
LI STAGEM 5.2 MoodyDriver. java (continuao)
J
J
System.out.print ln{ NHow does the happy object feel today?" );
happyObject . queryMood(); Ilnote que a sobreposi o muda o humo r
happyObject . laugh() ;
Sys t em.out .print l n( l ;
101
ALERTA
A prxima seo discute as solues do Laborat rio 1. No prossi ga at con-
cluir o Laboratri o 1.
Solues e discusso
As listagens 5.3 e 5.4 apresentam uma soluo para o laboratri o.
LI STAGEM 5.3 HappyObj ect.java
publ ic class HappyObject extends MoodyObject (
J
Ilredefine o humor da classe
protected String getMood() I
return "happy;
J
II especializao
pu bl ic voi d laugh () {
Sys tem. ou t. pri nt 1 n (" hehehe ... hahaha . .. HAHAHAHAHAHA! ! ! ! ! ") ;
J
LI STAGEM 5.4 SadObject .java
public class SadObjec t extends MoodyObject {
II redefine o humor da cl asse
protected String getMood() {
return "sad";
J
II especializao
publ ic voi d cryO I
1 102 Dia 5
LI STAGEM 5.4 SadObject.java (continuao)
System.out . println{"'wah' ' boo hoo' 'weep ' 'sob' ' weep'"};
}
}
Quando voc executar o driver de teste, dever ver uma sada semelhante a da Figura 5.1.
FIGURA 5.1
A saida correra de
MoodyDriver,
De interesse a chamada de queryMood(). Quando voc chama queryMood () em SadObject. " I
feel sad today!" impresso na tela. Do mesmo modo, HappyObject imprime, "1 fccl happy today!"
Tal comportamento pode parecer surpreendente, pois nenhuma classe redefi ne queryMood O.
Voc precisa ver queryMoodO detalhadamente. Internamente, queryMoodO chama getMoodO
para obter o humor. Como as subclasses redefinem getMoodO, queryMoodO chamar a verso
fi lha de getMood (). Esse comport amento um exemplo do processo ilustmdo na Figura 4.6 do
Dia 4.
laboratrio 2: usando classes abstratas para
herana planejada
Existi ro ocasies em que voc desejar desenvolver li ma classe especificamente para que ou-
tros possam herdar dela. Quando voc desenvolve algumas classes relacionadas, pode encontrar
cdigo que comum a todas as suas classes. A boa prtica diz que, ao ver cdigo comum, voc o
coloca em uma classe base. Quando voc escreve essa classe base, planeja para que outras clas-
ses herdem dela.
Ent retanto, uma vez que voc ti ver terminado de mover o cdigo, poder notar que no faz senti-
do instanciar a classe base di retament e. Embora a classe base contenha cdigo comum, que
Herana: ho ra de escrever algum cdigo 103
muito valioso para subclasses, ela pode no ter nenhum valor para instanciao e uso direto. Em
vez disso, s faz sentido usar as subclasses. As subclasses se especializam em relao classe
base e fornecem o que est faltando.
Considere a classe Employee:
publ i c cl ass Employee {
I
private String first_name ;
private String last_name;
private double wage ;
publi c Employee ( String first_name . St ring last name . double wage ) (
this.first_name f i rs t _name :
this.last _name last_name :
this.wage wage;
I
publ iC doubl e getWage() {
return wage:
I
publ iC String getFirstName() (
return first_name:
I
public String getLastName() (
return l ast_name:
I
publ ic double calculatePay() (
II No sei como fazer isso !
return O;
I
publiC Stri ng print Paycheck() {
I
String full_name " l ast_name + " , " + fi r st_name ;
ret urn ( "Pay: " + full name + " $" + cal culatePay() );
Voc pode usar Empl oyee como classe base de Conmi ss i onedEmp loyees, HourlyEmployees e Sa-
l ariedEmp loyees. Cada subclasse sabe como calcular seu pagament o. Entretanto, o algoritmo
usado para calcular pagamento vai variar de acordo com o tipo de funcionrio. Quando cri a-
mos essa hierarquia, imaginamos que cada subclasse preci saria definir seu prprio mtodo
cal cul atePayO.
Dia 5
H um pequeno problema: Empl oyee no tem nenhuma regra para calcular seu pagamento. No
faz sentido executar calculatePayO para um objeto Employee. No existe nenhum algoritmo
para calcular o pagamento de um runcionrio genrico.
Uma soluo no defini r cal culatePayO na classe base. Entretanto, no defi ni r o mtodo na
classe base seri a uma deciso inreliz. Isso no modela um runcionri o muito bem. Cada runcio-
nri o saber calcular seu pagament o. A nica diferena a implementao real do mtodo ca 1-
culatePayO. Assim, na verdade, mtodo pertence classe basco
Se voc no definir ca 1 cul atePayD na cl asse base, no poder tratar os runcionrios generica-
mente. Voc perder a capacidade de conexo de subtipo para o mtodo ca 1 cul atePay (). Ou-
tra soluo simplesment e codificar um retorno en latado. O mtodo poderia simpl esmente
retornar wage.
Um retorno codificado no uma soluo muito limpa. No h garantias de que outro dcsenvolvc-
dor v se lembrar de sobrepor o mtodo, ao desenvol ver uma nova subclasse. Alm disso, no raz
nenhum sentido instanciar um objeto Emp loyee. Felizmente, a 1'00 oferece um tipo especial de
classe, desl'inada especificamente herana planejada: a classe abstrata.
Uma classe abstrata mui to parecida com qualquer outra definio de classe. A defi nio da
classe pode definir comportamentos e atributos, exatamente como uma classe normal. Entretan-
to, voc no pode instanciar diretamente uma classe abstraIa, pois uma classe abstrata pode dei-
xar alguns mtodos indefinidos.
Novo TERMO
Um mtodo declarado, mas no implemelllado, chamado de melOdo absl NIIQ. So-
mente classes abstraIas podcm tcr mtodos abstratos.
Em vez di sso, voc pode instanciar apenas as descendentes da classe abstrata que realmente im-
plementam os mtodos abstraIaS.
Vamos ver uma classe Employee abstraIa:
public abstract cl ass Empl oyee (

publiC abstract double calculatePay{) ;
II o restante da definio permanece igual
I
A classe abslrata Emp 1 oyee defi ne um mtodo ca 1 cu 1 a tePay () ; entretanto, ela o deixa indefi nido.
Agora, fica por conta de eada subclasse implementar realmente o mtodo. HourlyEmpl oyee
uma dessas subclasses:
public class Hour lyEmployee extends Emp l oyee {
private i nt hours ; Ilcontrola o nmero de horas trabalhadas
public HourlyEmpl oyee ( Str i ng f lrst_name, String last_name. double wage ) {
supe r ( flrst _name. l ast_name. wage };
}
Herana: hora de escrever algum cdigo
}
publiC double calculatePay() I
return getWage{) * hours;
}
publi c void addHours( i nt hours ) I
this . hours thiS.hours + hours;
}
public void resetHours() {
hours O;
}
105
Declarando mtodos abstratos, voc obriga suas subclasses a se especial izarem em relao
classe base, fornecendo uma implementao para os mtodos abst ratos. Tornando uma classe
base abstrata e criando mtodos abstratos, voc planeja com antecipao o que a subclasse deve
redefi nir.
Exposio do problema
No Laboratrio 1, voc criou uma classe MoodyObject. Todas as subclasses redefinem getMo-
od (). Para o Laboratrio 2, altere um pouco essa hierarquia. Torne o mtodo gctMood()abstrato.
Voc tambm precisar atualizar a classe MoodyDriver para que ela no tente mais instanciar Mo-
odyObject diretamenle. Voc no ter de fazer quaisquer alteraes em SadObject ou
HappyObject, pois elas j fornecem uma implementao de getMoodO.
A prxima seo discute as solues do Laboratrio 2. No prossiga at con-
cluir o Laboratrio 2.
Solues e discusso
As li stagens 5.5 e 5.6 apresentam as definies de MoodyObj ect e MoodyDri ver reestruturadas.
LI STAGEM 5.5 MoodyObject .java
public classe abstrata MoodyObject I
II retorna o humor
protected abstract Stri ng getMood();
II pergunta ao objeto como ele se sente
public void queryMood() I
1 106 Dia5
LI STAGEM 5.5 MoodyObject .java (cont inuao)
System.out.println{"I feel N + getMood{) + N today!N);
}
}
LISTAGEM 5.6 MoodyDriver . java
public class MoodyOriver (
}
publi c final stat i c void main{ String [] args ) (
}
IIMoodyObject mo new MoodyObject{); l lno pode instanciar MoodyObject
SadObject so new SadObject();
HappyObject ho new HappyObject() ;
IISystem.out.println( "How does the moody object feel today?" );
Ilmo.queryMood();
IISystem.out.println{ "" );
System. out.println( "How does the sad object fee l today?" };
so.queryMood(); II note que a sobreposi o muda o humor
so.cryO;
System.out . println( MM );
System.out.print l n{ NHow does the happy obj ect feel today?M );
ho.queryHood(); II note que a sobreposio muda o humor
ho.laughO;
System.out.println( N_ );
As al teraes so muito simples. MoodyObject define um mtodo getMood () abstrato e deixa por
conta de suas subclasses fornecer a implementao real. Quando O mtodo queryMood () precisa
recuperar o humor, ele simplesmente faz uma chamada ao mtodo abstrato.
O uso de classes abstratas define o contrato que as subclasses devem atender para utilizar a clas-
se base. Como descnvolvedor, quando voc ver uma classe base abst rata, saber exatamente o
que preci sa especiali7..ar ao herdar. Voc pode especializar os mtodos abstratos. Entretanto,
voc sabe que definindo os mtodos abst ratos, sua nova classe se encaixar na hierarquia corre-
tamente.
Quando uma classe base tem muitos mtodos, pode ser confuso descobri r quais deles devem ser
sobrepostos. As classes abstratas fornecem uma dica.
Herana: ho ra de escrever algum cdi go 107
laboratrio 3: conta em banco praticando
a herana simples
Agora hora de testar seus conheci mentos de herana. Vamos voltar ao Banco 00 e vero que a
herana pode fazer para o sistema de contas do banco.
O Banco 00 oferece aos seus clientes algumas escolhas de contas: uma conta poupana, uma
conta com cheques, uma conta com vencimento programado e uma conta de cheque especial.
Uma conta genrica
Cada ti pc de conta pcrm itc ao usurio depositar e sacar fundos, assi m como veri ficar o saldo cor-
rente. A conta bsica genrica no permite saque a descobert o.
A conta poupana
A conta poupana especial iza a conta genrica do banco, aplicando juros no saldo, quando ins-
truda a fazer isso. Por exemplo, se um depositante tem um saldo de US$I.OOO e a taxa de juros
de 2%, aps o pagamento dos juros, o saldo ser de USS 1020:
balance E balance + (balance * interest_rate)
A conta poupana no pennite saque a descoberto.
Uma conta com vencimento programado
A conta com vencimento programado tambm aplica juros ao saldo. Entretanto, se o titular da
conta fizer qualquer saque do capital investido, antes do prazo de vencimento, banco deduzi r
uma porcentagem do saque. Assim, por exemplo, se o depositante sacar US$I.OOO antes do pra-
zo de venci mento e houver urna multa de 5% sobre o valor sacado, o saldo da conta diminuir
US$IOOO. Entretanto, o depositante receber apenas US$950. Se a conta estiver no vencimento,
o banco no penalizar os saques.
balance E balance - withdraw amount
mas
amount_given_to_depositor amount - (amount * penalty_rate)
a conta com vencimento programado no permite saque a descoberto.
Conta com cheques
Ao cont rrio das contas poupana e com vencimento programado, a conta com cheques no apli-
caj uros ao saldo. Em vez disso, a conta com cheques pcnni te que o depositante emi ta cheques e
faa transacs na conta atravs de ATM (caixa elelrnico de auto-atendimento). Entretanto,
Dia 5
banco limita o nmero de transaes mensais a algum nmero fixo. Se o depositante ult rapassar
essa quota mensal , o banco cobrar uma taxa por transao. Assim, por exemplo, se o deposi tan-
te tiver direit o a cinco transaes gratuitas por ms, mas fi zer oito transaes a uma taxa de US$I
por transao, O banco cobrar do deposi tante uma taxa de US$3:
fee (total _t ransact ions - monthl y_quota) * per_transacti on_fee
A conta com cheques no permite saque a descoberto.
Conta com cheque especial
Finalmente, a conta com chcquc especial perm ite ao depositante sacar dinheiro alm do saldo da
conta. Entretanto, nada de graa. Periodicamente, o banco apl icar uma taxa de j uros no caso
de qualquer saldo negativo. Assim, por exemplo, se o depositante acumular um saldo negativo
de US$I.OOO a uma taxa de 20%, poder pagar uma taxa de US$200. Depoi s da aplicao da
taxa, seu saldo ser de - US$ 1200:
balance balance + (balance * i nterest_rate)
Noteque o banco s calculajuros em contas com saldo negativo! Caso contrrio, o banco acaba-
ria di stribui ndo dinhei ro. O Banco 00 no est no ramo de distribuio de dinheiro. Nem mes-
mo para desenvolvedores.
Ao cont rario da conta com cheques, a conta com cheque especial no coloca um I imite no nlllne-
ro de transaes mensais. O banco estimulari a os saques - eles poderiam cobrar juros!
Exposio do problema
Sua tarcfa formular uma hierarquia de herana e implementar as contas confonne definido an-
teriorment e. Voc deve criar as seguintes classes de conta:
BankAccount
Savi ngsAccount
TimeMaturityAccount
CheckingAccount
OverdraftAccount
BankAccount a classe base. Ela contm as tarefas comuns a todas as contas. Essa a nica dica
hierrquica que voc ter 1 Part e do laboratri o voc experimentar as hi erarquias de herana.
Existem v rias si mpl ifi caes que voc pode fazer. Para clcul os de taxas, vencimento pro-
gramado e j uros, suponha que out ra pessoa observar o calendrio. No programe esse tipo de
funcionalidade em suas classes. Em vez disso, fornea um mtodo para outro objelo chamar.
Por exemplo, SaVl ngsAccount deve ler um mtodo addlnterest (). Um objeto externo cha ma-
ra o mtodo. quando for hora de calcular osjuros. Do mesmo modo, Checki ngAccount deve ex-
por um mtodo access FeesO. Quando chamado, esse mtodo calcular todas as laxas e as
aplicar no saldo.
NOTA
Herana: hora de escrever algum cdigo 109
No se atrapalhe com detalhes desnecessrios. lembre-se de que voc est
completando este laboratri o para ganhar experi ncia prtica com herana e
no para escrever o sist ema de conta mais robusto possivel. Assim, no se
preocupe com a validao da entrada (a no ser que queira fazer isso). Voc
pode supor que todos os valores dos argumentos sero sempre vl idos.
o Dia 4 abordou brevemente o uso de super. super no um conceito dificiL Considere
a sel eo a seguir:
publlc COfTlTlissionedEmployee( String first_name, String last_name,
I
double wage, double cOfTlTlission ) 1
super(first_name, last_name,wage l; II chama o construtor origi nal
II para inicializar corretamente
this.cOfTlTlission cOfTlTlission;
Quando voc chama super dentro de um construtor, isso permite que o construtor da
progenitora seja chamado. claro que voc deve fornecer todos os argumentos exi gi
dos pelO construtor da progenitora. A maioria das linguagens, Java inclulda, exi ge
que, se voc chamar super dentro do construtor, ento deve fazer isso antes de tudo.
Na verdade, se voc no chamar super, automaticamente a linguagem Java t entar
chamar superO sozinha.
super permite que voc destaque o cdigo da progenitora, que de outro modo seria
simplesmente sobrescrito. No caso dos construtores, super permite que a fil ha chame o
construtor de sua progenitora.
Chamar corretamente o construtor da progenitora al go que voc no deve desprezar.
Voc precisa garantir que a classe seja inicial izada corretamente.
Voc tambm pode usar super dentro de um mtodo.
Imagine uma classe VeryHappyObject,
publ 1c class VeryHappyObject extends HappyObject {
I
II redefi ne o humor da cl asse
protected String getMoodO {
String old_mood super.getMood();
return "very" + old_mood;
I
VeryHappyObject SObrepe getMood(). Entretanto, super.getMood() permite que Very-
HappyObject chame a verso da progenitora de getMood (). VeryHappyObject especi ali za
o mtodo getMood () de sua progenitora, realizando algum processamento extra no va-
l or retornado por super .getMood ().
Assim, mesmo que uma f ilha sobreponha o mtodo de sua progenitora, a filha ainda
poder destacar o cdigo exi stente na progenitora.
Dia 5
Assim como em um construtor, se voc usar super para chamar um mto-
do, ento deve fornecer t odos os argumentos que o mtodo possa exigir.
Voc achar super til neste laboratrio.
Pare agora e complete o laboratri o, caso se sinta vontade. Se voc precisar de um pouco mais
de ajuda, cOluinue a ler.
Exposio estendida do problema
Se voc ainda se acha perdido, estas interfaces devem aj ud lo um pouco. Essas interfaces repre
sentam apenas unta maneira de completar o laboratrio.
BankAccount contm os seguintes mtodos:
publi c void depositfunds( double amoun t )
publ ic double getBal ance()
public double withdrawfunds( double amount )
protected void set8al ance( double newBalance )
Savi ngsAccount deve conter os seguintes mtodos:
public void addlnterest()
public void setlnterestRate( double interestRate )
public double getlnterestRate()
TimedMaturityAccount contm os seguintes mtodos:
public boolean isMature()
public void mature()
public double getfeeRate()
public void set feeRate( double rate)
Ti medMatu ri tyAccount precisar redefi nir wi thdrawfunds () para veri fi car o venci mento e apli
car todas as taxas necessrias.
Checki ngAccount contm os seguintes mtodos:
pub li c void accessfees()
publi c double getFee()
public void setfee( double fee )
public int getMonthl yQuota{)
public void setMonthl yQuota( int quota)
public int getTransact ionCount()
Checki ngAccount precisar sobrepor wi thdrawfunds () para controlar o nmero de transacs.
Herana: hora de escrever algum cdigo
OverdraftAccount contm os seguintes mtodos:
publl c void chargelnterest()
public double getCreditRate()
publ i c void setCredltRate( double rate)
"1
OverdraftAccount pode precisar sobrepor withd rawFunds (), caso 6ankAccount coloque cheques
a descoberto no mtodo.
Talvez voc tambm queira iniciar sua hierarquia com a classe Account, que desenvolveu para o
Laboratri o 2 no Dia 3. A (mica mudana que voc dever fazer no mtodo wi thdrawFunds{).
Voc provavelmente deve colocar proteo contra saque a descoberto nos mtodos withdraw-
Funds ().
A prxima seo di scute as solues do Laboratrio 3. No prossiga at con-
cluir o Laboratri o 3.
Solues e discusso
A Figura 5.2 ilustra a hierarquia de herana resultante de conta.
FI GURA 5 .2
ii hierarquia de conta elll
baIlCO.
S8"; nll'''' """"nl
Bel'llAccounl
OvtIrd flAccounl
Ti mflMalll. 11'1 Acooun I
Ch",klnll
4
CCOllOl
import ante ter essa hierarquia em mente, enquanto voc considera as solues a seguir.
A Listagem 5.6 apresenta uma possivel implementao de 6ankAccount. Essa classe base contro-
la o saldo e manipula depsitos e saques.
LI STAGEM 5.7 BankAccount.j ava
publl c class 6ankAccount {
II dados privados
private double balance;
1 11 2 Dia5
LISTAGEM 5.7 BankAccount.java (continuao)
}
II construtor
public BankAccount( double initoeposit ) {
setBalance( initDeposit ):
}
II deposita dinheiro na conta
public void depos1tFunds( double amount ) {
}
II a classe base no apl ica regras s contas
II no valida a entrada
setBalance( getBalance() + amount ):
II consulta o saldo
public double getBalanceO {
return balance;
}
II configura O saldo
protected void setBalance( double newBa l ance ) {
balance newBalance:
}
II saca fundos da conta
publ ic double withdrawFunds( double amount } {
if( amount >'" balance) {
amount balance:
}
setBalance( getBalance() - amount );
return amount;
}
Savi ngsAccount, na Listagem 5.8, herda diretamente de Ban kAccount. Sav i ngsAccount especiali-
za BankAccount, adi cionando mtodos para obter e confi gurar a taxa de juros, assim corno um
mtodo para apl icar juros no saldo da cont a.
LISTAGEM 5.8 Savi ngsAccount.java
publiC class SavingsAccount extends BankAccount {
II dados privados
private double interestRate:
II Cria novo SavingsAccount
public SavingsAccount(double initBal ance , doubl e interestRate }I
supere initBalance ) :
setInterestRate(interestRate l:
Herana: hora de escrever algum cdi go
LI STAGEM 5 .8 Savi ngsAccount. j ava (continuao )
}
}
II calcula e soma juros na conta
public voi d addInterest() {
double balance = getBal ance( ) ;
double rate z get InterestRate() ;
doubl e interest balance * rate ;
double new balanc e z balance + i nterest;
set Balance{ new_balance );
}
II configura a t axa de juros
pu bli c voi d set InterestRate( double i nterestRate ) {
this.interestRate z interestRate ;
}
II cons ulta a taxa de juros
publ ic doubl e getInterestRate() {
return interestRate;
}
113
Ti meMa t urityAccount, na Listagem 5.9, herda de SavingsAccount, pois juros podem ser aplica-
dos em seu saldo. Entretanto, ela especiali za sua progenitora, definindo mtodos para configu-
rar o nvel de vencimento e taxas. Interessante o fato de que essa classe redefine o mtodo
wi thdrawFunds (). Atravs de uma chamada a super .wi thdrawFunds () , esse mtodo ai nda usa a
funciona lidade original; ent retanto, ela acrescenta as verificaes necessri as para ver se precisa
acessar uma taxa para a transao. Se assim for, ela acessa a taxa c retorna o valor do saque, me-
nos a taxa.
LISTAGEM 5 .9 Ti meMaturi tyAccount . java
class Ti medMaturityAccount extends SavingsAccount {
II dados pri vados
private boolean ma ture;
private double feeRate;
II Cria novo TimedMa turi tyAccount
public TimedMaturityAccount( double i nitBalance.
double interestRate.
double fee Rate ) I
super ( initBalance . interestRate ) ;
set FeeRate ( feeRate );
}
1 11 4 Dia5
LI STAGEM 5.9 TimeMaturityAccount.java (continuao)
}
II sobrepe withdrawFunds de BankAccount
public double withdrawFunds( double amou nt ) I
super.withdrawFunds( amount ):
}
if( !isMature() ) I
}
double charge amount * getFeeRat e() :
amount amount - charge :
return amount:
II verifica o vencimento
public bool ean isMature() I
return mature:
}
II faz vencimento
publ ic void mature() {
mature true ;
}
II % de taxa para saque anteCi pado
publ ic doubl e getFeeRate() {
return feeRate:
}
II configura % de taxa para saque antecipado
public voi d setFeeRate( doubl e rate) I
feeRate rate:
}
Checki ngAccoun t, na Listagem 5. I O, herda diretamente da classe base BankAccount. Essa classe
adiciona os mtodos necessrios para configurar a taxa por transao, configurar a quota mensal,
reconfi gurar a cont a da transao e consultar o nmero de transaes corrente. Essa classe tam-
bm sobrepe o mtodo wi thdrawFunds () para controlar o nmero de transaes. Assim corno
Ti medMaturityAccount, ChecklngAccount ainda usa a lgica original, chamando super .with-
drawFundsO.
LI STAGEM 5.10 CheckingAccount.java
publiC cl ass CheckingAccount extends BankAccount I
II dados privados
private int monthlyQuota :
private int transact ionCount:
private double fee :
II Cria novo CheckingAccount
Herana: ho ra de escrever algum cdigo
LI STAGEM 5.10 Checkl ngAccount . java (continuao)
publiC ChecklngAccount( double initOeposit , int trans, double fee } {
supere inltOeposit }:
setMonthlyQuota( trans l :
set Fee( fee ):
J
II sobrepe withdrawFunds de BankAccount
public double withdrawFunds( double amount ) {
transactlonCount++:
return super .withdrawFunds( amount l:
J
II acessa as taxas se ultrapassou o l imite de
public void accessFees() (
J
int extra a getTransactionCount() - getMonthlyQuota():
if( extra> O ) {
double total_fee extra * getFee{) j
double balance ge tBalanceO total fee:
setBalance( balance );
J
transactionCount a O:
II al guns mtodos de obteno e configurao
public double getFee() {
return fee;
J
public void setFee( double fee ) (
this. fee fee;
J
J
publi c int getMonthlyQuota() {
return mont hlyQuota:
J
public void setMonthlyQuota( int quota) {
monthlyQuota a quota:
J
publi C int getTransactionCount() {
return transactionCount:
J
115
Finalmente. Ove rdra ftAceount, na Listagem 5.1 I, herda diretamente de BankAceount . Entretan-
to, ela tambm adiciona mtodos para configurar a taxa de juros de saque a descoberto e para
apli car quaisquer taxas de juros.
Dia 5
LI STAGEM 5.11 OverdraftAccount . java
public class Ove rdraftAccount extends BankAccount I
I
II dados privados
private double creditRate;
II Cria novo OverdraftAccount
public OverdraftAccount( double initOeposit. double rate) (
super( 1nitOeposit ) j
setCreditRate( rate ) j
I
II cobra j uros sobre qualquer di nhei ro emprestado
public void chargelnterest() {
I
double balance a getBalance()j
if(balance < O ) I
I
double charge balance * getCreditRate()j
setBalance( balance + charge )
II consulta a taxa de crdito
publ ic double getCreditRate() (
return creditRate

I
II configura a taxa de crdito
public void setCreditRate( double rat e) {
creditRate ratei
I
II saca fundos da conta
public double withdrawFunds( double amount ) (
setBalance(getBal ance() - amount )j
return amountj
I
Cada uma dessas classes especial iza sua progenitora de uma maneira ou de outra. Algumas,
corno SavingsAccount, simplesmente adicionam novos mtodos. Outras. como Chec-
ki ngAccount, Ove rdraftAccount e TimedMaturi tyAccount, sobrepem o comportamento padro
da progenitora, para aumentar a funcionalidade.
Este laboratrio o expe aos mecanismos da herana, assim como herana para reuti lizao de
implementao e programao pela diferena.
Herana: hora de escrever algum cdigo 117
Embora no seja mostrada aqui, voc tambm pode usar a capacidade de conexo, pois a classe
comum BankAccount se relaciona a todas as contas. Qualquer um que sai ba como atuar na classe
base BankAccount pode sacar, deposi tare emitir um cheque nos fundos de qualquer tipo de conta.
Voc vai explorar a capacidade de conexo com detalhes por todo o Dia 6, "Polimorfi smo:
aprendendo a prever o fut uro", e Dia 7, "Polimorfi smo: hora de escrever algum cdigo".
laboratrio 4: estudo de caso
"tem um" e java.util.Stack
Il um"l
Quando se ini ciante em 00, pode ser tentador ver a li nguagem Java como um exemplo de pro-
jeto ori ent ado a objetos perfeito. Voc pode di zer a si mesmo, "se a linguagem Java faz isso,
deve estar correto". I nfel izmente, colocar confiana inquesti onvel em qualquer implementao
00 perigoso.
Vamos rever a estrutura de dados de pilha clssica. Voc pode colocar itens em uma pilha, extrair
itens de uma pilha e olhar o primeiro elemento da pilha, sem remov- lo. Talvez voc tambm
quisesse ver se a pi lha est vazia.
A linguagem Java tem uma classe Stack. A Listagem 5.12 ilustra a interface.
Lt STAGEM 5. 12 java.utll.Stack
publ lC class Stack extends {
public boolean empty() ;
publi c Object peek();
public Object pop ();
}
public Object push( Obj ect item ) ;
public int search( Object o ) ;
Voc notam que a linguagem Java ol im iza um pouco a definio clssica de pi lha. A linguagem
Java acrescenta um mtodo search(). O mtodo push () tambm retorna o it em que voc coloca.
Entretanto, h um problema maior. A classe Java Stack tambm herda de Vector. De um ponto
de vista, essa uma deci so inteligente. Herdando de Vector, St ack obtm toda a implementao
contida em Vector. I)ara implementar Stack, tudo de que voc precisa envolver os mtodos de
Stack para chamarem internament e os metodos herdados de Vector corretos.
Infelizmente, a classe Java Stack um exemplo de herana pobre. Stack passa no teste ' um'?
"Um objeto Stack ' um' Vector"? No- o teste fal ha. Vector tem todos os tipos de mtodos
para colocar elementos em Vector e remov-los. Um objeto Stack s permi te que voc coloque
elementos no topo da pilha. A classe Vector permi te que voc insira e remova elementos em
qualquer parte.
Aqui , a herana pennite que voc interaja com a classe Stack de maneiras indefinidas para uma pilha.
Dia 5
Exposio do problema
Stack passa no teste ' tem um'. "Um objeto Stack ' tem um' objeto Vector". Para este laboratri o,
escreva uma nova verso de Stack que empregue o ti po correto de reut ilizao de implementao.
ALER TA
A prxima seo discute as solues do laboratrio 4. No prossiga at con
cluir o laboratrio 4.
Solues e discusso
A Listagem 5. 13 ilustra uma possivel implementao de Stack
LI STAGEM 5. 13 A New Stack Implementation
public cl ass Stack (
private java.util .Arraylist list :
publ ic StackO(
list new java.uti l .Arrayl ist() :
}
public boolean emptyO (
return l ist.isEmptyO :
}
publiC Object peek() I
if( !emplyO } I
return li st .get( O };
}
return null :
}
publi C Object popO (
if( !emplyO } I
return list.remove{ O ):
}
return nul l;
}
publiC Object push( Object item ) (
list . add( O, item l :
return item:
}
Herana: ho ra de escrever algum cdigo 119
LISTAGEM 5.13 A New Stack Implementation (continuao)
J
publ iC int search( Object o ) {
int index l i st. indexOf ( o ,;
if( index ! - - 1 ) {
return index + 1;
J
return - 1;
J
Se este laboratrio nos ensi nar algo, que no devemos depositar toda nossa f em qualquer fon-
te de 00. Nada perfeito.
Resumo
Hoje, voc completou quatro laboratri os. O Laboratrio I permi ti u que voc experi mentasse a
herana simples. Aps concluir o Laboratrio 1, voc deve ter entendido o mecanismo bsico da
herana. a Laboratri o 2 permiti u uma maior explorao da herana, atravs da classe abstrata e
da herana planejada. O Laboratrio 3 deve ter solidifi cado as li es do Dia 4. Os laboratrios I
e 2 permiti ram ver mtodos e atributos redefinidos, novos e recursivos. Voc tambm viu como,
mesmo se sobrepuser um mtodo. ainda pode usar a implementao da progenitora.
a Laboratri o 4 ilustrou a importncia de considerar os testes ' um' e 'tem um', enquanto se
formam hierarquias de herana. s vezes, a melhor ao no herdar. Conforme o Dia 4 enfati-
za, a composio freqUentement e a fomla mais limpa de reutilizao. A herana s faz sentido
do ponto de vista relacional ou ' um' . Se dois objetos no esto relacionados pelo tipo, ento
eles no devem herdar. A implement ao compart ilhada no motivo sufi ciente para herdar.
Dentro de um sistema ou aplicati vo, voc sempre deve planejar a mxima herana possvel.
Entretanto, quando programa para um apl icativo espec fi co, voc est limitado a esse programa.
Com o passar do tempo, voc trabalhar em muit os programas diferentes. Quando voc comear
a notar que est programando as mesmas coisas repetidamente, as oportunidades para herana
comearo a se apresentar. Voc sempre deve estar atento a essas hi erarquias de herana desco-
bertas. Voc deve refazer seu cdi go, quando descobrir essas novas hi erarquias.
Perguntas e respostas
P No Laboratrio 4, voc mostrou como at a linguagem Java comete erros de 00.
Quando eu examinar as APls Java ou outras fontes de exemplos de 00, como pode-
rei ter certeza de que o que estou vendo ' boa' ao?
Dia 5
R dificil dizer o que constitui a ' boa' 00 e a ' m' 00, mesmo aps ter mui ta experincia
em 00. A melhor coisa que voc pode fazer aplicar o que aprendeu e nunca tomar um
exemplo como garant ido. Encare cada exemplo ponderadamente e, se algo no parecer
correto, discuta isso com seus colegas: obtenha uma segunda opinio.
Workshop
As perguntas e respostas do teste so fornecidas para seu melhor entendimento. Veja as respos-
tas no Apndice A, ' Respostas".
Teste
I. A partir das solues de laboratrio, d um exemplo de mtodo redefinido, de mtodo re-
cursivo e de novo mtodo.
2. Por qu voc declararia uma classe como sendo abslrata?
3. No Laboratri o 4, voc explorou os relacionamentos ' um' e 'tem um'. Antes mesmo de
aprender a respeito de herana, voc viu relacionamentos ' tem um'. Quais os relaciona-
mentos ' tem um" voc vi u nos laboratrios do Dia 3?
4. Como esses laboratrios preselVaram o encapsulamento entre a classe base e as subclasses?
5. A partir das solues, encontre um exemplo de especiali zao.
6. Como as solues do Laboratrio 3 e do Laboratri o 4 adotam lima estralgia diferente
para reutil izao de implementao?
Exerccios
No h exerccios hoje. Faa seus laboratrios!
SEMANA 1
DIA
Polimorfismo: aprendendo a
prever o futuro
At aqui, voc aprendeu sobre os dois primei ros pilares da programao orientada a objelos: en-
capsulamento e herana. Como voc sabe, o encapsulamento permi te construir componentes de
soft ware independentes e a herana pennite reutilizar e estender esses componentes. Entretanto,
ainda falta algo. O soft ware est sempre mudando. Se os usurios exigem nova runcional idade,
erros aparecem ou o software precisa ser integrado em novos ambientes, a nica constante a
mudana. O ciclo de vida do soft ware no tennina quando voc di stribui um produto. Voc pre-
cisa de sof1ware que possa se adaptar s necessidades futuras. No seria timo, se voc pudesse
escrever software ' prova do futuro'?
Um software prova do futuro se adapta aos requisitos futuros sem alterao. Um software fi
prova do futuro permi te que voc faa alteraes e adicione novos recursos facilmente. Feliz
mente, a POO entende que um software de sucesso no esttico. Assim, a POO usa o conceito
de polimorfi smo para permitir que voc escreva esse soft ware prova do futuro.
Voc pass<lr os prximos dois dias considerando o polimorfismo, o terceiro e ltimo pilar da
programao ori entada a objetos.
Hoje voc aprender:



o que polimorfismo
Quai s so os diferentes tipos de poli morfismo e o que eles oferecem para seus objetos
Dicas vali osas para o polimorfismo eficaz
122


Dia 6
A respeito de algumas armadil has do polimorfi smo
Como o pol i morfi smo atinge os obj eti vos da 00
Polimorfismo
Se o encapsulamento e a herana so os socos um e dois da POO, o polimorfismo o soco para
nocaute seguime. Sem os dois primeiros pilares, voc no poderia ler o polimorfi smo, e sem o
polimorfismo, a POO no seria eficaz. O polimorfismo onde o paradigma da programao orien-
tada a objelos realment e brilha e seu domnio absolutamente necessri o para a roo eficaz.
Polimorfismo significa muitas formas. Em termos de programao, o paI imorfi smo penn ite que
um nico nome de classe ou nome de mtodo represente um cdigo diferente, selecionado por
algum mecanismo aut omti co. Assim, um nome pode assumir mui tas formas e como pode re-
presentar cdigo difercnte, o mesmo nome pode representar mui tos comportamcntos di ferentes.
Novo TERMO
Polimorfismo: ter muitas ronnas. Em tennos de programao, mui tas rormas sign i-
fica que um nico nome pode representar um cdigo direrente, selecionado por al-
gum mecanismo automtico. Assi m, o polimorfismo pennite que um unico nome expresse muitos
componamentos direrentes.
De sua prpria maneira, o polimorfismo o di sturbio das multiplas personalidades do mundo do
somvare, pois um ni co nome pode expressar muitos comportamentos direrentes.
Toda essa conversa sobre expressar 'muitos componamentos di rerentes' pode parecer um pouco
abstrata. Pense no termo abrir. Voc pode abrir uma porta, uma caixa, uma janela e uma conta
no banco. A palavra abrir pode ser aplicada a muitos objetos direrentes no mundo real. Cada oh-
jeto int erpreta 'abrir' de sua prpria maneira. Entretanto, em cada caso, voc pode simplesmente
dizer ' abrir', para descrever a ao.
Nem todas as li nguagens suponam poli morfi smo. Uma linguagem que suporta polimorfismo
uma lingl/agem polimrfica. Em contraste, uma lingl/agem monomrfica no suporta polimor-
fi smo e, cm vez disso, restringe tudo a um e apenas um comportamento estti co, pois cada nome
estaticamente vinculado ao seu cdigo.
A herana rornece o aparato necessrio para tornar certos tipos de polimorfi smo possveis. No
Dia 4, "Herana: obtendo algo para nada", voc viu como a herana permite fonnar relaciona-
mentos com capacidade de substi tuio. A capacidade de conexo extremamente imponante
para o poli morfismo, pois ela pennitc que voc trate um tipo especfico de objeto genericamente.
Considere as classes a segui r:
publl C class Personal ityObject (
}
public St r ing speak() {
return - I am an object.";
}
Polimorfismo: aprendendo a prever o futuro
pub1i c c1ass Pessimi sticObject extends Personali t yObject (
public St r ing speak() {
return "The glass i s half empty . ":
I
I
pub1ic class Opt imisticObject extends Personal ityObject (
pub1ic String speak() {
ret urn "The gl ass is ha 1 f fu ll. ":
I
I
publiC class IntrovertedObject extends PersonalityObj ect (
publlc St ring speak() {
return "hi ... ";
I
I
publi C cl ass ExtrovertedObject extends PersonalityObject (
public Stri ng speak() {
return "Hell o. blah blah blah. did you know that bl ah blah blah. M:
I
I
123
Essas classes formam uma hierarquia de herana muito si mples. A classe base, Persona-
1 i tyObject, declara um mtodo: speak(). Cada subclasse redefi ne speak () c retorna sua prpri a
mensagem, baseada em sua personalidade. A hierarquia forma relacionamentos com capacidade
de substituio entre os subtipos e seus progenitores.
Considere O mtodo mal n () a segui r:
public static void main(String [] args ) (
Persona1 1tyObject personality E new PersonalityObject();
Pess1misticObject pessimistic " new Pessimi sticObject() :
OptimisticObject optimist ic " new OptimisticObject( ):
IntrovertedObject introverted E new IntrovertedObject();
ExtrovertedObject extroverted " new Ext rovertedObject():
II a capacidade de substi tuio permite fazer o seguinte
Personal ityObject [] personal ities " new Personal ityObject [5] :
personali t ies [O] personal ity:
personalities (1] pessimistic;
personalities [2] opt imi st i c:
personalities [3] introverted:
persona 11 t i es [4] ext roverted;
I I o polimorfismo faz com que PersonalityObject parea ter
I I muitos comportamen tos diferentes
J
Dia 6
II l embre-se - o polimorf i smo o distrbio das mlti plas
Ilpersonalidades do mundo 00
System.out.print ln( "Per sonaIHyObject[O] speaks: " +
pe r sona 1 i t ies[O] . speak(;
System.out.printl n( "Per sonaI HyObject[ l] speaks: M +
personal it i es( l). speak( :
System. out.print ln( "PersonaI HyObject [2] speaks: M +
personal i ties [2] . speakO) :
System. out . prlntln( "PersonalityObject[3] speaks: " +
persona 1 i t i es [3) . speak O) :
System.out.println( "PersonalityObject[4} speaks : " +
personalities[4}.speakO) :
Os primeiros dois teros do mtodo mai n{) no apresentam nenhuma novidade. Conforme voc
viu no Dia 4, a capacidade de substitui o permite tratar um objeto genericamente. Ent retant o, o
trecho a seguir onde o exemplo se torna interessante:
1/ o pol imorfismo faz com que PersonalityObject parea ter
l/muitos comportamentos diferentes
II lembre- se - o polimorf i smo o distrbi o da s m l ti plas
Ilpersonalidades do mundo 00
System.out.println( "Per sonaI HyObject[O] speaks: " +
pe r sonal i t ies[O] . speak( ;
System.out.print ln( "Per sonahtyObject[ l] speaks: M +
persona 1 H ies[ I] . speakO) :
System.out.print ln( "Per sonalityObject [2] speaks: M +
persona I i ties (2) . speak() :
System.out.println( "Per sonalHyObject (3] speaks: " +
persona 1 i ties (3) . speak O) :
System. out . println( "PersonalityObject(4) speaks : +
personal ities(4] . speakO) ;
A Figure 6. 1 ilustra a sada.
FIGURA 6.1
Demolls'raeio do
compor/mllell/O polim/fico.
Po limo rfismo: aprendendo a prever o futuro 125
Com base na sada, parece que o mtodo speak() de Personal i tyObject tem muitos comporta-
mentos diferentes. Mesmo que PersonalHyObject defina speakO para imprimir "1 am an ob-
ject", Pe rsona 1 i tyObject est exibindo mais de um comportament o. Mesmo que o array
supostamente contenha instncias de Persona 1 i tyObject, cada membro do array se comporta de
forma diferente, quando o mtodo principal chama o mtodo speak (). Esse o dilema do com-
portamento poli mrfico; Personal 1tyObject, o nome, parece ter muitos comportamentos.
Novo TERMO
NOTA
persona 1 it i es um exemplo de varivel polimrfica. Uma vari(11ef polimrfica
uma varivel que pode conter muitos tipos diferentes.
Em uma linguagem tipa da, as variveis polimrficas esto restritas a conter
valores especfi cos. Em uma linguagem dinamicamente tipada, uma varivel
polimrfi ca pode conter qualquer valor.
o exemplo anterior explica o mecanismo, mas ele poderia no representar adequadamente o es-
prito do polimorfismo. Afi nal, voc sabe exatamente o que o array contm.
Em vez disso, imagine que voc tenha um objelo cujo mtodo recebe um objeto Persona-
1 i tyObject como parmetro:
public void makeSpeak( PersonalityObject obj ) I
System.out. print ln( obj.speak() );
I
Os relacionamentos com capacidade de subst ituio permitem que voc passe uma instncia do
objeto Personal i tyObject ou qualquer descendente dessa classe para o mtodo makeSpeak (),
como um argumento. Assi m, ao criar descendentes especializados de Persona 1 i tyObject, como
Ext rovertedObject, voc no precisa mudar a lgica do mtodo para que ele use instncias das
novas classes como argumento. Em vez disso, voc pode simplesmente instanciar Extrover-
tedObject (ou qualquer descendente) e passar a instncia para o mtodo.
O polimorfismo entra em ao quando o mtodo makeSpeak() chamado e lhe passado um
obj eto como argumento. O polimorfi smo garant e que o mtodo correto seja chamado atravs do
argumento de Persona 1 i tyObject, chamando o mtodo do objeto com base no tipo da c lasse real
do argumento, em vez do tipo da classe que o mtodo makeSpeakO pensa que est usando.
Assim, se voc passar um objeto ExtrovertedObject, o polimorfismo garantir que a definio
de speak () de ExtrovertedObject seja chamada e no aquela encontrada na classe base. Como
resultado, makeSpeak() apresentar mensagens diferentes na tela, dependendo do tipo de argu-
mento que for passado.
Voc pode apri morar o polimorfismo para adicionar nova funci onal idade em seu sistema, a
qualquer momento. Voc pode adicionar novas classes, que tenham funcionalidades jamais ima-
ginadas quando O programa foi escrito pela pri meira vez - tudo isso sem ter de mudar seu cdi -
,
go j existente. E para isso que serve o software prova do futuro.
Dia 6
Este exemplo apenas a ponta do iceberg polimrfi co. Na verdade, o exemplo representa apenas
uma das mui tas formas do polimorfis mo. O prpri o polimorfi smo correto poli mrfi co!
Infeli zmente, ai nda h pouco consenso na comunidade de 00 quando se trata de polimorfi smo.
Em vez de ent rar na controvrsia, este livro apresentar quatro formas de polimorfismo. O en-
tendimento dessas quatro fonnas comuns deve dar-lhe a base de que voc precisa para comear a
aplicar o polimorfismo. Hoje voc aprender sobre:
I. Polimorfismo de incluso
2. Polimorfismo paramtrico
3. Sobrepos io
4. Sobrecarga
Polimorfismo de incluso
o pol imorfi smo de incluso, s vezes chamado de poli morfismo puro, permite que voc trale ob-
j etos relacionados genericamente. Voc viu o poli morfismo de incluso pela primeira vez, no
incio do dia.
Considere os mlodos a seguir:
publ 1c v01d makeSpeak( Pess1mist1cObject obj ) I
System.out.println( obj.speak() ) ;
}
publ1C v01d makeSpeak( OptimisticObject obj ) I
System. out . println( obj.speak( ) );
}
public v01d makeSpeak( IntrovertedObject obj ) (
System.out.println( obj . speak() ):
}
publ ie void makeSpeak( ExtrovertedObject obj ) (
System.out.println( obj . speak() ) :
}
Pess1m1sticObject, OptimisticObjeet . IntrovertedObject e Ext rovertedObject esto todos
rel acionados, pois lodos eles so objetos Persona 11 tyObj eet. A capaci dade de subst ituio e o
polimorfi smo de incluso pennitem que voc escreva um mtodo para manipular lodos os tipos
de objctos Persona1 1 t yObject:
pu bl 1c void makeSpeak( PersonalityObject obj ) I
System.out.println( obj.speak() ) ;
}
Polimorfismo: aprendendo a prever o futuro 127
A capacidade de substit uio permite que voc passe qualquer obj elo Persona I i tyObject para
o mtodo e o polimorfi smo garant e que o metodo correto sej a chamado na instncia. O poli-
morfismo chamar o mtodo com base no tipo verdadeiro da instncia (Optimi st icObject.
IntrovertedObject . ExtrovertedObject ou Pess imisticObject) e no cm seu tipo aparente
(Persona 1 i tyObject).
O pol imorfis mo de incluso lltil porque di mi nui a quantidade de cdi go que precisa ser escri to.
Em vez de ter de escrever um mtodo para cada ti po concreto de Personal i tyObject, voc pode
simplesmente escrever um mtodo que manipule todos os tipos. O polimorfi smo de incl uso e a
capacidade de substituio permitem que makeSpeak() funcione cm qualquer objeto que ' sej a
um' Persona 1 ityObj ect.
O polimorfismo de incluso torna mai s fcil adicionar novos subtipos em seu progra ma, pois
voc no precisar adicionar um mtodo especificamente para esse novo tipo. Voc pode sim-
plesmente reut ilizar makeSpeak{).
O polimorfismo de incluso tambm interessante porque faz parecer que as instncias de
Personal i tyObject exibem muitos comportamentos diferentes. A mensagem apresentada por
makeSpeak () ser di ferente de acordo com a entrada do mtodo. Atravs do uso cuidadoso do p0-
li morfismo de incluso, voc pode mudar o comportamento de seu sistema, int roduzindo novas
subclasses. A melhor part e que voc pode obter esse novo comportamento sem ler de alterar
nenhum cdigo j existent e.
O polimorfismo o mot ivo pelo qual voc no deve associar automaticamente herana com reu-
tili zao de implement ao. Em vez disso, voc deve usar herana principal mente para permitir
um comportamento polimrfico atravs de relacionamentos com capacidade de substituio. Se
voc definir corretamente os relacionamentos com capacidade de subst ituio, a reutil izao
ser automt ica. O poli morfi smo de incluso permite que voc reutil ize a classe base, qualquer
descendente, ass im como os mtodos que usam a classe base.
Agora, voc provavelmente j entende o mecani smo, mas por que desejaria usar pol imorfi smo
de incluso?
Considere a hi erarquia a seguir:
publi c abstract class Baselog {
II al gumas constantes teis ; no s.
private f inal static String DEBUG
private f ina l static String INfO
private f i nal stat i c St r ing WARNING
private f inal statl c St r ing ERROR
private f inal st atlc St r ing fATAL
preocupe com a si ntaxe
"DEBUG'"

-
MINfO'"

"WARNING" ;

8ERRQR";
8fATAl'"

java.text . Da teformat df java.text.OateFonmat.getDateTimeInstance( ) ;
}
Dia 6
public void debug( St ring message ) {
log( message, DEBUG, getDate() );
}
public void info( Stri ng message ) {
log( message , INFO. getoateO , ;
}
public voi d warn;ng( St ring message ) (
l og( message , WARNING. getDate() ) ;
}
publ ic void error( String message ) (
log ( message , ERROR , ge tDate() );
}
publi c voi d f atal ( String message ) (
log( message , FATAL, getoateO );
}
II cr ia uma indicaao de tempo
protected String getDateO {
}
java.ut il. Date date" new java.util.DateO;
return df.format( date );
II permite que as subclasses def i nam como e onde vo gravar o l og
protected abstract voi d l og( St ring mess age, String leve I . St r i ng t ime ,;
BaseLog um log abstrai o que define a interface pblica de um log, assim como alguma imple-
mentao. Ba seLog abstraIo porque cada desenvol vedor precisa personalizar o modo como o
log gravado. Todo desenvolvedor de Baselog deve definir o mtodo logO.
Tomando a classe abstrata, voc garante que todo desenvolvedor implement e as subclasses cor-
retament e. Tal estratgia permite que voc rellti I ize o projeto do log entre muitos aplicali vos di-
ferentes. Quando um novo aplicativo aparecer, voc poder simpl esmente fornecer a
implementao necessria para esse apli cat ivo. No h necessidade de cri ar um novo projeto de
logo Em vez disso, voc pode reutilizar o projeto de log delineado em Baselog, fornecendo im-
plementaes personali zadas.
publi c class Filelog extends Baselog {
private java .i o.Pri ntWriter pw;
public Fi l elog ( Stri ng filename )throws java.i o. IOExcepti on {
pw new java.io. PrintWriter( new java.i o. FileWriter( f ilename ) , ;
}
protected void log( St r ing message , String leveI . Stri ng ti me) {
pw. pr intln( l evel + "; " + t ime + M; M + message );
Polimorfismo: aprendendo a prever o futuro
pw. flush();
}
public void close() (
pw.c1ose() ;
}
pu bl i c class Screenlog extends Baselog (
}
protected void log( St ring message , String level , String time) (
System. out.println( l eve l + "; " + ti me + ": " + message ) ;
}
129
Fi 1 elog e Screenlog herdam de Baselog e implementam o mtodo 1 og(). Fi 1 elog grava em um
arquivo, enquanto Screenlog escreve na tela.
Lembrando do exemplo Emp l oyee do Dia 4, razovel suspeit ar que exi sta urna classe que saiba
corno recuperar objetos Emp10yee a partir de um banco de dados:
pub1ic class Empl oyeeDatabaseAccessor (
private Baselog error_log ;
public Empl oyeeDat abaseAccessor( Basel og l og ) throws InitDBException {
error_log l og;
try (
II a conexo com o banco de dados
I cat ch( DBExcept ion ex ) I
error_l og. fatal ( "cannot access database: " +
ex.getMessage() );
throw new Ini tDBException( ex.getMessage() );
}
}
}
public Emp10yee ret rieveEmp1oyee( St r ing first name , String last name )
throws EmployeeNotFoundException {
}
try {
II tenta recuperar o fu ncionrio
return nu11;
} catch( Emp1oyeeNotFoundExcept ion ex ) {
}
error_1og.warning ( "cannot locate employee: " + 1ast _name +
" , " + f irst_name ,;
throw new EmployeeNotFoundException( 1ast_name, first name , ;
II etc. , cada mt odo usa error_l og para registrar erros
Dia 6
A classe EmployeeDatabaseAccessor recebe um obj eto Basel og como argumento em seu constru-
tor. Uma instncia usar esse log para gravar todo e qualquer event o importante. Considere o
mtodo mainO a seguir:
public static void ma i n( Stri ng [] ar gs ) {
Baselog 10g new Screenlog ();
Emp l oyeeDatabaseAccessor eda = new EmployeeOa tabaseAccessor ( 10g ) ;
Employee emp eda. retri eveEmployee ( MEmployee" , M r . ~ )
}
Concebivelmente, o mtodo mai n() poderia passar qualquer subclasse de Ba sel 09 para Empl o-
yeeDatabaseAccessor. Um aplicat ivo poderia fazer o mesmo. EmployeeDatabaseAccessor
prova de futuro - no que di z respeito ao registro. Talvez no futuro voc precise de um arquivo
de log que funcione a cada 24 horas ou um que crie um nome de arquivo usando a data. Talvez
outro log faa registros em um manipulador de erros, que receba informaes da rede. Quem
pode ter certeza? Entretanto, com O polimorfismo de incluso, voc est pronlo.
Sem pol imorfismo de incluso, voc pred saria de um construtor para cada tipo de log que qui-
sesse fazer o accessor usar. Entretanto, isso no pra a. Voc tambm precisaria trocar cdigo
dentro do accessor. para que ele soubesse qual log deveria usar. Um objeto EmployeeOataba-
seAccessor que no usasse polimorfi smo, mas quisesse suportar mui tos logs di ferentes, poderi a
ser como segue:
publ i c class Empl oyeeOatabaseAccessor {
pr ivate Fllelog f il e_log;
pr ivate ScreenLog screen_l09;
private i nt log_type;
/ / a I gumas cons tantes ' tei s'
private f i nal static i nt FILE_LOG "O;
private final static i nt SCREEN_LOG " 1;
pu bl iC EmployeeDatabaseAccessor{ Filelog 109 ) throws InitDBException {
f ile_l og 109 ;
109_type FI LE_lOG;
inH();
}
publiC EmployeeDatabaseAccessor( Sc reenLog 10g ) throws Ini tOBException {
screen_l og log ;
l 09_type SCREEN_LOG:
i nH{):
}
publ i C Employee retrieveEmployee ( St r i ng f i r st_name . String last_name )
}
Polimorfismo: aprendendo a prever o futuro
throws EmployeeNotFoundExcept ion I
t ry {
}
II tenta recuperar o funcionr io
return nu11;
) catch( EmployeeNotFoundExcept ion ex ) I
if( 1og_type "" FIlE_lOG ) {
}
file_1og.warning( cannot locate employee: " +
last_name + ", " + first_name );
J else if ( log_type ~ SCREEN_lOG ) I
screen_1og.warning( "cannot locate employee: " +
last_name + ", " + first_name );
}
throw new EmployeeNotFoundException( last name , first name );
private vold lnlt () throws InitOBException {
try {
}
II ini cializa a conexo com o banco de dados
) catch( OBException ex ) {
}
if( log_type Fl LE_lOG ) {
file_log . fatal( "cannot access database : +
ex.getMessageO );
) else if ( log_type ... SCREEN_lOG )1
screen_log.fat al( cannot access database: M +
ex.getMessageO ) ;
}
throw new InitOBException( ex.getMessage(} );
II etc. Cada mtodo usa error_log para registrar erros
131
Voc precisar atual izar Emp 1 oyeeDa tabaseAccessor sempre que quiser adicionar suporte a um
novo log. Agora, qual verso voc gostaria de manter?
Polimorfismo paramtrico
o polimorfis mo paramtrico permite que voc crie mtodos e tipos genricos. Assim como o po-
limorlismode incl uso, os mtodos e tipos genricos pennitem que voc codifique algo uma vez
e faa isso trabalhar com muitos t ipos diferentes de argumentos.
Mtodos paramtricos
Embora o polimorfismo de incluso arete o modo como voc v um objeto, o polimorfi smo pa-
ramtrico areia os mtodos. O polimorfismo paramtrico pennite que voc programe mtodos
Dia 6
genricos retirando a referncia de declaraes de tipo de parmetro at o momento da execu-
o. Considere o mtodo a segui r:
lnt add(lnt a, i nt b)
add() recebe dois intei ros e retoma a soma. Esse mtodo mui to explcito; ele recebe dois intei-
ros como argumentos. Voc no pode passar dois nmeros reais para esse mtodo ou dois obje-
lOS matriz. Se voc tentar, obter um erro em tempo de compilao.
Se voc quiser somar dois nmeros reais ou duas matri zes, ento deve criar mtodos para cada
ti po:
Matrix add_matrix(matrix a, matrix b)
Rea l addJeal (real a, real b)
etc., para cada tipo que voc queira somar.
Seria conveniente se voc pudesse evitar ter de escrever mui tos mtodos. Primeiro, ter de escre-
ver muitos mtodos torna scus programas maiores. Voc precisar separar um mtodo para cada
tipo. Segundo, mais cdigo leva a mais erros e a mais manuteno. Voc no quer tornar a manu-
teno mais difcil do que precisa ser. Terceiro, ter de escrever mtodos separados no modela

add{) nat uralmente. E mais natural pensar apenas em tennos de add{) e no de add matrix() e
add_real ().
O polimorfismo de incluso apresenta uma soluo para o problema. Voc poderi a declarar um
ti po chamado addable, que teria um mtodo que soubesse como somar-se a outra instncia de
addable.
O t ipo poderi a ser como segue:
publ i c abs tract class Addable (
public Addable add(Addable) ;
J
O novo mtodo seria como segue:
Addable add_addable(Addable a, Addable b)
Return a.add(b)
NOTA
s vezes, o exemplo ant erior referido como polimorfismo de f unAo.
Est tudo bom, tudo bem. Voc s6 precisa escrever um mtodo para somar, entretanto o mtodo
funciona apenas para argumentos de Addabl e. Voc tambm precisa certi ficar-se de que os obje-
tosAddabl e passados para o mtodo sejam do mesmo tipo. Tal requisito propenso a erros e con-
trri o ao que a interface implica. De qualquer modo, voc realmente no resolveu o problcma
Polimorfis mo: aprendendo a prever o futuro 133
original. Voc ai nda precisar escrever mtodos para cada tipo que queira somar, que no seja do
ti po Addabl e. Nem tudo que voc desejar somar ser Addable.
a que o polimorfi smo paramtrico entra em ao. O polimorfis mo paramtri co permi te que
voc escreva um e apenas um mtodo para somar todos os tipos. O pol imorfismo paramtrico re-
tarda a declarao dos tipos dos argument os.
Considere o mtodo reescri to para ti rar proveito do polimorfi smo paramtri co:
,dd([T] " [T] b) , [T]
[T] um argumento exatamente igual a a e b. O argumento [T] especifica o tipo de argumento de
a e b. Declarando um mtodo dessa maneira, voc adi a a defini o do tipo dos argumentos at o
momento da execuo. Voc tambm notar que a e b devem ter o mesmo [T].
Internamente, o mtodo pode ser como segue:
[T] ,dd([T] " [T] b)
return a + bj
O polimorfis mo no mgico. Ele ainda espera que o argumento tenha determinada estrut ura.
Neste caso, qualquer argumento que voc passe dever definir + para esse tipo.
NOTA
Determinada estrutura pode ser a presena de certo mtodo ou operador cor-
retamente defi ni do.
Tipos paramtricos
Levado sua concluso extrema, o poli morfi smo paramtrico pode estender seu alcance aos
prprios tipos. Assim como os mtodos podem ter parmetros paramtricos, os ti pos podem ser
eles prprios paramtricos. Consi dere o TAO Queue defin ido no Dia 2:
Queue [T]
void enqueue([T])
[T] dequeue O
boolean isEmpty()
[T] ,oekO
O Queue um tipo parametrizado. Em vez de escrever uma classe de fil a para cada tipo que gos-
taria de enfilei rar, voc simplesmente especi fi ca os tipos de elementos que gostari a de enfi leirar,
para conter dinamicamente em tempo de execuo. Originalmente, voc poderi a dizer que o ob-
jeto Queue era um Queue de Object o Agora, oobjeto Queue pode ser um Queue de qualquer ti po.
Assi m, se voc quisesse annazcnar objctos Empl oyee, fari a a seguinte declarao:
Queue[Empl oyeel employee_queue = new Queue[Employee] :
Agora, quando voc usar Queue, s podem usar enqueue() e dequeue () nas inst,'i ncias de funcionrio.
Dia 6
Se ti pos paramtricos no forem possveis, voc precisaria escrever uma fil a separada para intei-
ros, outra para reais e ai nda outra para alienigenas do espao.
Em vez di sso, usando ti pos parametrizados, voc pode escrever o tipo uma vez, neste caso uma
fila, e usa- lo para cont er todos os tipos possiveis.
NOTA
Polimorfismo paramtrico soa bem no papet, mas h um problema: suporte.
Para aqueles que esto famitiarizados com Java, os exemplos anteriores po-
dem parecer estranhos. Na verso 1.3, a linguagem Java no tem suporte nati-
vo a t ipos parametrizados ou polimorfismo paramtrico em geral. Voc pOde
imitar tipos parametrizados, mas o preo na efi cincia bastante alto. Existem
algumas ext enses Java disponiveis para suporte a polimorfismo paramtri -
co, entretanto nenhuma delas foi oficialmente sancionada pela Sun.
A si ntaxe dos exemplos anteriores completamente inventada. Entretanto, ela
demonstra as idi as adequadamente.
Sobreposio
A sobreposio um tipo importante de pol imorfismo. Voc viu como cada subclasse de Pe r so-
nalityObject sobreps o mtodo speakO no incio deste dia. Ent retanto, voc vi u detalhada-
mente um exemplo ainda mais interessante de sobreposio e polimorfi smo no Dia 5.
Especificament e, considere as definics de classe MoodyObject e HappyObject :
publ l c class MoodyObject (
,
II retorna o humor
protected Stri ng getMood{) (
return "moody ";
,
II pergunta ao objeto como ele se sent e
public void queryMood() {
System, out.println("I feel " + getMood() + " today! ");
,
public cl ass HappyObject extends MoodyObject {
II redef i ne o humor da classe
protected String getMood() {
return "happy";
,
II especializao
public voi d laugh() (
Polimorfi smo: aprendendo a prever o futuro 135
Sys tem. out. pr; nt 1 n ("hehehe. .. hahaha... HAHAHAHAHAHA!!!!!");
}
}
Aqui, voc v que Ha ppyObject sobrepe o mtodo getMood() de MoodyObject. O interessante
que adefi ni o de MoodyObject de queryMood( ) faz uma chamada a getMood () internamente.
Voc notar que HappyObject no sobrepe o mtodo queryMood(). Em vez disso, HappyObject
si mplesmente herda o mtodo como um mtodo recursivo de MoodyObject. Quando voc chama
queryMood() em HappyObject , o poli morfismo da instncia garante a chamada da verso sobres-
crita de getMoodO em HappyObject, internamente.
Aqui, o pol imorfismo cuida dos detalhes do mtodo a ser chamado. Isso o libera de ter que rede-
fin ir queryMoodO, para que ele chame a verso correta de getMoodO.
Posteriorment e, voc viu como poderia tornar getMoodO abstrato na progenitora:
pub1ic abstract c1ass MoodyObject (
}
II retorna o humor
prot ected abst ract St r i ng getMood( ) ;
II pergunta ao objet o como el e se sente
publ ic void queryMoodO t
System.out.print1n( "I fee l " + getMoodO + " t oday!M);
}
Os mtodos abstralos so freqUentemente referidos como mtodos adiados, poi s voc retarda a
definio para as classes descendentes. Entretanto, assim como em qualquer outro mtodo, a
classe que define o mtodo abstraio pode fazer chamadas ao mtodo. Assim como os mlodos
sobrepostos, o polimorfi smo garantir que a verso correta do mtodo adiado seja sempre cha-
mada nas subclasses.
Sobrecarga
A sobrecarga, tambm conhecida como polimorfismo ad-llOc, permite que voc use o mesmo
nome de mtodo para muitos mtodos diferentes. Cada mtodo difere apenas no nmero e no
tipo de seus parmetros.
Considere os mtodos a segui r, definidos em java.1ang.Math:
pub1i c sta tic int max(i nt a, int b) ;
publ i c stat ic 10n9 max( long a, 10n9 b):
public stati c fl oat max(float a, float b) :
pu bl i c stat ic double max(doubl e a, doubl e b) ;
Dia 6
Os mtodosmax () so todos exemplos de sobrecarga. Voc notar que os mtodosmax( ) di ferem
apenas no ti po de parmetros.
A sobrecarga lIt il quando um mtodo no defi ni do por seus argumentos. Em vez disso, o m
todo um conceito independente de seus argumentos. O mtodo transcende seus parmetros es-
pecificas e se aplica a muitos tipos di ferent es de parmetros. Peguemos o mtodo max (). max ()
um conceito genrico que recebe dois parmetros e informa qual maior. Essa defini o no
muda se voc comparar int ciros, n(mlcros com ponto fl ut uante, valores duplos ou a ordem da bi
cada de um bando de pssaros.
A operao + out ro exemplo de mtodo sobrecarregado. O conceito + independent e de seus
argumentos. Voc pode somar todos os tipos de element os.
NeTA
Voc no pode SObrecarregar ou sobrepor operadores na linguagem Java; en-
tretant o, a l inguagem Java tem alguma sobrecarga int erna.
Se a sobrecarga no fosse possvel , voc teria que fazer o seguinte:
publ ic sta t i c i nt max_l nt( lnt a. int b }i
publ i c stati c 10ng max_longe 10ng a. 10ng b ) i
pub1i c stat i c f loat max_fl oat( fl oat a, floa t b ) i
publ i c sta tic doub1e max_doubl e( double a, doubl e b }i
publ i c stat ic bi rd max_b i rd ( bi rd a. bi rd b l i
Sem a sobrecarga, voc deve dar a cada mtodo um nome exdusivo. Os mtodos ma x () no
transcenderi am mais seus parmetros. Max deixari a de ser um conceito abstrato. Em vez disso,
voc teri a de defi nir o mtodo em tennos de seus argumentos. Ter de cscrever o mtodo ma xO
dessa maneira no um jeito natural de modelar o conceito de max (). Isso tambm fornece ao
programador mais deta lhes para ter em mente.
,
E daro que chamar cada mtodo com um nome diferent e no polimrfi co. Quando todos os
mtodos comparti lham o mesmo nome, voc obtm comportament o polimrfi co, pois diferen
tes mtodos so chamados internamente, dependendo dos ti pos de parmetros passados. Voc
pode simplesment e chamar max () e passar seus parmetros. O poli morfi smo cuidar de chamar a
mtodo correto internamente.
O modo como o polimorfi smo direciona a chamada de mtodo dependc da linguagem. Algumas
linguagens solucionam a chamada de mtodo durante a compilao, enquant o OUl ras vinculam a
chamada de mtodo dinamicamente, em tempo de execuo.
Po limo rfismo: aprendendo a prever o futuro 137
Converso
Converso e sobrecarga freqentement e andam lado a lado. A converso tambm pode fazer
com que um mtodo parea como se fosse polimrfico. A converso ocorre quando um argu-
mento de um ti po convenido para o tipo esperado, intemamenle.
Considere a definio a seguir:
public f1 0at add( f10at a, f10at b );
add() recebe dois argumentos float e os soma.
O segmento de cdigo a seguir cria algumas variveis inteiras e chama o mtodo addO:
int iA " 1;
int i B 2:
add(iA,iB);
,
Entretanto, o mtodo add() solicita dois argument os float. E a que a converso entra em ao.
Quando voc chama add () com argumentos i nt, os argumentos so convcnidos em valores f10-
a t pelo compilador. J sso signi fica que, antes que os argumentos i nt sejam passados para add (),
primeiro eles so convert idos em valores f1 oat. Os programadores Java reconhecero essa con-
verso.
Assi m, a converso faz o mtodo addO parecer polimrfico, pois O mtodo parece funci onar
para valores f 1 oa t e int. Conforme voc vi u na lti ma seo, tambm seria possivel ter um m-
todo add sobrecarregado, da forma:
pub1ic int add(1nt a, 1nt b);
Nesse caso, add (i A, 1 B) no resultaria em converso. Em vez disso, o mtodo add () corretamen-
te sobrecarregado seria chamado.
Polimorfismo eficaz
Assim como todos os outros pil ares, o polimorfismo eficaz no acontece por acidente. Existem
alguns passos que voc pode executar para garantir um pol imorfi smo eficaz.
O primeiro passo para o polimorfi smo eficaz ter encapsulamento e herana eficientes.
Sem encapsulamento seu cdigo se torna facil mente dependente da implementao de suas clas-
ses. No pcnnita que o encapsulamento seja destruido. Se o cdigo se tornar dependente de al-
guns aspectos da implementao de uma classe, voc no poder conectar uma subclasse que
refaa essa implementao. Um bom encapsulamento o primeiro passo para o polimorfi smo.
Dia 6
imponante notar que, nesse contexto, interface um pouco di ferent e da no-
o de interfaces Java, embora sejam semelhantes. Aqui , o termo interface
usado para descrever a lista de mensagens que voc pode enviar para um ob-
j eto. Todas essas mensagens compreendem a interface pbli ca de um objeto.
Uma interface Java tambm define as mensagens que voc pode enviar para
um objeto Java. Quando uma classe Java implementa uma interface, todos os
mtodos da int erface se tornam pane da interface pbl ica global da classe.
Enlretanto, a int erface Java no a nica maneira de def inir as mensagens que
voc pode enviar para um objeto. Na li nguagem Java, qualquer mtodo pbli-
co definido na definio da cl asse se tornar pane da interface pblica do obje-
to. Isso significa que. se uma classe implementar uma interface e definir
mtodos pbli cos adicionais. os dois conjuntos de mtodos se tornaro parte
de sua interface pbli ca.
Usar interfaces Java ao programar considerada uma boa prt ica, pois isso
separa a definio da interface da implementao da classe dessa interface.
Quando voc separa as duas, muitas classes de outro modo no relacionadas
poderiam implementar a mesma interface. Assim como a herana, os objetos
que compartil ham uma interface comum tambm podem tomar parte em rela-
ci onamentos com capacidade de substituio, mas sem ter de fazer parte da
mesma hi erarqui a de herana.
A herana um fator importante no polimorfi smo de incluso. Sempre tente estabelecer relacio-
namentos com capacidade de substituio programando o mais prximo possvel da classe base.
Essa prtica penniti r que mais tipos de objelos participem de seu programa.
Um modo de estimular a capacidade de substit uio atravs de hierarquias bem pensadas.
Mova as caractersticas comuns para classes abst raias e programe seus obj etos para lIsar a classe
abstrata e no uma descendente concreta especfi ca. Desse modo, voc poder int roduzir qual-
quer descendente em seu programa.
DICA
Para obter um poli morfis mo eficaz, siga estas dicas:
Siga as dicas do encapsulamento e da herana efi cazes.
Sempre programe para a interface e no para a implementao. Progra-
mando para uma interface, voc define especi fi camente quais tipos de ob-
j etos podem participar de seu programa. Ento. o pOlimorfismo garantir
que esses objetos participem corretamente.
Pense e programe genericamente. Deixe o polimorfi smo se preocupar
com os det alhes especificos. Se voc deixar o pOlimorfi smo fazer seu tra-
balho. no preci sar escrever muito cdigo. El e cuidar dos detalhes para
voc!
Defina a base do polimorfismo estabelecendo e usando relacionamentos
com capaci dade de substitui o. A capacidade de substitui o e o poli -
morfismo garanti ro que voc possa adi cionar novos subti pos em seu
programa e que o cdigo corret o ser executado, quando esses sUbt ipos
forem usados.
Polimorfismo: aprendendo a prever o futuro 139
Se sua linguagem fornece uma maneira de separar completamente a in-
terface e a implementao, favorea esse mecanismo em detri mento da
herana. Um exemplo de mecanismo que permite definir e herdar interface
sem i mplement ao a Java Int erface. Separar os dois permite uma capa-
cidade de substituio mais fl exvel, obtendo-se assim mai s oport uni dade
de polimorfismo .
Use classes abstratas para separar a interface da implementao. Todas
as classes no-folha devem ser abstratas; programe apenas para essas
classes abstratas.
A discusso anteri or focalizou muito as linguagens fortemente tipa das, como Java. Em
uma linguagem fortemente tipada, voc deve deciarar explicitamente o tipo de uma
varivel. Entretanto, algumas linguagens orientadas a objetos, como Smalltalk. no
tm esse requi sito. Em vez disso, tais linguagens so dinamicamente tipadas. Tipagem
dinmica signifi ca que voc no precisa indicar explicitamente o tipo de uma varivel,
ao cri-Ia. Em vez di sso, o tipo determi nado dinamicamente, em tempo de execuo.
Assim, basicamente, toda varivel polimrfi ca.
O poli morfismo um pouco mais simples em linguagens dinami camente tipadas. As
variveis so automaticamente pol imrficas, pois elas podem conter qualquer valor.
Desde que o objeto tenha o mtodo esperado, ele pode trabalhar de forma pOlimrfica.
E claro que tudo ser destruido, se voc tentar chamar um mtodo que no existe!
As l inguagens ti padas so um pouco mais rigorosas. As linguagens di namicamente ti -
padas permit em que voc t rat e um obj eto de forma polimrfica, desde que ele tenha o
mtodo em que voc est interessado. O objeto no precisa pertencer a uma hierar-
qui a de herana especifica. As li nguagens f ortemente tipadas exigem que o objeto per-
t ena a uma hierarquia de herana especif ica.
Entretanto, os dois casos no so to diferentes assim. O comportamento que real
mente define um tipo; as linguagens tipadas exigem apenas a presena de todos os
comportamentos definidos. Assim, os concei t os por trs do polimorfismo em lingua
gens fortemente tipa das e dinmicas so os mesmos. Tudo se reduz a um objeto que
sabe como executar algum comportamento.
O f oco nas linguagens ti padas deliberado. Focalizar diretamente a forte tipagem o
obriga a se concentrar no tipo, sem perder os detalhes. Se voc pode entender o poli-
morfismo em uma linguagem tipada, ento certamente pode entend-lo em uma lin-
guagem no tipada. O inverso parece no ser verdadeiro I
A escolha de focalizar o tipo tambm pragmtica. A maioria das princi pais l ingua-
gens orientadas a objetos fortemente tipada.
Armadilhas polimrficas
Ao se usar polimorlismo, existem trs annadil has pri ncipai s a serem evitadas.
Dia 6
Armadilha 1: mover comportamentos para cima na
hierarquia
Mui to freqUentemente, desenvolvedores inexperientes movero comjX)rtamentos para cima na
hierarquia, para aumentar o pol imorfismo. O ent usiasmo em tratar tudo de maneira poli mrfica
pode cegar faci lmente um desenvolvedor e resul tar em hierarquias mal projetadas.
Se voc mover um comportamento para cima demais em uma hierarquia, nem todos os descen-
dentes podero suportar o comportamento. Lembre-se de que os descendentes nllnca devem reti-
rar funcionalidade de seus ancestrais. No dest rua uma boa herana para tornar seus programas
mais pol imrficos.
Se voc tiver vontade de mover comportamentos para cima na hierarquia, unicamente para me-
lhorar o polimorfismo, pare. Voc est em territrio perigoso.
Se voc encontrar limi taes demais em sua hierarquia, talvez queira rev-I a. Mova elementos
comuns para classes abstratas; mova funcional idade por toda parte. Ent retanto, no mova mto-
dos para cima na hi erarq uia, alm do nvel onde eles so necessrios pela primeira vez. Nilo se
habi tue a mover comport amentos por capri cho, simplesmente para adicionar suporte polimrfi-
co. Certifique-se de que voc tenha out ro moti vo vlido para a mudana. Voc pode ter sorte al-
gumas vezes. mas a prtica o pegar posteri ormente, e maus hbi tos de programao so dificeis
de perder.
Ao desenvolver suas hierarquias, importante considerar a evol uo em potencial das classes,
com o passar do tempo. Voc pode di vi dir a hierarquia em nveis funcionai s. Com o passar do
tempo, voc pode evoluir sua hierarquia, adicionando novos n veis funciona is, quando eles fo-
rem necessrios. Entretanto, voc s deve especular com base nos requi si tos fut uros que conhe-
ce. Exi ste um nmero inl1nito de 'e se' indefi nidos. Planeje apenas as eventua li dades que voc
conhece.
Armadilha 2: sobrecarga de desempenho
Tudo tem um preo. O verdadei ro polimorfismo sofrer certa sobrecarga de desempenho. O po-
limorfismo no pode competir com um mtodo que conhece seus argumentos estaticamente. Em
vez di sso, com o polimorfi smo, devem haver verificaes em tempo de execuo. Para o poli-
morfi smo de incluso, a implementao real do objeto para o qual voc envia mensagens deve
ser determinada em tempo de execuo. Todas essas veri ficaes levam tempo para terminar e
so mais lentas em comparao aos valores que conhecem seus ti pos estati camente.
As vantagens da manuteno e da nexibilidade do programa devem compensar qualquer perda
de desempenho. Ent retanto, se voc estiver escrevendo um apli cativo em que o tempo seja im-
portante, talvez precise tcr cuidado ao usar pol imorfismo. Entretanto, mantenha o desempenho
em perspectiva. Cri e uma implementao 00 limpa, trace o perfil da implementao e oti mi ze
cui dadosamcnte o desempenho, onde o traado do perfil revela problemas.
Polimorfi smo: aprendendo a prever o f uturo 141
Armadilha 3: vendas
o polimorfi smo de incl uso tem uma defi cincia. Embora seja verdade que voc pode passar
uma subclasse para um mtodo que est esperando uma classe base. o mtodo no pode tirar pro-
veito de todos os novos mtodos que a subclasse possa adicionar em sua interracc. Porcxcmplo,
a classe Fi 1 elog adiciona um mtodo c1oseO em sua interface. O mtodo retrieveEmpl oyeeO
de EmployeeOatabaseAccessor no poder uslo. Um mtodo programado para acei tar a classe
base s saber manipular a interrace da classe base.
A Figura 6.2 mostra como a visual izao de uma instncia relat iva. Optar por ver uma instncia
de Fi 1 eLog como se fosse uma instncia de BaseLog corno colocar vendas nos olhos. Voc s
tem acesso aos mtodos declarados em BaseLog. claro que, se voc tratar da instncia de Fil e
Log como uma instncia de Fi 1 eLog, obter toda a funcionalidade definida ou herdada pela classe
Fi 1 eLog, como aconteceria normalmente.
FIGURA 6 .2
Di/erellles l"iscs
do mesmo objero.
.

Basel og bI '" new FileLogl'file')
BllseLog II '" new FileLogl'fi le'):
Baselog
debugU
InfoU
wll mingU
error()
fetaltl
FileLog
loseU
,
,
,
,
InlJl.lnjll de
Filel og
, "-----'= '--'
,
Assim, quando voc adicionar novos tipos de fonna polimrfica, seu cdigo antigo no poder
usar nenhum dos mtodos novos. Ent retant o, o novo cdigo (ou o cdigo atua li zado) est livre
para usar qualquer coisa na inlerrace pblica.
Novamente, essa armadilha aponta o moti vo pelo qual um descendente nunca deve remover
componament os de seu progenitor. Um mtodo que conte com o polimorfismo de incluso s
saber como exercer os mtodos defin idos com o ti po que estiver programado para manipular.
Se estiver faltando um comportamento, o mtodo no funcionar.
Essa armadil ha tambm mostra que simplesmente trocar para um novo tipo em seu programa j
existente, freqUentemente no to fcil quanto poderia parecer. No exemplo do Fi 1 eLog, voc
preci sar encontrar um modo de chamara mtodo cl ose(), quando seu programa tiver termina
do com o log.
Dia 6
Advertncias
Existe uma advenncia imponant e a ser lembrada ao se considerar o polimorfi smo. Cada lin-
guagem implementa o polimorfismo de uma fonna diferente. Esta discusso esboou as defi ni -
es tericas por trs do poli morfi smo.
A maioria, se no todas as linguagens, supona polimorfismo de incl uso em algum grau. Por ou-
tro lado, poucas suponam o verdadeiro poli morfi smo paramtrico. A linguagem Java cenamen-
te no supona polimorfi smo paramtrico. C++ fi nge implement-lo.
A maioria das linguagens tem alguma forma de sobrecarga e converso. Entretanto, a implemen-
tao exata vai vari ar de uma linguagem para outra.
Assim, quando voc comear a programar de fonna poli mrfi ca, lembre-se da teoria, mas pros-
siga cuidadosamente. Voc no pode evitar as I im itaes de sua I inguagem de impl ementao.
Como o polimorfismo atende os objetivos
da 00
o polimorfismo atende cada um dosobjetivosda poo. O polimorfi smo produz software que:
1. Natural
2. Confivel
3. Reut ilizvel
4. Manut envel
5. Extensvel
6. Oportuno
O polimorfi smo atende esses objet ivos das seguintes maneiras:
Natural: o poli morfi smo permite que voc modele o mundo mais nattlr'dlmente. Em vez
de programar para casos especiais, o pol imorfis mo permite que voc trabalhe em um n-
vel mais genrico e conceit uaI.

A sobrecarga e o polimorfi smo paramtrico permitem que voc modele um objeto ou m-
todo em nvel conceituai do que esse objetoou mtodo faz e no de quais tipos de parme-
tros ele poderia processar. O polimorfi smo de incluso permite que voc manipule tipos
de objetos, em vez de implementaes especficas.
Tal programao gencri ca c mais natural, pois ela o libera para programar no nvel
concei tuai do problema e no nas implementaes especficas.
Confivel: o poli morfismo resulta em cdigo confi vel.




Polimorfismo: aprendendo a prever o futuro 143
Primeiro, polimorfismo simpl ifica seu cdigo. Em vez de ter de programar casos espe-
ciais de cada tipo de objeto que poderia manipular, voc escreve simplesmente um caso.
Se voc no pudesse programar dessa maneira, teria de atualizar seu cdigo sempre que
adicionasse uma nova subclasse. Ter de atualizar cdigo algo propenso a erros.
Segundo, o polimorfismo pennite que voc escreva menos cdigo. Quanto menos cdigo
voc escreve, menores as chances de introduo de erros.
O polimorfismo tambm pennite que voc isole partes do cdigo das alteraes das sub-
classes, garantindo que elas tratem apenas com os nveis da hierarquia de herana impor-
tantes para sua funo.
Reutilizvel: o polimorfismo auxilia a reutili zao. Para que um objcto use outro, ele s
precisa conhecer a interface do segundo objeto e no os detalhes da implementao.
Como resultado, a reutilizao pode ocorrer mai s prontamente.
Manutenvel: o polimorfismo auxilia a manutenibilidade. Conforme voc j viu, o poli-
morfismo resulta em menos cdigo. Assim, h menos para manter. Quando voe precisa
manter cdigo, no obrigado a manter grandes estruturas condicionais.
Extensvel: o cdigo poli mrfico mais extensvel. O poli morfi smo de incluso permite
que voc adicione novos subtipos em seu sistema, sem ter de alterar o sistema para usar o
novo subtipo. A sobrecarga permite que voc adicione novos mtodos, sem terde se preo-
cupar com conflitos de atribuio de nomes. Final mente, o polimorfismo paramtrico
pennite que voc estenda automaticamente suas classes, para suportar novos ti pos.
Oportuno: o pol imorfismo oajuda a escrever cdigo oportuno. Se voc pode escrever me-
nos cdigo, ento pode distribui r seu cdigo mais cedo. Como o polimorfismo o estimula
a programar genericamente, voc pode adicionar novos tipos quase que instantaneament e
em seus programas. Como resultado, a manuteno e a extenso de seus programas ocor-
re em um ritmo muito mais rpido.
Resumo
Polimorfi smo ter muitas formas. O polimorfismo um mecanismo que permi te a um nico
nome representar cdigos diferentes. Como um ni co nome pode representar cdigos diferentes,
esse nome pode expressar muitos comportamentos diferentes. O polimorfi smo permite que voc
escreva cdigo humorado: cdigo que exibe diferentes comportamentos.
Para os objetivos deste li vro, voc aprendeu a respeito de quatro diferentes tipos de polimorfismo:
Polimorfismo de incluso
Polimorfi smo paramtri co
Sobreposio
Sobrecarga
Dia 6
Embora exista cert o desacordo em relao ao polimorfismo na comunidade de 00, esses tipos
descrevem algumas das fonnas mais comuns de pol imorfi smo. Entender esses tipos proporcio-
nar a voc uma boa base na teoria de polimorfismo.
O pol imorfismo de incluso permi te que um objeto expresse muitos comport amentos diferentes,
em tempo de execuo. Do mesmo modo, o pol imorfi smo paramtrico permite que um obj etoou
mtodo opere com vrios tipos de parmetro diferentes.
A sobrepos io permi te que voc sobreponha um mtodo e saiba que o polimorfi smo garantir
que o mtodo correto sempre ser executado.
Fi nalmente, a sobrecarga pennite que voc declare o mesmo mtodo vrias vezes. Cada declarao
difere simplesmente no nmero e no ti po de argumentos. A converso faz um mtodo parecer pol i-
mrfico, convertendo argumentos nos tipos de argumentos esperados pelo mtodo.
O polimorfismo permite que voc escreva cdigo mais curto e mais inteligivel, que tambm
mais flexvel para os requisitos futuros.
Perguntas e respostas
P Existem trs pilares na programao orientada a objctos. Se cu no usar todos os
trs, meu software nllo ser OO?
R No minimo, voc sempre deve usar encapsulamento. Sem encapsulamento, voc real-
mente no ter herana eficaz, polimorfi smo ou 00 em geral. Quanto aos out ros dois pi-
lares, voc s deve us- los quando fi zer sent ido. No use herana ou polimorfismo
apenas para que voc possa dizer que os uti lizou em seu programa.
A ausncia de herana e polimorfismo no significa que um programa necessariament e
no-OO. Entretanto, voc precisa dar uma boa olhada em seu programa, para ver se est
desperdi ando uma oportunidade de lIsar corretament e os outros pilares.
P Por que existe tanto desacordo cm relao ao polimorfismo na comunidade de OO?
R H muito desacordo na literatura que ainda precisa ser acertado. Parece que cada autor
tem seu prprio vocabulrio. Grande parte desse desacordo provm do fato de que cada
linguagem implementa o polimorfismo de sua prpria manei ra. Todas essas diferentes
implementaes tm di vidido a comuni dade.
O important e que voc ent enda os quatro tipos apresentados hoje. Embora eles possam
receber nomes diferentes, esses quatro tipos so bastant e reconhecidos.
P A linguagem Java vai suportar polimorfismo paramtrico?
R Somente a Sun pode responder essa pergunta. Entretanto, atualmentc existe um Java
Specificat ion Request (JSR-OOOO 14), que foi aceito para desenvolvimento. Ele acrescenta ti-
pos genricos na linguagem de programao Java. Assim, a coisa est a caminho!
Polimorfismo: aprendendo a prever o futuro 145
Workshop
As perguntas e respostas do teste so fornecidas para seu melhor entendimento. Veja as respos-
tas no Apndice A, "Respostas".
Teste
I. Quais so os quatro tipos de polimorfi smo?
2. O que o poli morfismo de incluso permite que voc faa?
3. Como a sobrecarga e o polimorfi smo paramtrico modelam mais naturalmente o mundo
real?
4. Ao programar, por que voc deve programar para uma interface, em vez de para uma im-
plementao?
5. Como o polimorli smo e a sobreposio trabalham j untos?
6. Qual outro nome para sobrecarga?
7. Defi na sobrecarga.
8. Defi na polimorfis mo paramtrico.
9. Quais so as trs armadilhas associadas ao pol imorfi smo?
10. Como o encapsulament o e a herana afetam o polimorfismo de incluso?
Exerccios
I. D um exemplo real de sit uao de programao onde voc acha que poderia usar poli-
morfi smo de incluso. Pode ajudar pensar em algo que voc tenha programado ant erior-
mente, que pudesse ti rar proveito do pol imorfi smo.
2. D um exempl o de converso. Explique por que se trata de converso.
3. Examine as APl s Java. Encontre um exempl o de sobrecarga e explique-o. Em seguida,
encontre uma hierarquia de classes que voc poderia destacar para polimorfi smo de in-
cluso. Identi fiq ue a hierarqui a e explique como voc pode aplicar polimorfismo de in-
cluso nela.
SEMANA 1
DIA
Polimorfismo: hora de escrever
algum cdigo
Ontem, voc aprendeu a respeito do polimorfi smo. Voc deve ter um bom entendi mento dos
quatro diferentes tipos de polimorfismo. Hoje, voc ganhar experincia prtica com o polimor-
fi smo, alravs de vri os exerccios de laboratri o. No final da lio de hoje, voc dever se sentir
vontade com a teoria apresentada no Dia 6, "Polimorfismo: aprendendo a prever o futuro",
Hoje voc aprender:



Como aplicar as diferentes formas de polimorfismo
Como escrever software prova do futuro
Como o polimorfi smo pode ajud- lo a evitar a troca da lgica
laboratrio 1: aplicando polimorfismo
No Dia 5, o Laboratrio 2 apresentou uma hierarquia de funcionri os. A Listagem 7.1 apresenta
uma classe base E111> loyee ligeiramente alterada.
LISTAGEM 7.1 Empl oyee . j ava
publi C abstracl class Employee {
private String f i rst_name ;
private String last _name ;
1 148 Dia 7
LI STAGEM 7. ' Empl oyee. java (continuao)
}
pri va te double wage :
public Empl oyee ( Stri ng first_name. String last_name . double wage ) I
this.first_name = first name;
this . last name z last name;
this.wage wa ge :
}
public double getWage() {
return wage:
}
public String getFirstName() {
return first_name;
}
publ iC Str ing getlastName() {
return last_name :
}
publiC abstract double calculatePay( ) ;
public void printPaycheckO I
}
String full_oame " l ast_name + lO, " + first_name ;
System. out. pr i nt l n( "Pay: M + full _name + " $" + cal cul atePay() ):
A nova classe Empl oyee tem agora um mtodo abstrato ca 1 cul atePay() . Cada subclasse deve de-
fini r sua prpria i mplementao de ca 1 cu 1 atePay (). As listagens 7.2 e 7.3 apresentam duas pos-
sveis subclasses.
LI STAGEM 7.2 Corrmi ss ionedEmp loyee.java
publ i c cl ass CommissionedEmployee extends Employee {
private double
private int
conmi ss i on :
units:
I I o custo por uni dade
II controla o nmero de unidades vendidas
publiC CommissionedEmployee ( String first_name . String last_name .
double wage , double conmission ) {
super ( first_name . l ast_name. wage ):
II chama o const rutor original para inicializar corret amente
Polimorfi smo: hora de escrever algum cdigo
LI STAGEM 7.2 Colt'lt1i ss ionedEmployee.java (continuao)
}
}
}
}
thlS.commissi on = commission;
public double calculatePay() (
return getWage() + (commission * units );
}
pub11C void addSales( int units ) {
th1s.unlts thiS.units + un1ts;
publiC lnt getSales() {
return units;
public void resetSales() {
unit s O;
}
LISTAGEM 7.3 HourlyEmpl oyee.java
public class HourlyEmployee extends Employee (
}
pri vate int hours; II controla o nmero de horas trabalhadas
publiC HourlyEmployee ( String first_name. String last name .
double wage ) {
supere first_name . last_name, wage );
II chama o construtor original para i nicializar corretamente
public double calculatePay() {
return getWage()* hours ;
}
publlc void addHours( int hours ) {
this.hours this.hours + hours;
}
public int getHours() {
return hoursj
149
1 150 Dia7
LI STAGEM 7.3 HourlyEmployee.java (continuao )
I
I
public void resetHours() I
hours = O;
I
Cada subclasse fornece sua prpria implementao de cal cul atePay(). HourlyEmployee sim-
plesmente calcula o pagamento multipl icando as horas lI balhadas pela taxa horria. Um objeto
Conm; ss; onedEmp 1 oyee recebe o salrio-base, mais um bnus por cada unidade vendida. Cada
subclasse tam bem adiciona alguns mtodos prprios. Por exemplo, Hour I yEmp 1 oyee tem um m-
todo para reconfigurar as horas. Do mesmo modo, Conmiss i onedEmployee tem um mtodo para
adicionar vendas.
Conforme voc aprendeu no Dia 4, " Herana: hora de escrever algum cdigo", Conmi ssio-
nedEmployee e HourlyEmployee permitem que as instncias das duas classes compartilhem um
relacionamemo com capacidade de substituio. Voc pode usar uma instncia de Conmi ss io-
nedEmp loyee ou uma instncia de HourlyEmployee, em lugar de Emp l oyee. Entretanto, o que o per
li morfi smo permite fazer?
Considere a classe Payroll, apresentada na Listagem 7.4.
LISTAGEM 7.4 Payr oll. java
public class payroll I
private int
private int
private double
total_hours;
t otal_sales ;
total_pay;
public void payEmployees( Employee (] emps ) I
I
for( int i O; i < emps . length; i ++ ) {
Emp l oyee emp = emps [i];
I
total_pay +z emp.calculatePay{) ;
emp.printPaycheck();
publi c void recordEmployeeln fo( CommissionedEmployee emp ) (
total_sales += emp.getSales() ;
I
publiC void recordEmployeelnfo( Hourly6mployee emp ) I
total _hours +- emp.getHours();
Polimorfismo: hora de escrever algum cdigo 151
LISTAGEM 7.4 Payroll. java (continuao)
}
}
public void pri ntReport() I
}
System.out.pr int ln( "Payroll Report:" ) ;
System.out.println( "Total Hours: " + total _hours ) ;
System.out.println( "Total Sales: " + total_sales ) ;
System.out.print ln( "Total Paid: $" + total_pay );
ALERTA
Mtodos get e set em demasia indicam um mal projeto 00. Em geral, voc
quer solicitar os dados de um objeto muito raramente. Em vez di sso, voc deve
pedir para que um objeto faa algo com seus dados.
No exemplo de funcionrios, ter ia sido uma 00 melhor se passasse para o ob
jeto Emp 1 oyee um objeto Report, onde ele pudesse registrar suas horas. vendas
etc. Embora isso fosse uma 00 melhor, teria se desviado do exemplo.
A 'boa 00' tambm relativa. Se voc esti ver escrevendo objetos genri-
cos que sero usados em mui tas situaes diferentes, talvez queira adicio-
nar mtodos get / set. para que possa manter a interface da classe fci l de
ger enciar.
Considere o mtodo payEmployees( Employee [] emps ). Os relacionamentos com capacidade
de substituio permitem que voc passe qualquer subclasse de Emp I oyee para o mtodo. Geral-
mente, esse mtodo trata objetos HourlyEmpl oyee e CorrmissionedEmployee como simples instn-
cias de Employee.
O polimorfismo o que torna esse exemplo interessante. Quando os mtodos payEmployeesO
dizem
total_pay += emp.calculatePay()
o polimorfismo faz parecer que Employee tenha muitos comportamentos diferentes. Quando
emp.ca I cul atePay() chamado em um objeto que realmente um HourlyEmp loyee, ca I cul ate-
PayO calcula o pagamento, multipl icando a taxa horria pelo nmero de horas trabalhadas. Do
mesmo modo, quando a instncia subjacente um objeto Conmiss i onedEmployee . calcul ate-
pay() retorna o salrio mais todos os bnus de vendas.
payEmployeesO um exemplo de polimorfismo de incll/so. Esse mtodo funciona para qual-
quer funcionrio. O mtodo no precisa de cdigo especial, voc no precisar alual iz-Io cada
vez que adicionar uma nova subclasse em seu sistema - ele si mplesmente funciona para todos
os objetos Emp I oyee.
Dia 7
Mtodos como
recordEmployeelnfo( CommlsslonedEmpl oyee emp )
e
recordEmployeelnfo( Hour1 yEmployee emp )
demonstram a sobrecarga. A .wbrecarga permite que um mtodo parea ser polimrfico. Por
exemplo, ela permite o seguinte:
Payroll payroll new Payrol1() ;
Commi ssionedEmployee empl = new Corrmi ssionedEmployee( "Mr. ". "Sales ".
25000.00 , 1000.00);
Hou r1 yEmp1oyee emp2 new HourlyEmployee( "Mr." , "Minimum Wage" , 6.50 ) ;
payroll.recordEmp loyeelnfo( emp2 ) ;
payroll . recordEmp10yeelnfo( emp l ) j
recordEmp 1 oyee I n fo () parece ser pai imrfico. pois pode manipular os dois tipos de funcionrio.
A sobrecarga um pouco mais limitada que o polimorfismo de incluso. Com o polimorfismo de
incl uso, voc viu que precisava apenas de um mtodo, payEmpl oyees(), para calcular o paga-
mento de qualquer objeto Emp 1 oyee. I ndependentemente de quantas subclasses de Emp 1 oyee voc
introduza, o mtodo sempre funcionar. Esse o poder do pol imorfi smo de incl uso.
Os mtodos que empregam sobrecarga no so to robustos assim. Pegue como exemplo o m-
todo recordEmp loyeelnfo(). Sempre que voc adicionar uma nova subclasse na hierarquia
Empl oyee, ter de adicionar um novo mtodo recordEmp1oyeelnfo() para o novo tipo. Embora
alguns mtodos extras possam ser aceitvei s para uma hierarquia pequena, talvez voc tenha de
refazer sua hierarquia, para que possa escrever um mtodo recordEmpl oyee lnfo() genrico,
quando o nmero de subclasses de Employee aumentar.
A Listagem 7.5 fornece um pequeno mtodo principal que executa os mtodos Payroll.
LISTAGEM 7.5 Payro 11 Dri ver . java
publi C cl ass PayrollDri ver (
publi c static vOl d maln( String [J args ) (
II cr ia o sistema de fo lha de pagamento
Payroll payrol1 = new Payrol l () ;
II cria e atuallza alguns funcionrios
COIlI1lissionedEmp1oyee emp l - new Corrmi ssionedEmployee( "Mr.", "Sal es ",
25000.00 , 1000. 00),
CommissionedEmpl oyee emp2 new COIl1ll i ssionedEmp1oyee( "Hs." , "Sales - ,
25000. 00, 1000.00),
empl . addSales( 7 );
emp2. addSales( 5 );
Polimo rfi s mo: hora de escrever algum cdi go 153
LISTAGEM 7.5 Payro110river . java (continuao)
I
I
HourlyEmployee emp3 .. new Hour l yEmployee( "Hr . ", "Hinimum Wage" , 6.50 ) ;
HourlyEmployee emp4 .. new Hour l yEmployee( "Hs." , "Hini mum Wage" , 6.50 );
emp3 . addHours( 40 ) ;
emp4.addHours( 46 );
II usa os mtodos sObr eca rregados
payroll.recordEmployeeI nfo( emp2 ) ;
payroll.recordEmployeel nfo( emp l ) ;
payroll.recordEmployeel nfo( emp3 ) ;
payroll.recordEmployeel nfo{ emp4 );
II coloca os em um array
Empl oyee [] emps new Empl oyee [4];
emps[O] .. empl; emps [l] " emp2 ; emps [2] = emp3 ; emps[3] .. emp4;
payroll. payEmployees ( emps ) i
payroll.printReport() j
A Figura 7. 1 mostra a sada do mtodo pri ncipal.
FIGURA 7.1
A Si/ida correia de
Payro 11 Ori ver.
Se voc percorrer o cdigo e calcular manual mente o pagamento de cada funci onrio, ver que
payEmp 1 oyees () paga o valor correiO. Do mesmo modo, todas as infonnaes de funcionrio so
correlamente gravadas.
Dia 7
Exposio do problema
No Dia 5, voc trabalhou com obj etos MoodyObject. A Lis tagem 7.6 apresenta uma classe
HoodyObject ligeiramente modificada.
LISTAGEM 7.6 MoodyObject . java
publiC abstract class MoodyObject (
I
II retorna o humor
protected abstract String getMood() ;
II pergunta ao objeto como ele se sente
publ ic void queryMood() (
System.out.println( " I feel " + getMood() + " today!!") :
I
As listagens 7.7 e 7.8 apresentam duas subclasses: HappyObject e SadObject.
LI STAGEM 7.7 HappyObject . java
public class HappyObject extends MoodyObject (
I
Il redefine o humor da classe
protected String getMood() I
return "happy;
I
Ilespecializao
public void laugh() {
Sys tem. ou t. pri nt l n (" hehehe. .. hahaha. .. HAHAHAHAHAHA!!!!!") ;
I
LI STAGEM 7.8 SadObject.java
publiC cl ass SadObject extends MoodyObject {
II redefine o humo r da classe
protected Stri ng getMood() {
return "sad":
I
II especializao
Polimorfi smo: hora de escrever algum cdigo 155
LI STAGEM 7.8 SadObject.java (conti nuao)
publiC vold cry{) (
Sys t em.out.println("'wah' ' boo hoo ' 'weep' ' sob ' ' weep'");
J
J
Sua tarefa prati car o pol imorfismo. Escreva uma classe Psychiatri stObject. Psychia-
t ri s tObj ect deve ter trs mtodos. exami ne () deve pegar qualquer instncia de MoodyObject e
perguntar como ela se sente. Psychi atri stObject tambm deve ter um mtodo observe() sobre-
carregado. observe{) deve chamar os mtodos cry() ou laughO do objelo. A classe Psychia-
lristObjecl deve tecer um comentrio mdico para cada comportament o.
Certi fi que-se de usar a classe PsychiatristDriver fornecida, para testar sua soluo!
A prxima seo discutir as solues do Laboratri o 1. No prossiga at con-
cluir o Laboratrio 1.
Solues e discusso
A Li stagem 7.9 apresenta uma passivei classe PsychiatristObject.
LISTAGEM 7.9 Psychiatr i stObject. java
public class PsychiatristObject {
II usa polimorfismo de incluso para examinar todos os objetos humor
II genericamente
pu bl ic voi d examine(MoodyObject obj ) {
J
Sys tem. out . prlnt ln( "Te11 me, object , how do you feel t oday?" )i
obj . queryMood () ;
System. out.print ln() ;
II usa sobrecarga para observar objetos especificamente.
II mas com um mtodo chamado generi camente
publ ic voi d observe( SadObject obj ) (
J
obj.cry() j
Sys t em. out.print ln(
"Hnm . .. very . ve ry interest i ng. Some thi ng makes thi s object sad." );
System. out . println()j
1 156 Dia7
LI STAGEM 7 .9 Psychi atri stObject.j ava (continuao)
J
publiC void observe{ HappyObject obj ) (
obj . laugh();
J
Sys tem.out.println(
MHmm .. very . very i nteresti ng. This object seems ve ry h a p p y ~ );
System.out .print ln() ;
examine como ( MoodyObjec t obj ) trata todos os obj etos MoodyObject genericamente. O objeto
PsychiatristObject pergunt a ao objeto MoodyObject como ele se sente e chama seu mtodo
queryMood O. O objeto Psychi atri stObject precisa de um mtodo observe O para cada lipo de
objcto MoodyObject que gostaria de observar.
Aps concluir este laboratrio, voc dever comear a se sentir vontade com os mecani smos
bsicos do polimorfi smo.
laboratrio 2: conta de banco aplicando
polimorfismo em um exemplo conhecido
No Laboratrio 2, voc vai pegar o que aprendeu no Laboratri o 1 e aplicar em um problema li
geiramente mais compl icado. Este laboratrio focaliza a hierarquia BankAccount, apresentada no
Dia 5. A hierarquia apresentada aqui conti nua quase igual quela apresentada no Dia 5. A nica
diferena que agora BankAccount uma classe abstrata. Voc no pode mais instanciar um ob-
jeto BankAccount diretament e.
Tornar BankAccount abstrata modela mai s precisamente o funcionamento de contas bancri-
as. Quando voc abre urna conta, abre uma conta de cheque ou urna cont a de mercado finan-
ceiro. Voc no abre uma conta de banco genrica. A Li stagem 7.10 li sta a ni ca mudana na
hierarquia.
llSTAGEM 7 . 10 BankAccount.java
publi c abst ract cl ass Ba nkAccount {
II o restante igual
J
Polimorfismo: hora de escrever algum cdigo 157
Exposio do problema
Neste labormrio, voc precisa escrever uma classe 8ank. A classe Sank tem vri os mtodos.
As instncias de 8ank contm contas. Entretanto, voc precisa de uma maneira de controlar a
quem penencem as contas. addAccount() permite especificar um propri etrio, sempre que voc
adiciona uma nova conta:
publlc YOld addAccount( Str ing name, BankAccount account );
Voc pode usar o nome do propri etrio para acessar a conta correta posteriormente.
totalHol dingsO permite que a classe Bank relate a quantidade total de dinheiro existente no
banco:
publ ic doubl e totalHoldings() ;
totalHoldingsO deve fazer um lao por todas as contas e totalizar o valor mantido no banco.
total Accounts () permite que voc consulte a instncia de Bank para ver quantas contas ela pos-
sui correntemente:
publiC int totalAccounts();
deposi tO permite que voc deposite fundos em uma conta bancria especifica:
public yoid deposite Stri ng name, double amount );
depos i tO um mtodo de convenincia que o li bera de ter de recuperar uma conta especfica,
anlesde poder adicionar rundos ne la. Em vez disso, depos i t () pcnnite que voc deposite fundos
diretamente atravs do banco.
balanceO permite que voc recupere o saldo de uma conta especifica:
public double balance( Stri ng name )
Assim como depos i t 0 , ba 1 ance() um mtodo de convenincia.
addAccountO armazena uma conta sob determinado nome. Existem vrias maneiras
de implementar essa funcionalidade. Entretanto, algumas estratgias so mais fceis
de implementar do que outras.
Para este l aboratrio, voc dever considerar jaya. ut i I . Hashtab I e. Hashtab I e permite
que voc armazene e recupere pares chave/Valor.
Considere esta APl consolidada:
pub1 ic Object get( Object key );
publ ic Object put ( Object key, Object ya1ue );
public lnt size();
publlc Java . util.Enumeration elementos();
Aqui est um exemplo de Hashtable:
Dia 7
java. ut 11 . Hashtab le tab I e new java. util . Hashtab I e();
table.put( -LANGUAGE-, "JAVA" );
String name table.get( -LAHGUAGE" ) ;
Esse exemplo armazena ovalar JAVA sob a chave LANGUAGE. Para recuperara valor pos-
t eri ormente, voc simplesmente chama get() e passa a chave correta.
Estudando a APl, voc notar que os mtodos get () e put () retornam Objecto Assim, se
voc fosse armazenar uma Stri ng, obteria o valor de volta como um Objecto
Na linguagem Java, todos os objetos herdam de Objecto A Hashtable foi escrita
para tratar com Object, de modo que funcionar para todos os objet os Java. Entre-
tanto, e se voc armazenar um objeto CheckingAccount na Hashtable e quiser tra-
t-Ia como um objelo Checki ngAccount, aps recuper-l o? Como voc fari a isso na
linguagem Java?
A linguagem Java fornece um modo de transformar uma referncia de Object de volta
para seu tipo correto. O mecanismo conhecido como converso. A instruo a seguir
invlida na linguagem Java:
CheckingAccount account table.get( "CHECKING ACCOUNT" );
Em vez disso, voc precisar realizar uma converso, antes de poder armazenar uma
referncia de Object em uma varivel CheckingAccount:
CheckingAccount account " (CheckingAccount) table.get( "CHECKlNG ACCOUNT");
Voc precisa tomar cuidado enquanto converte. A converso pode ser perigosa. Por
exemplo, a converso a seguir invlida:
HappyObject o new HappyObject() ;
lable.put( "HAPPY-, o );
(CheckingAccount) table.gel( "HAPPY- );
Quando voc converte, deve certificar-se de que o Objecl que est convert endo seja re-
almente do tipo TYPE . Assim, para este laboratrio, quando voc recuperar um objeto
BankAccount da Hashtable, desejar converter para BankAccount. Como exemplo, consi-
dere a converslio a seguir:
BankAccount b (BankAccount) table.get( "ACCOUNTl" };
Se voc tentar realizar uma converso invlida na linguagem Java, ela lanar uma ex-
ceo ClassCastE)(ception.
Assim como o Laboratri o I, o Laboratrio 2 fornece um driver para ajud-l o a testar sua solu-
o. Certifique-se de consultar BankDriver.
A prxima seo discutir as solues do laboratrio 2. No prossiga at con-
cluir o Laboratrio 2.
Polimorfismo: hora de escrever algum cdigo
Solues e discusso
A Li stagem 7. 11 apresenta lima possvel implementao de Bank.
LI STAGEM 7.11 Bank.java
publlc cl ass Bank (
}
private java.utll .Hashtable accounts = new java.util.Hashtable();
public void addAccount( String name, BankAccount account ) (
accounts .put( name, account ) ;
}
publi C double totaIHoldings() (
double total - 0.0;
}
java.ut il . Enumeration enum = accounts . elements();
while( enum.hasMoreElements() ) (
}
BankAccount account (BankAccount) enum.nextElement();
total +- account .getBalance() ;
return to ta 1 ;
public int totalAccounts() (
return accounts.size();
}
publiC voi d deposite Str ing name , double amount l (
BankAccount account - retrieveAccount( name l;
if( account !a null ) {
account.depositFunds( amount l;
}
}
public double balancei String name ) {
}
BankAccount aCCQunt * retrieveAccount( name );
if( accQunt ! - null ) {
return account.getBalance()i
}
return 0.0;
private BankAccount retrieveAccount( String name ) {
return (BankAccount) accounts. get{ name l i
}
159
Dia 7
I nternamente, essa soluo usa java. ut 11 . Hashtab 1 e para conter todos os objetos BankAccount.
Em vez de forne<::er seu prprio meanismo de annazenamento e recuperao, essa implement a-
o ti ra proveito da reutilizao, utili zando as classes fornecidas pela linguagem Java.
ba 1 ance (), depos i t (), addAccount () e t o ta 1 Ho 1 di ngs (). todos demonstram o pol imorfismo de in-
cl uso. Esses mtodos funcionaro para qualquer subclasse de BankAccount que voc possa criar.
A ps concl uir este laboratri o, voc dever ter uma idia melhor dos mecanismos de pol imorlis-
mo. No Dia 5, os objetos BankAccount mostraram a convenincia da herana. A herana permitiu
que voc cri asse subclasses rapidamente, programando apenas o que era diferente ent re as con-
tas. O polimorfi smo simplifica ainda mais seu cdigo, fornecendo um mecanismo para progra-
mao genrica.
laboratrio 3: conta de banco usando
polimorfismo para escrever cdigo prova
do futuro
Por toda a discusso sobre pol imorfis mo, voc ouvi u o tenno software prova do futuro. O que
exatament e soft ware prova do futuro? Software prova do futuro simplesment e um software
que se adapta faci lmente mudana nos requisitos.
Os requisitos mudam o tempo todo. Quando voc comea a escrever um programa pela pri mei ra
vez, os requisitos podem mudar, enquanto voc aprende mais a respeito do problema que est re-
solvendo. Uma vez escri to, seus usurios esperaro e exigiro novos recursos de seu software.
Se voc criar soft ware prova do fut uro, no ter de reescrev-lo completamente, cada vez que
obt iver um novo requisi to.
Vamos considerar um exemplo de mudana de requisitos. A Listagem 7. 12 apresenta urna nova
classe MoodyObj ect : CarefreeObj ect.
LISTAGEM 7.12 CarefreeObject.java
pub1ic class CarefreeObject extends MoodyObject {
II redefine o humor da classe
}
protected Stri ng getMood() {
ret urn "carefree
M
j
}
II especial izao
pub1ic void whist le{) I
Sys t em. out. print l n{"whi st1e, whist 1e, whistle ... );
}
Polimorfismo: hora de escrever algum cdigo
A Li stagem 7. 13 most ra o Psychiatri stOriver atualizado.
LI STAGEM 7.13 PsychiatristDriver.java
public class PsychiatristOriver I
}
public static void main( Str ing [] args ) I
HappyObject happy new HappyObject():
}
SadObject sad = new SadObject( ) ;
CarefreeObject carefree new CarefreeObject();
PsychlatristObject psychiatrist z new PsychiatristObject();
II usa polimorfi smo de incluso
psychiatrist . examlne( happy ):
psychiatrist.examine( sad ) :
psychiatrist.examine ( carefree ) ;
II usa sobrecarga para que possamos observar os objetos
psychiatrist.observe( happy );
psychiatrist.observe( sad );
A Figura 7.2 mostra a saida que voc vera ao executar PsychiatristOriver.
FIGURA 7.2
A sada correia de
Psychiatri s tOri ver.
161
Dia 7
Aqui , voc v que Psychiatr;stObject prova do ful uro. A qualquer momento, voc pode
adi cionar novos objetos MoodyObject, todos com seu prprio comportamento personalizado.
PsychiatrlstObject pode simplesmente usar os novos subti pos.
Voc pode observar que esse exemplo se concentra no mtodo examineO. O
polimorfi smo de incluso possibilita um software realmente prova do futuro.
Entretanto, se Psychi atri s t Object quiser usar observe () em um novo subtipo,
voc precisar atualizar Psychiatri stObj ect tambm.
MoodyObjec t um exemplo simples. Entretanto, tente imaginar corn o voc poderi a estender essa
idia para programas mais complexos!
Exposio do problema
Sua tarefa testemunhar a programao prova do fut uro em primeira mo. No ltimo laborat-
ri o, voc escreveu uma classe Bank. A classe Bank pode trabalhar com qualquer subtipo de
BankAccount. Sua tarefa criar um novo tipo de BankAccount: a Rewa rdsAcount .
Assim como em Savi ngsAccount , a RewardsAccount aplica j uros no saldo. Entretanto, para aumentar
o nmero e o tamanho dos depsitos, o banco gostaria de introduzi r um sistema de recompensas.
A RewardsAccount cont rola o nmero de depsitos em relao a certa quantidade de dlares: o
nvel de depsito para recompensa. Por exemplo, digamos que o nvel de depsito para recom-
pensa seja de US$SOO dlares. Sempre que o depositante deposita US$SOO ou mais, ele receber
um poruo de recompensa.
NeTA
Mantenha RewardsAccount simples. Se o nvel de depsito para recompensa for
de US$500 e o depositante depositar US$500, ele receber um ponto de re-
compensa. Se o depositante depositar US$3.000, ele ainda dever receber
apenas um ponto de recompensa.
Junto com os mtodos definidos por BankAccount, RewardsAccoun t tambm deve fornecer
um mecanismo para recuperar e recon fi gurar o numero de pontos de recompensa recebidos.
RewardsAccount tambm precisa de um modo para configurar e obter o nvel de depsito
para recompensa.
Para este laboratrio, talvez voc queira vol tar ao Dia 5 e reler as descries dc Sav i ngsAccount e
BankAccount . Este laboratrio tambm inclui u
m RewardsAccountor i ver e um BankOri ver atualizados. Cert ifique- se de us-Ios para testar sua s0-
luo. Voc tambm desejar ver BankOriver. O BankOri ver demonstra como voc pode adicionar
um novo tipo de obj elo em seu programa, sem ter de at uali zar qualquer um dos outros objetos.
Polimorfismo: hora de escrever algum cdigo 163
ALERTA
A prxima seo discutir as solues do laboratrio 3. No prossiga at con-
cluir o laboratri o 3.
Solues e discusso
A Li stagem 7. 14 apresenta uma possvel sol uo para RewardsAccount.
LISTAGEM 7.14 RewardsAccount. java
publi c class Rewa rdsAccount extends SavingsAccount {
private double min_reward_balance:
I
private int quallfying_deposits:
public RewardsAccount( double initDeposit. double interest. double min ) {
super( i nitDeposit. interest ) :
min_reward_balance min:
I
publ ic voi d depositFunds ( doubl e amount ) {
super.deposit Funds( amount ):
I
if( amount >- min_reward_balance )1
qualifying_deposits++:
}
publi c int getRewardsEarnedO I
return qualifying_deposits:
I
publi c voi d resetRewards() {
qual i fying_deposi t s O:
I
publ i c doubl e getMi nimumRewardBal ance O {
ret urn min_reward_balance :
I
publi c voi d setMinimumRewardBalance( double min ) {
min reward bal ance : mi n;
-
I
RewardsAccount sobrepe depos i tFunds O. de modo que pode verificar o saldo e os pont os de re-
compensa. A classe tambm adiciona mtodos para recuperar o saldo das recompensas, reconfi -
gurar o saldo, assi m como obter e configurar o nvel de depsi to para recompensa.
Dia 7
A Listagem 7. 15 apresenta o BankOriver atualizado.
LI STAGEM 7.15 BankOri ver .java
public class 8ankOriver {
I
publlc s t atic void main( String [] args ) {
CheckingAccount ca new CheckingAccount( 5000.00, 5, 2.50 );
OverdraftAccount oa new OverdraftAccount( 10000.00, 0. 18 ):
SavingsAccount sa new SavingsAccount( 500.00. 0. 02 ):
TimedMaturityAccount tma K new TimedMaturityAccount(
10000 . 00, 0.06. 0.05 ):
Bank ba nk new Bank( )j
bank.addAccount( "CHECKING", ca ):
bank.addAccount( "OVERORAFT", oa );
bank.addAccount( "SAVINGS" , sa };
bank. addAccount ( "TMA" , tma );
Sys tem.out.println( "Total holdings(shou ld be $25500.0): $" +
bank.totalHoldings() )i
System.out.println( "Total accounts(should be 4): " +
Bank.totalAccountsO ) ;
RewardsAccount ra new RewardsAccount( 5000. 00, .05, 500.00 };
bank.addAccount( "REWAROS", ra };
System.out.print ln( "Total holdings(should be $30500 . 0): $" +
bank.totalHoldings() ) ;
System. out.println( "Total accounts(should be 5): " +
bank. to ta l Accounts () };
bank.depos1t( "CHECKING", 250 . 00 };
double new_balance bank . balance( "CHECKING " };
Sys t em. out.pr intln( "CHECKING new balance (should be 5250. 0): $" +
new balance ):
I
Para usar a nova classe de conta existem dois passos que voc deve dar.
Para o primeiro passo, voc deve criar seu novo subti po. Aps criar seu novo subti po, voc pre-
cisa aherar seu programa para criar novas instncias do objeto.
No caso de RewardsAccoun t , voc deve atual izar o mtodo mai n () de BankAccount, para cri ar ins-
tncias de RewardsAccount. Ent retamo, voc no precisa mudar mais nada!
Polimorfismo: hora de escrever algum cdigo 165
Quando voc est iver escrevendo um programa real, percorrer os mesmos passos para introduzir
novos subtipos em seu programa. Primeiro, voc precisar cri ar o novo subtipo.
Segundo, voc preci sar al terar seu cdigo para que ele possa criar seu novo subtipo. Mas, isso.
Voc no preci sa alterar o restante de seu programa.
Posterionnente, voc ver maneiras de tomar seus programas to flexvei s, que poder nem preci-
sar alterar qualquer cdigo de seu programa para que ele encontre e comece a usar novos subtipos.
laboratrio 4: estudo de caso estruturas
condicionais Java e polimorfismo
A linguagem Java, assi m como muitas outras, fornece um mecanismo de troca. Considere o m-
todo day of the week() a seguir:
- - -
public void day_of_the_week(int day ) {
switch ( day ) (
I
I
case 1:
System.out.pr intln ( "Sunday );
break;
case 2:
System.out.println( "Monday ) ;
break;
case 3:
System.out.println ( "Tuesday l;
break;
case 4:
System.out.println( "Wednesday" );
break;
case 5:
System.out.println( "Thursday" );
break;
case 6:
Sys t em.out.println( "Friday" l;
break;
case 7:
System.out.print ln{ "Saturday" )i
break;
default:
System.out.pr i ntln{ day + " is not a valid day. );
break;
Dia 7
o mtodo recebe um parmetro: um valor inteiro representando o dia da semana. Ent o, o mto-
do testa todos os dias vlidos da semana. Se o argumento day corresponder a um dos dias, o m-
todo imprimir o nome do dia.
Geralmente fa lando, voc usa estnlluras condicionais (case ou i r te 1 se) para realizar lgica con-
dicionaI. Com a lgica condicional, voc procura certa condio nos dados. Se essa condio for
satisfeita, voc faz algo. Se outra condio for satisfeita, voc faz algo inteiramente diferente. To-
dos osque tm base procedural devem estar familiarizados com tal estratgia de programao.
Se voc se sente vontade com estruturas condicionais, hora de desaprender um pouco. A lgi-
ca condicional geralmente considerada uma m prtica de 00. Na verdade ela to m, que
muitas linguagens 00 no fornecem tais estruturas. A lgica condicional tem uma vantagem;
ela o ajuda a detectar um projeto mal feito!
As estruturas cond icionais so quase sempre ms por natureza. Entretant o, elas frcqcnte-
mente se insinuam sua frente, pois aparecem em muitas formas. Considere um mtodo
day_of_t he_weekO li gei ramente diferente.
public void day_of_the_week( int day )
I
iflday"')!
System.out.println( "Sunday" );
} el se ir ( day == 2 ) I
System.out.println{ "Monday" };
} else if ( day 3 ) {
Sys tem.out.print ln( "Tuesday };
} else if ( day 4 ) I
System.out.println{ "Wednesday" );
} else ir ( day 5 ) I
System.out.print ln( "Thursday );
} else if ( day 6 ) I
System.out. println( "Fri day" };
} else ir ( day =- 7 ) I
System. out.print ln ( "Saturday" ) ;
} else {
System.out.printl n( day + " is not a valid day." };
I
Ento, o que h de errado com as estruturas condicionais?
As estrulUras condicionais so contrrias aos concei tos de 00. Na 00, voc no soli cita os da-
dos de um objeto e depois faz algo com esses dados. Em vez disso, voc sol icita para que um ob-
jeto faa algo com seus dados. No caso do metodo day_of_the_weekO, voc provavelmente
obtem day de algum objeto. Voc no deve estar processando dados brutos. Em vez disso, voc
deve solicitar ao obj eto uma representao de string. As estruturas condicionais o obrigam a mistu-
rar responsabilidades. Cada lugar que usa os dados ter de aplicar a mesma lgica condicional.
Polimorfi smo: hora de escrever algum cdi go 167
Existem ocasies em que as condicionais so absolutamente necessri as. Ent o, como voc de-
tecla ' ms' estrut uras condicionais?
Existem meios de saber quando uma estrutura condicional ' boa' fi ca 'ruim'. Se voc se encon-
trar atual izando uma estrut ura case ou blocos 1 fi el se, sempre que adicionar um novo subtipo,
as chances so de que a estrutura condicional ' ruim'. No apenas isso uma m prtica de 00,
como tambm um pesadelo de manuteno. Voc ter que certificar-se deatualizar cada condi -
cionai que teste os dados. Exigir mui to tempo para garantir que voc no se esqueceu de atuali-
zar algo!
Corrigindo uma estrutura condicional
Considere O mtodo a seguir:
publi c i nt ca l cul ate( Stri ng operao. int operand l. int operand2 ) {
if ( operation.equals( "+" ) ) (
J
return operandl + operand 2;
) el se if ( operat1on. equals ( "*" ) ) {
return operandl *operand2;
} el se i f ( operat i on.equals( ~ M ) ) {
return operandl loperand2;
J el se if ( operatlon. equals( "." ) ) I
return operand l - operand2;
) else (
J
Sys t em.out.print ln( "invalid oper at ion: + operat ion ) ;
return O;
Tal mtodo poderia aparecer em um problema de calculadora. O mtodo calcul ateO recebe a
operao, assim como os dois operandos, como argumentos. Ento, ele efetua o clcul o sol icitado.
Sendo assim, como voc poderia corri gir o problema? Voc pode corrigi-lo com objetos, claro!
Quando voc comear a eliminar lgica condicional , comece com os dados que est testando.
Transforme os dados em um objeto.
Neste caso, voc deve criar objetos adio, subtrao, mult'i plicao e di vi so. Todos esses obje-
tos so operaes. Assim, todos eles devem herdar de uma classe base comum. Conforme voc
j viu por todo este dia, a capacidade de substi tuio e o pol imorfi smo permitiro que voc faa
algumas coisas inteligentes com esses objetos.
Todos os objetos que voc deve criar so operaes; portanto, voc sabe que precisa de uma classe
base Operati on. Mas o que uma classe Operation faz? Uma classe Ope rat ion calcula algum valor,
dados dois operandos. A Listagem 7. 16 apresenta uma classe Operation.
1 168 Dia7
LI STAGEM 7.16 Operation.java
publ i c abstract class Operation (
pllblic abstract int cal clll ate ( int operand l. i nt operand2 ):
,
As listagens 7.17, 7. 18, 7.19 e 7.20 apresentam os vri os objetos operao.
LI STAGEM 7.17 Add.java
plIbl i c class Add extends Operati on {
,
publi c int cal clllat e( int operandl . int operand2 ) I
retllrn operandl + operand2:
,
LI STAGEM 7.18 Subt ract.java
publi C cl ass SlI btrac t extends Operation I
,
publ ic i nt calcul ate ( int operandI. i nt operand2 ) I
return operandl - operand2 :
,
LISTAGEM 7.19 Mult i ply. j ava
public class Mu l t lply extends Operati on (
,
public int calculat e( int operandl. int operand2 ) {
return operandl * operand2;
,
LISTAGEM 7.20 Oivide . java
publ ic cl ass Divide extends Operation (
,
publ ic int calcul ate ( i nt operand I. int operand2 ) {
return operandl I oper and2;
,
Cada operao implementa o mtodo ca 1 cul ateO de sua prpria maneira. Agora que voc tem
um objelo para cada operao, pode reescrever o mtodo cal culate() original.
Polimorfismo: hora de escrever algum cdigo
public int cal culate( Operation operation, int operandI, int operand2 ) (
return operat i on.ca l culate( operandl , operand2 );
I
169
Transfonnando a operao em um objeto. voc ganhou muita flexi bilidade. No passado, voc
leria de at ualizaro mtodo sempre que quisesse adicionar uma nova operao. Agora, voc pode
simplesmente criar a nova operao e pass- Ia para o mtodo. Voc no precisa alterar o mtodo
de maneira alguma, para que ele funcione com a nova operao-ele simplesmente func iona.
Exposio do problema
A linguagem Java fornece um operador chamado instanceof. O operador instanceof permite
que voc verifique o tipo subjacente de lima referncia.
String s "somestring"
Object obj = S;
System.out.println( (obj ins tanceof String) ),
Esse segmento de cdigo imprime true. obj contem uma instncia de String. A maioria das lin-
guagens de roo fornece um mecanismo semelhante.
Agora, considere a nova classe Payro 11, na Listagem 7.21.
LI STAGEM 7.21 Payroll.java
public class Payrol1 (
pr; vate i nt
pri vate ; nt
private double
total _hours,
total_sales;
total_pay;
public void payEmployees( Employee [J emps ) (
I
for ( int i - O, i < emps.length; ; ++ ) (
Emp l oyee emp z emps[i];
I
total_pay +- emp.calculatePay();
emp.printPaycheck();
publiC void calculate80nus( Employee
for( int i .. O; i < emps.length,
Employee emp emps[i] ;
[] emps I I
) I
i++
if( emp instanceof HourlyEmpl oyee ) (
System.out. print ln(" Pay bonus to .. + emp. getlastNameO +
", " + emp.getFirstNameO + " SIOO.OO." );
I else if ( emp instanceof CommissionedEmpl oyee ) {
i nt bonus - ( (Commi ssionedEmployee) emp ).getSales() 100;
1 170 Dia7
LI STAGEM 7.21 Payroll.java (continuao)
}
}
}
bonus to + emp. getLastName() +
emp.get FirstNameO + $" + bonus ):
I else (
System,ouLprintln( "unknown employee type
M
):
}
public vo1d recordEmployeelnfo( CommissionedEmpl oyee emp ) (
total _s ales +- emp.getSales() :
}
publi C vo1d recordEmployeelnfo( HourlyEmployee emp ) (
total_hours +- emp.getHour s() :
}
publ ic void pr1ntReport() (
System.out.println( "Payroll Report:" ) :
}
System.out.pri ntln( -Total Hours: " + tota l_hours ):
System. out.println( MTotal Sales: " + total _sales );
System.out.print ln( MTotal Paid: $" + total_pay ):
" +

Essa classe Payroll tem um mtodo ca l cul ateBonus (). Esse mtodo recebe um array de objetos
Empl oyee, descobre qual o tipo de cada um e calcula um bnus. Os objetos HourlyEmp loyee re-
cebem um bnus fixo de US$ IOO, enquanto os objetos COIl'Illi ss i onedEmpl oyee recebem USS IOO
por cada venda.
Sua tarefa eliminar a lgica cond icional encontrada em cal culateBonus(). Comece atacando
os dados que o mtodo est testando. Neste caso, ele est testando em um objeto. Ento, o que
est errado?
Em vez de soli citar o bnus ao objeto, o mtodo soli cita a ele alguns dados e, em seguida, calcula
um bnus, usando esses dados. Em vez disso, o mtodo deve solicitar os dados ao objeto.
Voc pode fazer downl oad do cdigo-fonte das classes Payroll, Empl oyee, HourlyEmployee e
Commiss i onedEmp l oyee. Tambm existe um Payroll Dri ver fomecido, para que voc possa testar
facilmente sua soluo.
A prxima seo di scutir as solues do Laboratrio 4. No prossiga at con-
cluir o Laborat ri o 4.
Polimorfismo: hora de escrever algum cdigo 171
Solues e discusso
Para resolver esse problema, voc deve adicionar um mtodo cal culateBonus () diretamente em
cada objeto Employee. Isso poderia parecer como se voc estivesse cai ndo na armadilha I do Dia
6. Entretanto, est correto mover o mtodo para a classe base, pois todas as subclasses sabem
como calcular seu bnus. Na verdade, isso j deveria estar na classe h muito tempo.
As listagens 7.22, 7.23 e 7.24 apresentam as alteraes exigidas.
LISTAGEM 7.22 Employee.java
publiC abstract class Employee (
publi c abstract double calculateBonus() ;
II reduz ido por brevi dade. o restante diz o mesmo
J
LI STAGEM 7.23 Hour l yEmployee .java
publi c class HourlyEmployee extends Employee {
publ ic double calcul ateBonus() {
return 100 . 00 ;
J
II reduzido por brevidade. o restante diz o mesmo
J
LISTAGEM 7.24 CornnissionedEmployee.java
public class CommissionedEmployee extends Employee {
publi c double calculateBonus() {
return 100.00 * getSales() ;
J
II r eduzido por brevidade . o restante diz o mesmo
J
Com essas alteraes, voc pode at uali zar a classe Payroll, como a Listagem 7.25 demonstra.
LI STAGEM 7.25 Payroll.java
publi c class Payroll {
public void calculat eBonus( Empl oyee [) emps ) {
for( int i z O; i < emps.length; i ++ ) (
Employee emp emps [i] ;
System. out.println("Pay bonus to " + emp.getlastName() + M, " +
emp. getFirstName() + " S" + emp.cal culat eBonus()
1 172 Dia7
LISTAGEM 7.25 Payroll.java (cont inuao)
) ;
)
)
II reduzido por brevi dade . o rest ante diz o mesmo
)
Vamos! Acabou-se a lgica condicional irritant e!
DICA
DICA
Resumo
Dicas sobre estruturas condicionais:
Evite o use de estrut uras condicionais case ou j f/else.
- Considere os blocos if/else grandes com celi ci smo.
- Cuidado com alteraes em cascata. Se uma alterao exige mui tas mu-
danas condicionais, tal vez voc tenha um problema.
lnstanceof um si nal de perigo muito grande.
H/ehe, case e instanceof so Nculpados at prova em contrrio
N

Di cas para a eliminao de estruturas condici onai s:

Transforme os dados em objetos.
Se os dados j so um obj eto, adicione um mtodo no objeto.
Evite verificaes de instanceof; use pOlimorfismo em vez di sso.
Hoje, voc completou quat ro laboratrios. O Laboratri o I lhe deu a chance de experimentar al-
guns dos mecanismos bsicos do poli morfismo. O Laboratri o 2 permi ti u aplicar o que voc
aprendeu no Laboratrio I, em um exemplo mais complicado. O Laboratrio 3 deve ter final-
mente respondido a pergunta, ;'0 que exatamente software prova do futuro?". O Laboratri o 3 re-
sume o motivo pelo qual voc desejari a usar polimorfismo. Finalmente, o Laboratrio 4 forneceu
algo para tomar cuidado enquant o estiver programando. El e tambm mostrou como o polimor-
fi smo pode ser til, quando utilizado corretamente.
Juntos, todos esses laboratri os reforam as lies sobre polimorfismo. Eles fornecem o que voc
precisa saber para tirar vantagem do conceito corretamente. Esperamos que, aps concluir esses
laboratri os, voc veja seus programas do ponto de vista do polimorfismo. A verdadeira progra-
mao 00 exige uma maneira diferente de pensar a respeito do software. As vantagens da 00 sur-
gem realmente, quando voc pode pensar de forma polimrfica.
Pol imorfi smo: hora de escrever algum cdigo 173
Perguntas e respostas
P. Parece que o polimorfismo de incluso mais conveniente do que a sobrecarga, pois
cu s preciso escr ever um mtodo e fazer com que ele funcione com muitos tipos di-
ferentes. I'or que eu usaria sobrecarga em vez disso?
R. Existem ocasies em que a sobrecarga uma escolha mel hor. Um mtodo que usa incl u-
so s funciona se esti ver processando objetos relacionados. A sobrecarga permite que
voc reut ilize um nome de mtodo dentre um grupo de mtodos, cujos argumentos po-
dem no estar re lacionados. Voc no pode fazer isso com a incl uso(embora possa usar
uma combinao de incl uso e sobrecarga).
Workshop
As perguntas e respostas do teste so fornecidas para seu melhor entendimento. Veja as respos-
tas no Apndice A, " Respostas".
Teste
I. A part ir das solues de laboratri o, d um exemplo de mtodo sobrecarregado.
2. Qual problema a sobreposio apresenta?
3. Quais passos voc preci sa dar para alterar o comportamento em uma hierarquia polimr-
fica?
4. A partir dos laboratrios, encontre um exemplo de polimorfismo de incluso.
5. Como voc elimina lgica condi cional?
6. Qual a vantagem do polimorfi smo de incluso em relao sobrecarga?
7. Na 00, qual o relacionamento entre objetos e dados?
8. que h de errado com as estruturas condici onai s?
9. Qual uma boa indicao de que uma estrutura condic ional ' ruim '?
10. Explique o polimorfismo com suas prprias palavras.
Exerccios
No h exerccios hoje. Faa seus laboratrios!
SEMANA 1
Em reviso
Na semana um voc no apenas aprendeu os fundamentos da programao orientada a objetos,
mas tambm corno e quando deve aplic-los.
Voc aprendeu que os trs pilares da programao orientada a objetos so o a
herana e o polimorfismo. O encapsulamento permite que voc construa software independen-
te. O encapsulamento conseguido atravs de abstrao, ocultao da implementao e diviso
da responsabi lidade. A herana permite que voc reutilize c estenda cdi go j existente. Voc
aprendeu que existem trs tipos de herana: para reuti lizao de implementao, para diferena
e para substit uio de ti po. O polimorfismo pennite que um unico nome represente cdigo dife-
rente. Os quatro tipos diferentes de polimorfi smo so: pol imorfismo de incluso, poli morfismo
paramtrico. sobrecarga e sobreposio.
O uso dos trs pilares da programao orient ada a objetos penni te que voc crie cdigo que :
Natural
Confivel
Reutil izvel
Manutenrvel
Extcnsivcl
Oportuno
Embora essas inrormaes tenham sido apresentadas nos dias 2, 4 e 6, os laboratrios dos dias 3,
Se 7 so o que realmente rene tudo. A experi ncia prti ca nesses laboratrios aumentou o seu en-
tendimento de como escrever cdigo orientado a objetos que atinge os objetivos mencionados.
SEMANA 2
Aprendendo a aplicar 00
8 Introduo fi UML
9 Introduo AOO (Anlise Orientada a Objetos)
10 Introduo ao roo (Projeto Orientado a Objetos)
11 Reutilizando projetas atravs de padres de projeto
12 Padres avanados de projeto
13 00 e programao de interface com o usurio
14 Construindo software confi vel atravs de testes
Panorama
Na primeira semana, voc aprendeu os fundament os da escrita de cdigo ori entado a objelos.
Embora esse seja um primeiro passo na criao de um programa ori entado a objelos, ainda h
muito mais para aprender, antes que voc possa comear a codi fi car.
Nesta semana, voc ult rapassar a si mples codi fi cao e abordar o inteiro processo de desen-
volvimento de software. Os passos do processo de desenvolvimento de software que voc abor-
dar so: an li se, projeto, implementao e teste.
A anli se orientada a obj etos (ADO) o primeiro passo no processo de desenvolviment o. A
ADO permite que voc entenda o problema que est tentando resolver. Aps concluir a ADO,
voc deve conhecer os requisitos de seu programa, assim corno toda a terminologia especfica do
domnio.
Aps ter analisado o problema, voc poder comear a projetar sua solui'lo. O Dia 10 descrever
o projeto orientado a objetos, o processo de pegar o modelo de domni o e criar o modelo de objetos
que voc usar durante a implementao. Os dias II e 12 apresentamo alguns atalhos de projeto.
O prximo passo a implementao; escrever o cdigo. a que voc utiliza as infonnaes
apresentadas na primeira semana.
O teste o estgio fi nal do processo de desenvolvimento. import antc tcstar durante todo o est
gio de implementao, assim como no final , para poder garantir um sistema livrede defei tos.
Esses assuntos complementaro o conheci mento que voc adquiriu na primeira semana e penni-
ti mo que voc tenha uma idia e acompanhe o processo de desenvolvi mento at ter um programa
ori ent ado a objetos totalmente desenvolvido.
DIA


Introduo UML
SEMANA 2
Na semana anteri or, voc aprendeu as teorias bsicas da programao ori entada a objelos. Entre
tanto, si mplesment e conhecer algumas tcnicas e definies no o preparar adequadamente
para aplic- Ias. Voc simplesmente mostra ferramentas a algum, explica seu uso e propsi to e
depois manda essa pessoa construir uma casa? claro que no! A programao no diferente.
A programao de sucesso s surge com experi ncia e boa metodologia. Nesta semana, voc vai
aprender a aplicar corretament e as ferramentas de 00 que viu na semana anterior.
Hoje, voc vai explorar a UML (Unified Modeling Langllage), assim como a lguns dos aspectos
mais elegantes do relacionamento entre objetos. As lies de hoje fornecen10 a linguagem co-
mum que voc usara enquanto aprende a analisar seus problemas e a projetar solues 00.
Hoje voc aprender:
Por que deve se preocupar com a Unified Modeling Language
Como modelar suas classes usando UML
Como modelar os vrios re lacionamentos ent re classes
Como reunir tudo
Introduo Unified Modeling Language
Quando um construtor constri uma casa. ele no faz isso aleatoriamente. Em vez disso, o cons-
tnll or constri a casa de acordo com um conj unto de cpias hel iogrficas detalhadas. Essas
cpias he li ogrficas dispem o projeto da casa explicitamente. Nada deixado ao acaso .
Dia 8
Agora, quantas vezes voc ou algum que voc conhea construiu um programa aleatoriamente?
Quantas vezes essa prtica trouxe problemas para voc?
A UML (Unified Modelillg Langllage) tenta trazer as cpias heliogrlicas para o mundo do soft
ware. A UML uma linguagem de modelagem padro. A linguagem consiste em vrias nota-
cs grlicas que voc pode usar para descrever a arquitetura inteira de seu software. Os
programadores, arquitetos e anali stas de software usam lingl/agem de modelagem para descre-
ver grafi camentc o projeto do software.
Novo TERMO
Uma lillguagem de modelagem uma notao grfica para descrever projeto de soft-
ware. A I inguagem tambm inclui vrias regras para distinguir entre desenhos corre-
tos e incorretos. So essas regras que tomam a UML uma linguagem de modelagem e no apenas
um punhado de s mbolos para desenho.
Uma linguagem de modelagem no igual a Ll m processo aLi metodologia. Uma melod% giadiz
a voc como projctar o software. Em vez disso, Lima linguagem de modelagem ilustra o projeto
que voc criar enquant o segue uma metodologia.
NovO TERMO
Uma metodologia define um procedimento para projetar software. As linguagens de
modelagem capturam esse projeto graficamente.
A UML no a imica linguagem de modelagem. Entretanto, ela um padrJoamplamente aceito.
Ao modelar software, important e fazer isso em uma linguagem comum. Desse modo, out ros
desenvolvedores podem rpida e faci lmente ent ender seus diagramas de projeto. Na verdade, os
cri adores da UML reuniram suas trs linguagens de modelagem concorrentes - por isso, o
U(nified - unificada) em UML. A UML fornece um vocabulrio comum que os desenvolvedo-
res podem usar para transmitir seus projetos.
Novo TERMO
NeTA
A VAn uma linguagem de modelagem padro. A UML consiste na not ao para
descrever cada aspecto de um projeto de software.
No o objetivo deste livro apresentar uma introduo exausti va da UMl. Em
vez disso, este livro apresentar as part es prticas que voc pode usar imedia-
tamente para descrever seu software.
importante notar que uma linguagem de modelagem no diz nada a respeito de como chegar a
seu projeto. Metodologias ou processos que most ram as diretrizes de como analisare projetar
software.
Novo TERMO
Uma melodologia ou processo descreve como projetar software. Uma metodologia
freqUentemente contm uma linguagem de modelagem.
ALERTA
Introduo UML 179
A UMl apresenta um rico conjunto de ferramentas de modelagem. Como re-
sultado, existem muitas informaes que voc pode colocar em seus modelos.
Cuidado para no tentar usar toda notao existente ao modelar. Use apenas
notao suf iciente para transmitir seu projeto.
l embre-se sempre de que o obj elivo de seu modelo transmilir seu projeto.
Faa o que precisar para transmitilo e f ique com isso.
Modelando suas classes
Na semana anterior. voc viu mui to cdigo. Quando voc se aprofunda nele, o cdigo est no n-
vel mais baixo da documentao de seu software. Se seu cdigo funciona, voc tem certeza de
ter seu projeto documentado.
Embora o cdigo seja a documentao mais completa de seu projeto, pode ser extremamente di-
fici l para outros mexerem nele - especialmente se no estiverem familiarizados com o cdigo.
A 'documentao' tambm ti l para algum que no conhea a linguagem de implcmcntao.
Em vez di sso, voc precisa de uma notao que lhe permita documentar seu projeto, para que
outros possam entend-lo imediatamente. Desse modo, outros podero ver a estrutura de classes
de alto nvel e apenas se aprofundar nos detalhes, quando isso for necessri o. De certa forma,
uma notao grfica o isola dos detalhes, para que voc possa eximir-se de entender a estrut ura
de alto nvel de um programa.
Cri ar documentao separada do cdigo exige o comprometimento de mano
t -Ia em sincroni smo com o cdigo.
Uma maneira pela qual a UML o ajuda a transmitir seu projeto fornecendo um ri co conjunto de
notao para descrever suas classes. Usando essa notao, outros podem ver facilmente as prin-
cipais classes que compem o projeto de seu programa. Conforme voc ver, a UML penn it e de-
fini r as classes, assim como descrever os relacionamentos de alto nvel entre as classes.
Notao bsica de classe
A UML fornece um rico conjunto de notao para modelar classes. Na UML, uma caixa repre-
senta a classe. A caixa superior sempre contm o nome da classe. A caixa do centro contm to-
dos os atributos c a inferior contm as operaes. Notas sobre seu modelo aparecem em caixas
com cantos dobrados. A Figura 8.1 resume a estrutura bsica de classes.
NOTA
A UMl faz di ferena entre operao e mtodos. Na UMl. uma operao um
servio que voc pode solicitar de qualquer obj eto de uma classe, enquanto
um mtodo uma implementao especfica da operao. As li es de hoje
acompanharo a utilizao da UMl.
FIGURA 8 . 1
A IIOttl(;O de classe
da U/oilL.
-
-
-
-
Dia 8
-
._dodoorr,.>
,
,
,
,
,
--------
..... ltu' M
Dentro do modelo, voc pode usar os caracteres , # e +, Esses caracteres transmitem a visibilida
de de um atributo ou dc uma operao. O hfe n (-) significa privado, o jogo da velha (#) significa
protegido e o sinal de adio (+) significa pblico (veja a Figura 8.2).
FIGURA 8.2
A IIOtatiO da UML
paro especificar
\'isibilidade,
VIsibilidade
.. public...n.
, pMteel/rd.". n.
, priY' __ .".1tr
public..opr{ ,
pMtectocLopr( I
, prMte. GP<l )
A Figura 8.3 ilustra a compl eta classe BankAccount dos dias 5 e 7,
FIGURA 8 .3
Uma classe
lotalmellle descrita,
BankAccount
, baI ..... : doubPI
dlpositFur.do l. mounr : doubll ) : vo!d
g.,elto""" (): doubPI
M5e.5. """ ( I : void
wirhdrowFuod. (omoun5 : doub .. ): doubPI
s vezes, uma nota ajudar a transmitir um significado que, de outro modo, fi caria perdido ou
seria ignorado, como a nota da Figura 8.4,
FIGURA 8 ,4
Um exemplo
delOlflado de lIora.
8ank
+ .ddAccounl ( I
+ 100.IHoldings t I
.. 100.IAceounls ( )
.. deposit ( I
.. balance I)
------ -
o blnco cont6m ,,6.1., COnlal
e fornece operaOes porl
m. nipular ln'" cont."
Introduo UML 181
Essas notas so a modelagem anloga anotao adesiva do mundo real.
Notao avanada de classe
A UML tambm deli ne algumas outras notaes, mais avanadas. O uso correIO dessa notao o
ajuda a cri ar modelos mais descrit ivos.
A UML o aj uda a ser mais descritivo, permitindo que voc amplie o vocabulrio da prpria lin-
guagem, atravs do uso de esteretipos.
Novo TERMO
Um eSlere61ipo um elemento da UML que permite que voc amplie o vocabul-
rio da prpria li nguagem UML. Um esteretipo consiste cm uma palavra ou frase
incl uda entre sinais de menor e maior dupl os <). Voc coloca um estereti po acima ou ao
lado de um element o existent e.
Por exemplo, a Figura 8. 1 mostra o esteret ipo Atributo . Esse estereti po ilustra onde
acrescentar atributos em um retngulo de cl asse. A Figura 8.5 ilustra out ro esteretipo que infor-
ma lIm pouco sobre a operao.
FIGURA 8 .5
Um eS/e/"elipo qlle
qualifica a
OperOf(io.
BankAccount
<<accessor. + gelBalunceU
+ depositfundsU
+ wilhdruwfundsO
Final mente, voc pode se lembrar que a classe BankAccount foi ori ginalmente defi ni da como
lima classe concreta. Ent retanto, o Dia 7 redefi ni u a classe BankAccount como uma classe abstra-
ta. A UML fornece uma notao para transmitir que uma classe abstrata: o nome da classe abs-
trata escrito em itl ico. No caso de BankAccount, o nome deve ser escri to em itlico, conforme
ilustrado na Figura 8.6.
FIGURA 8 .6
O objelo
BankAccount
abSlrato.
BankAccount
b,lance' doubl.
+ deposilFund. lamounl' doubl, ), vOH:!
+ IISIS.lance () : doubl,
' "'t8alance (I' void
+ lamaunl: doublel' double
Modelando suas classes de acordo com seus objetivos
As duas sees anteri ores apresentaram muitas escolhas diferent es de notao. Dadas todas es-
sas opes, como voc sabe quais notaes deve usar?
Dia 8
Voc sempre precisa voltar s perguntas, "o que eu estou tentando transmitir?" e "para quem eu
estou telllando transmiti r isso?" O objetivo de um modelo lransm iti r seu projeto o mais eficien-
tement e (e simplesmente) possivel.
Talvez seu objeti vo seja transmitir a interface pblica de uma classe. A Figura 8.7 poderia bas-
tar. Ela transmite adequadamente a interface pblica de Bank, scm sobrecarreg-lo com os deta-
lhes de argumentos de mtodo ou atri butos ocul tos. Tal notao bastar, se voc quiser
simplesmente transmi ti r o que outros objetos poderiam fazer com instncias de Bank.
FIGURA 8 .7 Bank
Uma lIo111(io simples
/um/ Bank.
addAccount ()
tOlolHoldings ( )
1010lAccounlS ( )
dapos it ( )
bol8nce ( )
Entretanto, tome a Figura 8.3 como out ro exemplo. Essa figura document a completamente todos
os at ributos e operaes (pblico, protegido e pri vado) da classe BankAccount. Voc poderia mo-
delar uma classe com esse detalhe, se quisesse transmitir a defi nio inteira da classe para outro
desenvolvedor. Ou talvez., quando voc progredi r em sua carreira 00, possa se tomar um arqui-
teto. Voc poderi a dar tal modelo para um desenvolvedor, para que ele pudesse criar a classe.
Ento, a resposta da pergunla "como eu sei quais notaes devo usar?" que isso depende.
Quando uma pessoa no-tcnica pergunta a voc o que faz, voc responde de li ma maneira
que essa pessoa entenda. Quando um colega pergunla o que voc faz, voc geral mente d
uma resposta tcnica. Modelar seu projeto no diferente. Use o vocabul rio que for apro-
pri ado para o que voc esti ver tentando fazer.
DICA
Dicas para a model agem ef iciente:
Sempre faa a voc mesmo a pergunta ~ o que eu estou tentando transmi
t i r ~ A resposta o ajudar a decidir exat amente o que voc precisa modelar.
Sempre faa a voc mesmo a pergunta " para quem eu estou tent ando
t ransmitir a informao?" A resposta ditar o modo como voc vai modelar.
Sempre tent e produzir o model o mai s simples que ai nda tenha xi to em
t ransmit ir seu proj et o.
No fique preso linguagem de modelagem. Embora voc no deva ser
vago demai s na semntica, no deve dei xar que o fato de segui r a not ao
perfeit amente o impea de concl uir seus diagramas. Os perigos de parali -
sia ao model ar so reais - especiatmente quando voc est comeando.
No se preocupe se seu modelo no estiver 100% perfeit o. Preocupese
somente se seu modelo no transmite corretamente o projeto.
Finalment e, lembrese de que a UML (ou qualquer l inguagem de model a
gem) simplesmente uma ferramenta para ajudl o a transmi tir o projeto.
El a no um instrumento em si mesma. No f inal do di a, voc ainda preci
sar produzir cdi go.
Introduo UML
Modelando um relacionamento de classe
As classes no existem no vcuo. Em vez disso, elas tm relacionamentos complexos entre si.
Esses relacionamentos descrevem como as classes interagem umas com as outras.
NovO TERMO
Um re/aciollllmelllo descreve como as classes interagem entre si. Na UM L, UIl1 re la-
cionamento uma conexo entre dois ou mais elementos da notao.
A UML reconhece trs tipos de al to nvel de relacionamentos de objeto:
Dependncia
Associao
Generali zao
Embora a UML possa fornecer notao para cada um desses relacionamentos, os relacionamen-
tos no so especificos da UML. Em vez disso, a UML simplesmente fornece um mecanismo e
vocabulrio comum para descrever os relacionamentos. Entender os relacionamentos, indepen-
dentemente da UML, import ante em seu estudo de 00. Na verdade, se voc si mplesmente ig-
norar a notao e entender os relacionamentos, estar bem adiantado nos estudos.
Dependncia
Dependncia o relacionamento mais simples entre objetos. A dependncia indica que um objc-
to depende da especificao de out ro objeto.
NeTA
Novo TERMO
uma manei ra dif eremede dizer interface ou comportamento.
Em um re!acionamel1lo de dependncia, um objeto dependente da especificao de
outro objeto. Se a especifi cao mudar, voc precisar atual izar o objelo dependente.
Lembre-se dos laboratri os do Dia 7. Voc pode dizer que Psychiatri stObject depende de
MoodyObj ect, por dois moti vos. Pri mel ro, o mtodo exami ne () de Psyc h i a t ri s tObj ec t rece-
be um MoodyObject corno argumento. Segundo, o mtodo examineO chama o mtodo query-
Mood () de MoodyObject. Se o nome ou lista de argumentos do mtodo queryMood () mudar, voc
precisar atualizar o modo como Psychi atri stObject chama o mtodo. Do mesmo modo, se o
nome da classe MoodyObject mudar, voc ter de atualizar a lista de argumentos do mtodo
examineO.
A Figura 8.8 ilustra a notao UML do relacionamento de dependncia ent re Psychia-
t r istObject e HoodyObject .
Dia 8
FIGURA 8.8
Um relaciol/amelllO de
dependllcia simples.
+e .. mineO + q .... 'VMoodU : St ring
NOTA
Tome not a do que a Figura 8.8 no di z. O elemento Psychiat r istObject no
conl m cada mtodo encont rado em Psych1atristObject. O mesmo val e para
MoodyObj ect. Em vez disso, esse model o de dependncia contm apenas os re-
cursos necessrios para descrever o relaci onamento de dependncia.
Lembrese de que a notao UML serve para t ransmi tir informaes. Ela no
est l para que voc tente usar cada truque de modelagem do livro de UML!
Atravs da POO, voc sempre tenta minimizar o mximo possvel as dependncias. Ent retanto,
impossvel remover todas as dependncias ent re seus objetos. Nem todas as dependncias so
criadas de modo igual. As dependncias de interface geralment e esto corretas, enquanto as de-
pendncias de implementao quase nunca so aceitveis.
DICA
Quando voc deve modelar dependncias?
Nor malment e, voc modela dependncias quando quer mostrar que um obje-
l o usa outro. Um lugar comum onde um objeto usa oul ro atravs de um ar-
gumento de mt odo. Por exemplo, o mtodo exami neO de Psych1at r 1 st Object
recebe um HoodyObject como argumento. Voc pode di zer que Psychia-
tri stObject usa HoodyObj ect.
Associao
Os relacionament os de associao vo um pouco mais fundo do que os relacionamentos de de-
pendncia. As associaes so rel acionamentos estrut urais. Uma associao indica que um obje-
to contm - ou que est conectado a - outro objeto.
Novo TERMO
Uma associado indica que um objelO contm outro objeto. Nos tennos da UML,
quando se est em um relac ionamento de associao, um objclO est conectado a outro.
Como os objetos esto conectados, voc pode passar de um obj eto para outro. Considere a asso-
ciao entre uma pessoa e um banco, como il ustrado na Figura 8.9.
Ft GURA 8.9
Vma (lssociarfio emre //fila
/JCSS()(l e 1/1/1 bW1CO.
I Pessoa I Empreste de 1>1 Banto I
A Figura 8.9 mostra que urna pessoa empresta de um banco. Na notao UML, toda associao
tem um nome. Neste caso, a associao chamada de empresta de. A seta indica a di reo da as-
sociao.
Introduo UML 185
Novo TERMO
o nome da associai'lo um nome que descreve o relacionamento.
Cada objeto em uma associao tambm tem um papel, confonne indicado na Figura 8.10.
FIGURA 8 .10
Os pllpis IIl1l1SSOCilllio.
Novo TERMO Na associao, o papel de Pessoa devedor e o papel de Banco credor.
Novo TERMO o papel da associao a parte que um objeto desempenha em um relac ionamento.
Finalmente, a multipli cidade indica quantos objelos podem tomar parte em uma associao.
Novo TERMO
A l11uIIIJ)/icidllde indica quantos objetos podem tomar parte na instncia de uma as-
sociao.
A Figura 8.11 ilustra a multiplicidade da associao entre Pessoa e Banco.
FIGURA 8.11
Mulriplicidade.
1 Pessoa 11... .1 Banco 1
Essa notao nos informa que um banco pode ter um ou mais devedores e que lima pessoa pode
utilizar O ou mais bancos.
NOTA
DICA
Voc especi f ica suas multiplicidades atravs de um nico numero, uma l ista
ou com um asterisco (*).
Um nico nmero si gnifica que determinado nmero de objel os - no mais e
no menos - podem participar da associao. Assim, por exemplo, um 6 signi -
fi ca que seis objetos e somente seis objetos podem participar da associao.
* significa que qualquer nmero de objetos pode partici par da associ ao.
Uma lista define um intervalo de objetos que podem participar da associao.
Por exemplo, 1 . .4 indica que de 1 a 4 obletos podem part icipar da associao.
3 .. * indica que trs ou mais obletos podem participar.
Quando voc deve modelar associaes?
Voc deve model ar associaes quando um oblet o conti ver outro objeto - o
relacionamento rem um. Voc tambem pode modelar uma associao quando
um objeto usa outro. Uma associ ao permit e que voc modele quem faz o
que em um relaci onamento.
186 Dia 8
A UML tambm defi ne dois tipos de associao: agregao e composio. Esses dois subtipos
de associao o ajudam a refi nar mais seus modelos.
Agregao
Uma agregao um tipo especial de associao. Uma agregao modela um relacionamento
tem 1//1/ (oupa,,'ede, no j argo da UML) cnlre pares. Esse relacionamento signi fi ca que um ohjc-
to contm out ro. Pares significa que um objeto no mais importante do que o out ro.
Novo TERMO
Novo TERMO
Um re/acioIlOmIII O IOdo/parte descreve o relaci onamento entre objclos onde um
ohjclo cont m outro.
Uma agrega(io um tipo especial de associao que modela o rel acionamento 'tem
um' de relacionamentos todo/parte ent re pares.
Importncia. no contexto de uma agregao, significa que os objclos podem existir independen-
temente uns dos outros. Nenhum objeto mais importante do que o out ro no relacionamento.
Considere a agregao ilustrada pela Figura 8. 12.
FIGURA 8.12
Agregllli o eml'e 1/111
banco e seus cliellles.
I Banco
1..0

Cliente
Aqui, voc v que um Banco pode conter qualquer nmero de obj etos Cl iente. O losango aberto
ajuda seu modelo a indicar qual objeto o todo e qual a parte. Aqui, o losango diz que Ba nco o
todo. Banco o objelo que ' tem um' no re lacionamento. Banco contm objetos Cl i ente. Em ter-
mos de programao, isso poderia significar que Banco contm um array de objetos Cl i ente.
NOTA
Um losango aberto simboliza agregao. O losango toca o objeto que consi-
derado o todo do relacionamento: a classe que se refere outra classe. O todo
constitudo de partes. No exemplo anterior, BanCO o todo e os objetos CI i -
ente so as partes.
Out ro exemplo de agregao um carro e seu motor. Um carro 'tem um' mo-
tor. Nessa agregao, o carro o todo e a parte o motor.
Como Banco e Cl iente so independentes, eles so pares. Voc pode di zer que o objeto Banco e
o objeto Cl iente so pares, porque os objelos Cl i ente podem existir independentemente do ob-
jeto Banco. Isso significa que, se o banco encerrar suas operaes, os cI ientes no desaparecero
Introduo UML 187
com o banco. Em vez disso, os clientes podem se tornar clientes de outro banco. Do mesmo
modo, um cliente pode sacar seus fundos e o banco conti nuar.
A agregao entre objetos funci ona como esses exemplos reais. Um objeto pode conter outro olr
jeto independente. Queue ou Vector um exemplo de objeto que pode conter outros objetos, atra-
vs da agregao.
D ICA
Quando voc deve modelar a agregao?
Voc deve modelar uma agregao quando o objetivo de seu modelo for des-
crever a estrutura de um relacionament o de pares. Uma agregao mostra ex-
plici tamente o relacionamento estrut ural todo/parte.
Entret ant o, se voc est iver mais interessado em modelar quem faz o que em
um relacionamento, melhor usar uma associao si mples: sem o losango.
Composi o
A composio um pouco mais rigorosa do que a agregao. A composio no um relaciona-
mento entre pares. Os objetos no so independentes uns dos outros.
A Figura 8. 13 ilustra um relacionamento de composio.
FIGURA 8 .13
COlllposi(10 elllre 1/1/1 b (/IICQ e
.nta.f filiai.f .
I
Banco 1 ... -- ,
Aqui, voc v que Banco pode conter muitos objetos fi 1 ial . O losango fechado diz que esse
um relacionamento de composio. O losango tambm diz quem ' tem um' . Neste caso, Banco
' tem um', Otl contm, objetos filial.
NeTA
Um losango fechado si mboliza a composio. O losango toca o objeto que
considerado o todo do rel acionament o. O todo constitudo de partes. No
exemplo anteri or, Banco o todo e os objetos Filial so as part es.
Como esse um relacionamento de composio, os objetos Fil ; a1 no podem existir inde-
pendentemente do objeto Banco. A composio diz que, se o banco encerrar suas atividades, as fil iais
tambm fecharo. Entretanto, o inverso no necessariamente verdade. Se uma filial fechar, o
banco poder permanecer funcionando.
Um objeto pode part icipar de uma agregao e de um relacionamento de composio ao mesmo
tempo. A Figura 8.14 modela tal relacionamento.
I
188 Dia 8
FIGURA 8.14 . ~
Filiei
Banco em 1/111 relacioname"to
~ . 1
1
de agregatia e de
1 ..
compositio.
silllulwneamellle.
D ICA
NOTA

Cliente
Quando voc deve modelar uma composio?
Assim como a agregao, voc deve modelar uma composi o quando o obje-
t ivo de seu modelo for descrever a estrutura de um relaci onamento. Uma com-
posio mostra explicitamente o rel acionamento estrut ural todo/ parte.
Ao contrrio da agregao, a composi o no modela relacionamentos
todo/parte de pares. Em vez disso, a parte dependent e do todo. Volt ando ao
exemplo Banco, isso significa que quando o banco encerrar suas atividades, as
fili ais t ambm fecharo.
Em l ermos de programao, isso significa que quando o objeto Banco for des-
truido, os objetos F1l1al tambm sero destrudos.
Novamente, se o objetivo de seu modelo f or capturar os papis dos objetos na
associao, voc deve usar uma associao simpl es.
l embre-se de que agregao e composi o so simplesmente refinamentos
ou subtipos da associao. Isso significa que voc pode model ar agregao e
composio como uma associao simples. Tudo depende do que voc est iver
t entando modelar em seu diagrama.
Generalizao
Um relacionamento de generalizao um relacionamento entre o geral e o espec fi co. a he-
rana.
Novo TERMO
Um re/acionamenfO de generalizao indi ca um re lacionamento ent re geral c es-
pecifico. Se voc tem um relacionamento de generalizao, ent o sabe que pode
substit uir uma classe filha pela classe progenitora.
A generali zao incorpora o relacionamento ' um ' sobre o qual voc aprendeu no Dia 4. Con-
fonne foi aprendido no Dia 4, os relacionamentos ' um' pennitem que voc defi na rel aciona-
mentos com capaci dade de substit uio.
Atravs de relacionamentos com capacidade de substi tuio, voc pode usar descendentes em
vez de seus ancestrais, ou fi lhos em vez de seus progenitores.
A UML fornece uma notao para modelar generalizao. A Figura 8.15 ilustra como voc mo--
delaria a hierarquia de herana BankAccount.
FIGURA 8.15
A hierarquia de herana
BankAccount.
Introduo UML 189
BIonkAccount
"fi
SavingsAccoun1 OYerd,aftAccoun1
1\
TimaMa1uri1yAccoun1 Rewa,dsAccoun1
Uma linha chcia com uma seta fechada e vazada indica um relacionamento de generali zao.
Reunindo tudo
Agora que voc j viu a modelagem bsica de classe eos relacionamentos, pode comear a mon-
lar modelos bastante expressivos. A Figura 8.8 apresentou um exemplo de dependncia simpl es.
Usando o que aprendeu durante lodoo dia, voc pode tomar esse modelo um pouco mais expres-
sivo. A Figura 8. 16 expande o relacionamento modelado na Figura 8.8.
Figura pgina 198 em baixo
FIGURA 8.16
Vm modelo de dependncia
mais e.'(pressivo.
Psychia1ris1Object
+ examine ( I
---------
SadObject HappyOblect
+ queryMood ) + queryMood ( )
A Figura 8. J 6 acrescenta uma generalizao para que voc possa ver quai s objetos pode substi
tuir por MoodyObject nesse relacionamenlo.
Do mesmo modo, a Figura 8. 17 expande a hi erarquia de herana apresentada na Figura 8. 15.
FIGURA 8.17
VII/a hierarquia
de herana
BankAccount
mais dela/hada.
,
Dia 8
,
' M \' ,...,
,
O ..... /L" ..
a ;$.. ....
,
Row .. _ ",,,,"
Examinando esse modelo, voc pode ver exatamente o que cada classe acrescenta na hierarquia.
Tal modelo poderia ajudar outros desenvolvedores a ver o que cada classe oferece, aci ma e alm
de suas descendentes.
Todos esses modelos tm um elemento comum. Cada modelo contm apenas infonnaes sufi -
cientes, apenas notao sufi cient e, para transmi tir a idia. O objeti vo desses modelos no usar
cada notao disponvel.
Todos esses modelos tambm combinam diferentes elementos da UML. Como uma linguagem
de programao, a UML pcnnite que voc combine suas vrias panes de maneiras excl usi vas.
Atravs da combinao de vrios element os, voc pode cria r modelos muito expressivos.
Resumo
Hoje, voc aprendeu os fundament os da modelagem de classe e relacionamentos. Aps prat icar
os exerc cios de hoje, voc dever consegui r comear a desenhar model os de classe simples,
usando a UML.
A UML fornece notaes para modelar classes, assim como os relacionamentos entre objetos, A
UML fornece notaes para descrever trs ti pos de re lacionamentos:
Dcpendncia
Associao
Generali zao
Introduo UML
A UML tambm reconhece dois subti pos de associao: agregao e composio. Combinando
todos esses elemeruos, voc pode gerar diagramas de classe expressivos. Seu domnio da UML
importante para documentar e transmitir seus projetos para out ros.
Perguntas e respostas
P. Voc I)ode misturar os trs lipos de relacionamenlOS dentro do mesmo modelo?
R. Sim. Seu modelo pode ilustrar qualquer combinao dos relacionamentos delineados
neste dia. O modelo existe para descrever os re lacionamentos entre suas classes. Voc
deve modelar os relacionamentos entre suas classes.
P. Como voc " S:I a UML? Existem ferramentas especficas?
R. Voc pode usar a UML como quiser. Voc pode desenhar seus diagramas em uma ferra-
menta de modelagem, em um quadro negro ou em um guardanapo de papel. Depende da
si tuao. Se voc estiver em uma discusso interativa sobre o projeto, provavelmente de-
sejar usar um quadro negro, pois atualizar um comput ador pode ser complicado.
As ferrament as de model agem por computador so melhor lIsadas quando voc quer do-
cumentar forma lmente um projeto.
Workshop
As perguntas e respostas do leste so forneci das para seu melhor entendi mento. Veja as respos-
tas no Apndice A, "Respostas".
Teste
I. o que UML?
2. Qual a diferena entre uma metodologia e uma linguagem de modelagem?
3. Que tipo de relacionamento existe entre Employee e Payroll , no Laboratrio I do Dia 7?
4. Examine cuidadosamente o modelo da Figura 8.15. Usando apenas o modelo, o que voc
pode dizer a respeito de MoodyObject?
5. Examine os laboratrios do Dia 7. Encontre um exemplo de dependncia.
6. Na UML, o que os sinai s a seguir simbolizam: +, #, -?
7. O Dia 2 apresentou a segui nte interface:
publ ic interface Queue (
publ i c void enqueue( Object obj );
publlC Object dequeue() ;
}
publ i C boo1ean lSEmpty();
pu b1 i c Object peek() ;
Dia 8
Que ti po de relacionamento Queue tem com os elementos que contm?
8. No Dia 3, Laboratrio 3, a classe Deck criava vrias cartas. Que tipo de relacionament o
' tem um' isso representa?
9. Como voc ilustra que uma classe OLl mtodo abstraio?
lO. Qual o objeti vo fi nal da modelagem? Quais conseqUncias esse obj etivo tem?
I I. Explique associao, agregao e composio.
12. Expl ique quando voc deve usar associao, agregao e composio.
Exerccios
I. Modele a classe Queue definida na questo 7.
2. Modele um relacionamento de composio abelhalcolmia.
3. Modele o relacionamento entre Bank e BankAccount do Laboratrio 2, Dia 7.
4. Modele a associao entre um comprador e um comerci ante. Especifique os papi s, a
multiplicidade e o nome da dependncia.
5. Modele a hierarquia de funcionri os do Laboratri o 2 do Dia 5. Atravs de seu modelo,
transmita o que cada classe adiciona acima e alm de suas descendentes.
6. Veja o Dia 6. Modele a hierarquia de herana Persona 11 t yObject.
SEMANA 2
DIA
Introduo AOO (Anlise
Orientada a Objetos)
Ontem, voc aprendeu ti visualizar seus projetas de classe atraves de modelos de classe. Voc
viu como os modelos de classe podem aj udaroulros desenvolvedores a entender melhor seu pro-
jeto, destacando os diferentes tipos de objetos e relacionamentos que eles encontraro em seu
software. As linguagens de modelagem, como a UML, fomecem a voc e ti seus colegas desen-
volvedores li ma linguagem comum para falar a respeito de projeto.
Entretanto, a questo ainda permanece; como voc projeta software ori entado a objetos? Os mo-
delos simplesmente capturam um instantneo de seu projeto. Eles no o ajudam a entender seus
problemas ou a formular lima sol uo. Em vez disso, os modelos so simplesmente o resultado
final do projeto de software. Como voc chega l?
Nos prximos dois dias, voc vai aprender a respeit o da AOO (Anli se Orientada a Objelos) e
POO (Projeto Orientado a Objetos). AOO uma estratgia orient ada a objelos para entender
um problema. Voc usa AOO para ajudar a entender o nllcleo do problema que deseja resolver.
,
Aps entender seu problema, voc pode comear a projetar uma soluo. E a que o Projeto Ori-
entado a Objetos (POO) entra em ao. No restante da lio de hoje, voc vai aprender a respeito
de AOO.
Hoje voc aprender:
Sobre o processo de desenvolviment o de software

Como a AOO o aj uda a entender seus problemas de software
1 194 Dia9
Como chegar a um entendimento de seu problema usando casos de uso
Como usar a UML para visualizar sua anl ise
Como construir seu modelo de domnio
O quc fazer com lUdo que voc cria durante a AOO
o processo de desenvolvimento de software
Existem tantas maneiras de desenvolver software quanto existem desenvolvedores. Entretanto,
uma equipe de desenvolvimento de software precisa de uma estratgia uni ficada para desenvol-
ver software. Nada ser feito, se cada desenvolvedor fizer sua prpria atividade. As metodologias
de software definem uma maneira comum de encarar desenvolvimento de software. Uma meto-
dologia rreqUentemente conter uma linguagem de modelagem (como a UML) e um processo.
Novo TERMO Um processo de software mostra os vrios estgios do desenvolvimento de software.
Um exemplo familiar de processo de software o processo de cascata.
FIGURA 9.1
Anlise de
O proce.fSo de casemo.
requisitos
"
Projeto
L
Irnplementaio
"
Teste
Conforme a Figura 9. 1 ilustra, o processo de cascata seqUencial e unidirecional. O processo
const itudo de quatro estgios di st intos:
I. Anli se de requi sitos
2. Projeto
3. Implementao
4. Teste
Quando segue o processo de cascata, voc vai de um estgio para prximo. Ent retanto, uma
vez que voc complete um estgio, no h volta - exatamente como descer uma cascata ou um
penhasco escarp."ldo! O processo de cascata tenta evitar alterao, proibi ndo mudar quando um
estgio est concludo. Tal estratgia protege os desenvolvedores de requisitos que mudam
Introduo AOO (Anlise Orientada a Objetosl 195
constantemente. Ent retanto, ta l processo rigido freqentement e resulta em software que no o
que voc ou seu cl iente quer.
Quando voc analisa um problema, projeta uma soluo e comea a implement ar, seu entendi
menta do problema continuamente aprofundado. O mel hor entendimento de seu problema
pode muito bem invalidar uma anlise ou projeto anterior. Os requi sitos podem at mudar en-
quanto voc desenvolve (talvez um concorrent e tenha acrescentado um novo recurso em seu
produto). Infelizmente. o processo de cascata no pode enfrentar a realidadc do moderno desen-
volvimento de software - requisitos que mudam constantemente.
Embora este li vro ni'lo tente impor nenhuma metodologia especfi ca, h um processo que tem se
mostrado muito efi cient e para desenvolvimento orientado a obj etos: o processo iterativo. Este li
vro impe esse processo!
o processo iterativo
O processo it erati vo o oposto do processo de cascata. O processo iterativo permite alteraes
em qualquer ponto do processo de desenvolvimento. O processo iterativo permite al terao ada.
tando uma estratgia iterativa e incremental para o desenvolvimento de software.
Novo TERMO
Um processo ileralivo uma estratgia iterativa e incrememal para desenvolvi men
to de software. Outro modo de pensar a respeito do processo como uma estratgia
' evolut iva'. Cada ilerai'l o aperfeioa e elabora gradualmente um produto bsico em um produto
amadurecido.
Uma estratgi a iterativa
Ao contrrio do processo de cascata, o processo iterativo pennite que voc continuamente volte
e refine cada estgio do desenvolvimento. Por exemplo, se voc descobrir que o projeto simples-
mente ni'l o funciona ao executar a implementao, pode voltar e fazer um projeto adici onal e
uma nova anl isco esse refinamento contnuo que torna o processo iterati voo A Figura 9.2 ilus-
tra a estratgia.
Uma estratgia incremental
Ao segui r um processo iterativo, voc no conclui simplesmente lima iterao grande que cons-
tri o programa inteiro. Em vez disso, o processo iterativo divide o trabalho de desenvolvi mento
em vri as iteraes pequenas. A Figura 9.3 ilustra essa estratgia incremental.
FIGURA 9.2
UII/a ilera(10.
FIGURA 9.3
O processo iterO/ho.
Iterlllo 1
Dia 9
Implementao
Itera!o 2
Anlise
Projeto
Implementa60
Teste
Fim da Itera60

Itera60 N
Ent rega
Cada iterao do processo inl roduz uma pequena melhori a incremental no programa. Essa me-
lhoria pode ser um novo reurso ou um refinamento de um recurso j existente.
Introduo AOO (Anlise Orientada a Objetos) 197
De qualquer modo, a iterao tem um objeti vo especfico e, no final da iterao, voc tem uma
melhoria notvel na funcionalidade.
Imagine que voc esteja criando um MP3 player. Durant e uma iterao do projeto, voc pode
terminar o component e que reproduz um arquivo MP3. Para determi nar se o componente funci-
ona, voc pode codifi c-lo de modo que abra e reproduza um arquivo de msica especfi co. Na
prxima iterao, voc pode adicionar a capacidade de escolher qual arquivo vai ser reproduzi-
do. Em cada iterao, voc tem um progresso mensurvel. No final da pri meira iterao, voc
pode ouvir o component e reproduzir uma msica. No final da iterao seguinte, voc tem um
mecanismo que permite escol her dinamicamente uma msica para tocar.
Seguindo uma estratgia iterativa, voc v o progresso constantemente. Por outro lado, se voc
tentar fazer tudo simultaneamente, poder ser dificil ver qualquer forma mensunvel de progres-
so. Em vez disso, o projeto parecer constantemente atolado em um nico lugar - nunca h
qualquer resultado. Se um projeto nunca for adiante, o moral vai baixar e se tornar diflcil deter-
minar o que precisa ser fe ito em seguida. Moral baixa e confuso sobre o que fazer em seguida
fragmentar e matar um projeto.
A LERT A
Os processos iterativos precisam ser cuidadosament e moni torados para se ga-
rantir que eles no sejam simplesment e reduzidos a 'cavar' uma soluo. A
AOO e o POO fornecem tal verif icao de sanidade.
o progresso constante fornece a voc relorno constante. Voc pode usar esse retorno como um
modo de garant ir se est no caminho certo. Se voc tentar completar o proj eto inteiro de uma
vez, no saber se criou a soluo correta at tenninar. Voltar e corrigir algo que niio foi fei to
corretamente ser muit o mai s dispendioso se voc precisar voltar e reescrever o programa intei-
ro! A iterao, por outro lado, torna muito mais barato voltar e corri gi r algo. Como voc recebe
retomo constante, mais provvel que ident ifique um problema mais cedo. Se voc identificar
seus problemas mais cedo, ser mais fc il refazer uma iteraiio ou duas para corrigi-lo. sempre
mais desejvel reescrever urna iterao do que reescrever um programa inteiro! Se voc mantiver
suas iteraes pequenas, no perder muito tempo, caso tenha de se des faze r de alguma delas.
Se um problema chegar base da iterao original, uma estratgia iterativa
no poder salv-lo. Tal problema fundamental pode ser di spendioso demais
para corrigir e pode danificar a qualidade do produto.
Uma metodologia de alto nvel
Este livro apresenta uma metodologia de desenvolvimento orientada a objelos infonnal. A me-
todologia sclcciona e escol he as tcnicas que se mostraram eficazes a partir de outras metodolo-
gias. A metodologia consiste em um processo iterativo, no qual uma iterao tem quatro
estgios:
1 198 Dia9
Anl ise
Projeto
Implementailo
Teste
NOTA
Aps o estgio de teste. voc tambm pode ter estgios de la namento e ma-
nuteno. Esses so estgi os importantes no ciclo de vida de um projeto de
sohware. Entretant o, para os propsitos da tio de hoje, esses estgios sero
omiti dos. HOje, voc vai focal izar anlise, projeto. implementao e teste.
As metodologias ' reais' freqUentemente enumeram estgios adicionais. Entretanto, quando
voc est aprendendo pela pri mei ra vez, esses quatro estgios silo aqueles que mais importam.
Por isso, este li vro se concentra nesses quatro estgios. O restante deste dia abordar a anli se
orientada a objetos.
AOO (Anlise Orientada a Objetosl
AOO (Anli se Ori entada a Objetos) o processo usado para entender o problema que voc est
tentando resolver. Aps completar a anlise, voc dever entender os requisitos do problema, as-
sim como o vocabulrio do domnio do problema.
Novo TERMO
Analise orientada a ohje/os um processo que usa uma estratgia orientada a objetos
para ajud- lo a enlender o problema que est tentando resolver. No final da anli se,
voc dever entender o domnio do problema e seus requisitos em tennos de classes e interaes
de objetos.
Para projetar uma soluo para um problema, voc precisa entender como os usurios uti lizari'io
o sistema. A resposta dessa pergunta so os requisitos do sistema. Os requisit os informam a voc
o que os usurios querem fazer com o sistema e quais tipos de respostas eles esperam receber.
Novo TERMO
Sislema o termo da AOO para um conjunto de objetos que interagem. Voc pode
di zer que esses objetos constituem um sistema ou modelo do probl ema.
Esses objetos so instncias de classes derivadas de objetos concretos ou abstratos no domnio
do problema que est sob est udo.
A anlise tambm o ajuda a se familiarizar com o domnio do problema. Estudando o domnio,
voc comea a identificar os objetos de que precisa para modelar corretament e o sistema.
A AOO, confonne o nOme sugere, uma estratgia orientada a objetos para anl ise de requisi-
tos. A AOO util iza uma estratgia baseada em 00, modelando o problema atravs de objctos e
suas interacs. Existem dois modelos pri ncipais. O modelo de caso de uso descreve como um
usurio interage com o sistema. O modelo de domnio captura o vocabulrio princi pal do siste-
Introduo AOO (Anlise Orientada a Obj et os)
199
ma. Usando o modelo de domnio, voc comea a identi fi car os objetos que pertencem ao seu
sistema. Um modelo de domnio corrctamente construdo pode resolver mui tos problemas no
mesmo domnio.
Usando casos de estudo para descobrir o uso do sistema
Ao comear a analisar um problema, voc primei ro precisa ent ender como seus usuri os utiliza-
ro ou interagiro com o sistema. Esses usos compreendem os requisitos do sistema e prescre-
vem o sistema que voc cria. Atendendo os requi sitos de seus usurios, voc produz um sistema
til.
Novo TERMO
Os requisitos so os recursos ou caractedsticas que o sistema deve ter para resolver
determinado problema.
Novo TERMO
Um modo de descobrir esses usos atravs de anlise de casos de uso. Atravs da
anli se voc definir vrios casos de uso. Um caso de uso descreve como um usurio
vai interagir com o sistema.
Novo TERMO
Novo TERMO
Amlise de ClI:,-oS de /(so o processo de descobena de casos de liSO atravs da criao
de cenri os e hi strias com usuri os cm potencial ou existentes de um sistema.
Um caso de liSO descreve a intcrao entre o usuri o do sistema e o sistema - como
O usurio ut ilizar o sistema do seu prprio ponto de vista.
A cri ao de casos de uso um processo iterativo. Existem vrios passos que voc deve dar du-
rante cada iterao, para fonnalizar seus casos de uso. Para definir seus casos de uso, voc deve:
i. identificar os atares.
2. Criar uma li sta preliminar de casos de uso.
3. Refi nar e nomear os casos de uso.
4. Definir a seqilncii\ de eventos de cada caso de uso.
5. Modelar seus casos de uso.
NOTA
Voc no cri a casos de uso no vcuo! Enquanto deriva seus casos de uso, voc
deve consultar aqueles que utilizaro o sistema - seus clientes. A participa-
o do cli ent e absolutamente fundamental para se descobrir os casos de uso
(a no ser que voc esteja escrevendo o software para si mesmo).
Seus client es so os especialistas do domnio. Eles conhecem bem seu espao
de at uao e sabem do que precisam em seu software. Sempre se certi f ique
de contar com o conhecimento deles e us-lo para ori entar os requisi tos de seu
software.
Fazer os usurios comporem histrias sobre seu dia ideal de interao com o
sistema pode ser uma boa maneira de quebrar o gelo nessa atividade.
Dia 9
Antes de continuar com o dia, importante dizer que os exemplos no tentam
real izar uma anlise completa de um sit e da Web on-line. Em vez disso, os
exemplos ensinam os passos que voc dar enquanto realizar uma anl ise
real. Assi m, muitos casos de uso sero omitidos.
Na prxi ma semana, voc trabalhar com uma anlise ori entada a objetos
compl eta.
Identifique os atores
O primeiro passo na definio de seus casos de uso definir os atores que usaro o sistema.
Novo TERMO
Um (1/01' tudo que interage com o sistema. Pode ser um usurio humano, outro sis-
tema de computador ou um chimpanz.
Voc preci sa pedir aos seus clientes para que descrevam os usurios do sistema. As perguntas
podem incluir as seguintes:
Quem principalmente usar o sistema?
Existem outros sistemas que usaro o sistema? Por exemplo, existem quaisquer usurios
que no so seres humanos?
O sistema se comunicar com qualquer outro sistema? Por exemplo, h um banco de da-
dos j existente que voc precise integrar?
O sistema responde ao estimulo gerado por algum que no seja usurio? Por exemplo, o
sistema precisa fazer algo em certo dia de cada ms? Um estimulo pode ser proveniente de
fontes nonnal mente no consideradas ao se pensar do ponto de vista puramente do usurio.
Considere uma loja da \Veb on-line. Uma loja on-line pennite que usurios convidados nave-
guem pelo catlogo de produtos, verifique o preo dos itens e solicite mais infonnaes. A loja
tambm permite que usuri os registrados comprem itens, assi m como cont rola seus pedidos e
mantm informaes dos usuri os.
A partir dessa breve descrio, voc pode idenli ficar dois atares: usurios convidados e usuri os
registrados. Cada um desses doi s atares interage com o sistema.
A Figura 9.4 ilustra a notao UML para um atar: um desenho de pessoa com um nome. Voc
deve dar a cada um de seus atares um nome no ambguo.
FIGURA 9. 4
Q. al ores lia UML.
Usutirio Regist rado

Introduo AOO (Anlise Orientada a Objetosl 201
importante evitar confuso ao nomear seus atores. D a cada ator um nome
que identifique exclusivamente o ator.
Uma boa atribuio de nomes fundamental. Os nomes devem ser simples e
fceis de lembrar .
E importante notar que detemlinado usurio do sistema pode assumir o papel de muitos alares
di ferentes. Um ator um papel. Por exemplo, um usurio poderia entrar no site como convidado,
mas posteri ormente se conectar como registrado para poder fazer uma compra.
N O TA
ALERTA
Um usurio pode assumir muitos papisdiferentes enquanto interage com um
sistema. Um ato r descreve o pape/que o usurio pode assumi r enquanto inte-
rage com o sistema.
Quando voc comear a definir seus casos de uso, crie uma lista preliminar de
atares. No se atrapalhe ao identificar os atares. Ser diflcil descobrir todos os
atares na primei ra vez.
Em vez disso, encontre atares suficientes para comear e adicione os outros
medida que os descobrir.
Os atares so os instigadores de casos de uso. Agora que voc j identificou alguns atorcs, pode
comear a definir os casos de uso que eles executam.
Crie uma lista preliminar de casos de uso
Para definir seus casos de uso, voc precisa fazer algumas perguntas. Comece com sua lista de
atores conhecidos. Voc precisa perguntar o que cada ator faz com o sistcma.
No caso da loja da Wcb on- line, voc tem usurios regi strados c usurios convidados. O que
cada um desses atares faz?
Os usurios convidados podem fazer o seguinte:
I. Navegar pelo catlogo de produtos.
2. Pesquisar o catlogo de produt os.
3. Procurar um it em especfico.
4. Pesqui sar o site.
5. Adicionar itens em um carri nho de compras e especificar a quantidade.
6. Ver o preo dos itens selecionados.
7. Mudar a quantidade de itens em seu carrinho.
8. Ver a li sta de produt os popular e nova.
9. Navegar pela li sta de itens desejados de out ros usurios.
10. Solicitar mais inrormaes sobre produto.
Dia 9
Os usuri os regi strados podem fazer o seguinte:
1. Tudo que o usuri o convidado pode fazer.
2. Fazer uma compra.
3. Adicionar itens em sua lista de itens desejados.
4. Ver uma lista personali zada recomendada.
5. Manter sua conta.
6. Assinar notificaes.
7. Tirar provei to de ofertas especiais personalizadas.
8. Controlar seus pedidos.
9. Ass inar vrias li stas de di stribuio.
10. Cancelar um pedido.
NOTA
Provavelmente existem mui t o mais casos de uso. Entretant o, para nossos pro-
psitos aqui e por brevidade, isso suf iciente para comear.
Quando tentar identi fi car casos de uso, voc tambm dever fazer a pergunta, "como um atar
muda seu papel?"
No caso da loja on-l ine, um usurio convidado pode se tomar um usurio registrado, das seguin-
tes maneiras:


O usurio convidado pode se conectar com o site.
O usurio convidado pode se registrar no si te.
Um usurio registrado se torna um usuri o convidado, como segue:
Um usuri o regi strado pode se desconectar do site.
At aqui, essas perguntas so orientadas pela interao. Voc tamb m pode adotar uma estrat-
gia orientada por resultados para a descobelta. Por exemplo, voc pode dizer que um usurio re-
gistrado recebe uma notificao. Um segundo ponto de vista pode ajud-l o a descobrir casos de
uso que voc poderia ter ignorado, se si mplesmente ficasse com o primeiro ponto de vista.
Finalment e, considere as vrias entidades que os usurios manipulam. Aqui, voc v produtos,
informaes sobre a conta e vrias listas de produto e descontos. Como todas essas entidades en-
tram no sistema? Quem adiciona novos produtos e edita ou excl ui produtos antigos?
Esse sistema precisar de um terceiro atar, o administrador. Passando pelo processo anteri or-
mente del ineado, voc pode verificar que os administradores podem fazer o seguinte:
Introduo AOO (Anli se Ori entada a Objetosl 203
I. Adicionar, edi tar e excluir produtos.
2. Adicionar, edi tar c excl ui r incentivos.
3. Atualizar infonnacs de conta.
As perguntas podem levar a outras perguntas. Por exemplo, quem atua\iza a lista de produtos p0-
pulares? Quem envia noti fi caes e correspondncias para as listas de dist ri bui o? Um quarto
ator, o prprio sistema, executa todas essas aes.
Refine e nomeie os casos de uso
Agora que voc tem uma lista preliminar de casos de uso, precisa refinar a li sta. Em particular,
voc desejar procurar oport unidades de dividir ou combinar os casos de uso.
Dividindo casos de uso
Cada caso de uso deve execut ar um objetivo principal. Quando voc encontrar um caso de uso
que estiver fazendo muita coisa, desejar dividi\o em dois ou mai s casos de uso. Considere o
caso de uso a segui r:
Os usuri os convidados podem adicionar itens em um carrinho de compras e especi fi car a quan
tidade.
Voc deve dividir esse caso de uso em dois:
Os usurios convidados podem adicionar itens em um carrinho de compras.
Os usurios convidados podem especificar a quantidade de um item.
Voc pode fazer a diviso de casos de uso, devido maneira como eles se relacionam entre si. Os
casos de uso so muito parecidos com as classes. Um caso de uso pode conter outro. Assim, se
uma instncia de caso de uso exige que outra faa seu trabalho, ela pode us-Ia.
Um caso de uso tambm pode estender o comportamento de outro caso de uso. Como resultado,
voc pode colocar comportamento comum em um caso de uso e, ent o, desenvolver outros casos
de li SO que sejam especiali zaes do original. Pegue o exemplo "os usurios registrados podem
fazer uma compra". Um caso de uso pode especiali zar o pedido, criando um caso de uso pedido
para presente. Um pedido para presente poderi a ser entregue sem recibo.
Combinando casos de uso
Voc noquercasos de uso redundantes. Um modo de evitar a redundncia ficar atento s vari
antes do caso de uso. Quando voc as encontrar, dever combi nar as variant es em um (mico caso
de uso.
Novo TERMO
Uma varianle de caso de uso uma verso especializada de outro caso de uso mais
geral.
Dia 9
Considere os dois casos de uso a seguir:


Os usurios convidados podem pesquisar o catlogo de produtos .
Os usurios convidados podem procurar um item especfico .
Aqui , o segundo si mplesmente uma variante do primeiro caso de uso mais geral.
Neste caso, o caso de uso difere apenas nos parmetros de pesquisa. melhor ter si mplesmen-
te um caso de uso e documentar a variante nos modelos de caso de uso que voc construir pos-
teriormente.
Uma vari ante muito parecida com uma instncia de uma classe. Lembre do exemplo
BankAccount. Um objcto BankAccount com um saldo de US$ l 0.000 pode ter mais dinheiro que
um BankAccount com US$ l 00. Entretanto, ambos ainda so objetos BankAccount. Tudo que dife-
rencia um objeto BankAccount de outro O valor de seus atributos. Os casos de uso funcionam da
mesma maneira.
Os casos de uso resultantes
Aps concluir o refinamento de seus casos de uso, voc deve nomear cada caso de uso. Assim
como na atribuio de nomes de atores, voc deve se esforar por nomear seus casos de uso de
maneira que evite confuso.
Aqui esto os casos de uso resultantes para usuri os convidados e usurios registrados, aps a di-
viso e a combinao:
I. Navegar pelo catlogo de produtos.
2. Pesquisar o catlogo de produtos.
3. Pesquisar o site.
4. Adicionar item no carri nho de compras.
5. Ver o preo dos itens.
6. Mudar a quantidade de item.
7. Ver a lista de produtos destacada.
8. Navegar em uma li sta de itens desejados.
9. Solicitar informaes sobre produto.
10. Pedir.
I I. Manter o pedido.
12. Adicionar itens na li sta de itens desejados.
13. Atualizar a conta.
14. Assinar a correspondncia.
15. Apli car incent ivos.
Introduo AOO (Anlise Orientada a Objetosl 205
16. Conectar.
I 7. Desconectar.
18. Registrar.
Neste ponto, voc tem uma lista de casos de uso bem desenvolvida. Agora, basta especi fi car to-
talmente cada caso de uso.
Defina a seqncia de eventos de cada caso de uso
A breve lista de casos de uso s6 infonna parte da histria. Internamente, muito mai s poderia estar
ocorrendo dentro de um caso de uso. Pegue um pedido como exemplo. Um usuri o no pode fa
zer um pedido em um passo. Em vez disso, ele deve usar uma seqncia de passos para concluir
um pedido com xito (como fornecer um mtodo de pagamento).
A seqncia de passos que um usurio usa para completar um caso de uso conhecida como ce-
nrio. Um caso de uso const itudo de vrios cenrios.
Novo TERMO Um cenrio uma seqUncia ou fluxo de eventos entre o usurio e o sistema.
Como parte de sua anlise de casos de uso, voc deve especificar os cenrios de cada caso de uso.
Vamos desenvolver o caso de uso Pedido. Primeiro, comece descrevendo o caso de uso em um
pargrafo:
O usurio registrado prossegue com a totalizao e pagamento, para adquirir os itens de seu
carrinho de compras. Uma vez na pgina de totalizao e pagament o, o usurio fornece infor-
maes de entrega. Uma vez fornecidas, o sistema totaliza e apresent a o pedido. Se tudo esti-
ver correto, o cliente poder optar por cont inuar com o pedido. Quando o usurio continua
com o pedido, o sistema consulta suas informaes de pagamento. Uma vez fornec idas, o sis-
tema autoriza o p<lgamento. Ento, ele exibe uma pgina de conformao de pedido final,
para os regist ros do usurio, e envia um e-mail de confinnao.
Existem alguns aspectos interessantes nesse caso de uso. Primeiro, ele no diz nada sobre a im-
plementao subjacente. Segundo, voc pode us lo para identificar as condies prvias e pos
teriores do caso de uso.
Novo TERMO
NOTA
Condies previas so aquelas condies que devem ser satisfeitas para que um caso
de uso comece. Condies posteriores so os resultados de um caso de uso.
Um dos problemas desse tipo de sistema que voc provavelmente no est
reunindo casos de uso dos usurios do sistema, mas das pessoas que querem
que voc os escreva. Lembre-se de que os modernos aplicativos da Web e ou-
tros aplicativos que se deparam com o cliente, como quiosques, podem exigir
que voc t rabalhe com grupos convergentes.
Dia 9
Aqui, a condi o prvia que o usurio j colocou itens no carrinho. O caso de uso Pedido pede
os itens do carrinho. A condio posteri or um pedido. Aps completar a caso de uso, o sistema
conter um pedido para o usurio.
Nesse ponto, ajuda considerar todos os caminhos alternativos no caso de uso de pedido. Talvez a
aut orizao de pagamento falhe ou o usurio decida cancelar o pedido, antes do trmino. Voc
precisa capturar esses cami nhos alternativos.
Aps se sentir vontade com o caso de uso, voc deve escrev-lo formalmente. Um modo de es-
crever o caso de uso li star os passos seqencialmente. Aps os passos, voc deve listar as con-
dies prvias, as condi es posteriores e os caminhos alternat ivos. Considere novamente o
caso de uso Pedido:
o Pedido
I. O usurio registrado passa para a totalizao e pagamento.
2. O usurio registrado fornece infonnaes de entrega.
3. O sistema exibe o total do pedido.
4. O usuri o registrado fornece informaes de pagamento.
5. O sistema autoriza o pagamento.
6. O sistema conli rma o pedido.
7. O sistema envia um e-mail de continnao.
o Condies prvias
o Um carrinho de compras no vazio.
o Condies posteriores
o Um pedido no sistema.
o Alternat iva: cancela pedido
Durant e os passos I a 4, o usuri o opta por cancelar o pedido. O usuri o vol ta para a homc
page.
o Alt ernativa: a autorizao falhou
No passo 5, o sistema fa lha em autorizar as informaes de paga ment o. O usurio pode
reintroduzir as infonnaes ou cancelar o pedi do.
Voc precisar completar o mesmo processo para cada caso de uso. Defi nir formalmente os ce-
nri os o ajuda a ver o fluxo de eventos no sistema, assim como a solidificar seu ent endi mento do
sistema.
DICA
Introduo AOO (Anlise Orientada a Objet osl 207
Ao escrever seus casos de uso, inclua apenas as informaes que fizerem sen-
ti do. Assim como na modelagem de classe, seu obj eti vo transmiti r algum
tipo de informao. Inclua apenas as informaes para transmitir o que voc
est tentando fazer.
Inclua apenas as condies prvias necessrias para Que o caso de uso come-
ce. Nilo inclua informaes extras e desnecessrias.
Certifique-se de consultar outros textos sobre casos de uso. Existem mui tas
maneiras de escrever um caso de uso (no h um padro).
Ao escrever seus casos de uso pela primeira vez, considere o uso de uma ficha de
arquivo com um lpis. Desse modo, voc no ter de estar diante de um compu-
tador, enquanto gera seus casos de uso iniciais. Dependendo de quem forem
seus clientes, pode ser dificil trabalhar com eles diante de um computador.
Diagramas de caso de uso
Assim como a UML fornece uma maneira de documentar e transmiti r projeto de classe, tambm
existem maneiras formais de capturar seus casos de uso. De especial interesse so os diagramas
de caso de uso, diagramas de interao e diagramas de atividade. Cada um ajuda a visual izar os
vrios casos de uso.
Os diagramas de caso de uso modelam os relacionamentos entre casos de uso e os re lacionamen-
tos entre casos de usoe atares. Embora a descrio textual de um caso de uso possa aj ud-lo a en-
tender um caso de uso isolado, um diagrama o ajuda a ver como os casos de uso se relacionam
uns com os outros.
A Figura 9.4 mostra como modelar atares. A Figura 9.5 ilustra a notao UML para um caso de
uso: uma elipse rOlUlada.
FIGURA 9 .5
O caso dI! liSO lia UMC
( pedido)
Coloque um atar e um caso de LISO juntos no mesmo diagrama e voc ter um diagrama de caso
de uso. A Figura 9.6 o diagrama de caso de uso Pedido.
FIGURA 9 .6
O caso de I/S0 Pedido.
---,,> .. ( pedidO )
Usuri o Registrado
Esse diagrama muito simples; ent retanto, examinando-o, voc pode ver que o usurio registra-
do executa o caso de uso Pedido.
Dia 9
Os diagramas podem ser um pouco mais complicados. O diagrama tambm pode mostrar os re-
lacionamentos existentes entre os prpri os casos de uso. Conforme voc j leu, um caso de uso
pode conter e usar outro. A Figura 9.7 ilustra lal relacionamento.
FIGURA 9.7
Um relaciOllamento lisa. Pedido
uA
( AssInatura da corrupond6ncl l
Aqui , voc v que o caso de uso Registro usa o caso de uso Assinatura da correspondncia.
Como parte do processo de regi stro, o usurio pode optar por receber e-mail s e notificaes.
A Figura 9.8 ilust ra o segundo ti po de relacionament o, o relacionamento estende.
FIGURA 9.8
Um relaciollamelllO eSfellde.
U."'rio Registr.OO
Consult 1"" de produto. dsstacad.
V recomendaes de produto estende a genrica Consulta a /is/a de produ/os destacada, apre-
sentando ao usuri o registrado uma li sta de produtos personalizados para suas preferncias de
compras. A normal V recomel1daes de produto, confonne vista por um usuri o convidado,
pode simplesmente mostrar os itens mais vendidos ou mais solicitados. Essa extenso apresenta
ao usurio produtos nos quais seu perfil sugere que ele poderi a estar interessado.
Assim como nas classes, possivel ter um caso de uso abstraio. Um caso de uso abSlrato um
caso de uso que outros casos de uso utilizam ou estendem, mas que nunca usado diretamente
por um atar em si. As abstraes nonnal mente so descobertas aps voc ter fe ito sua anlise de
caso de uso inicial. Enquanto voc estuda seus casos de uso, pode encontrar meios de extrair ca-
ractersticas comuns e coloc- Ias em casos de uso abstratos.
Introduo AOO (Anlise Ori entada a Objetosl 209
Diagramas de interao
Os diagramas de caso de uso aj udam a modelar os relacionamentos entre casos de uso. Os diagra
mas de interao aj udam a capturar as interaes ent re os vrios atares paT1icipantes do sistema.
Vamos expandiras casos de uso que vi mos anterionnente. Vamos adici onar um novo ata r, o re-
presentante de servio ao cliente. Freqentemente, um usurio registrado pode se esquecer de
sua senha. O representante de servio ao cliente est l para ajudar o usurio a reaver o acesso
sua conta. Vamos criar um novo caso de uso, Senha Esquecida:
Um usuri o registrado liga para o representante de servio ao cliente e informa ao represen
lante que perdeu sua senha. O represent ante de servio ao c li ente pega o nome completo do
usuri o e extrai as informaes de conta do usuri o. O representante de servio ao cliente faz
ento vrias perguntas ao usurio registrado, para estabelecer sua ident idade. Aps passar
por vrias interpelaes, o representante de servio ao cliente excl ui a senha anti ga c cria uma
nova. Ento, o usuri o recebe a nova senlla por email.
Esse caso de uso tambm pode ser descrito como segue:
o Senha Esquecida
I. O usuri o registrado liga para o representante de servio ao client e.
2. O usurio regi strado fornece o nome completo.
3. O representante de servio ao cliente recupera as infonnaes do cliente.
4. O usurio registrado responde a vrias perguntas de idemificao.
5. O representante de servio ao cliente cri a uma nova senha.
6. O usurio recebe a nova senha por email.
Condies prvias
O usuri o esqueceu sua senha.
o Condies posteriores
o Uma nova senha enviada por email ao usurio.
o Alt ernativa: a identificao falhou
O usuri o pode fa lhar cm responder corretamente as perguntas de identificao no passo
4. Se ass im for, a chamada terminar.
o Alternati va: usurio no encontrado
No passo 2, o nome fornecido pode no ser o de um usuri o conhecido. Se assim for, o re
presentante de servio ao cliente se oferecer para registrar o usurio chamador.
Existem dois tipos de diagramas de interao: diagramas de seqUncia e diagramas de colabora
o. Vamos explorar cada um deles.
Dia 9
Diagramas de seqncia
Um diagrama de seqncia modela as interaes entre o usurio registrado, o representante de ser-
vio ao cliente e o site Web, com o passar do tempo. Voc deve usar diagramas de seqUncia quan-
do quiser chamar a ateno para a seqUncia de eventos de um caso de uso, com o passar do tempo.
A Figura 9.9 apresenta um diagrama de seqUncia para o caso de uso Senha Esquecida.
Conforme voe pode ver na ilustrao, um diagrama de seqUnci a representa os eventos entre
cada atare o sistema (o site Web). Cada part icipante do caso de LI SO representado no incio
do diagrama como uma caixa ou como um desenho de pessoa (mas voc pode chamar ambos
de caixa).
Uma li nha tracejada, conhecida como linha da vida, sai de cada caixa. A linha da vida representa
o tempo de vida da caixa durante o caso de uso. Assim, se um dos atares fosse embora durante o
caso de uso, a li nha termi nari a na l tima seta que termi na ou se origina no atar. Quando um atar
deixa um caso de uso, voc pode dizer que seu tempo de vida terminou.
FI GURA 9 .9
A diagrama de
seqiilla Se"ha
Esquecida.
SileWeb
Registrado Representante de ServIo ao Cliente
1: Relata senha esquecida
2: SoIic:lte nome completo
3: Fornece nOrntl oompleto
.: Recupera inlorma6es do u ..... io
5: Devolve .egi"ro
6: Fel pargunln de Identificao
7: Responde as perguntas
8: Gera nova IInll.
9: Envia senlla por email
I
Novo TERMO
Uma linha da vida uma linha tracejada que sai de uma caixa em um diagrama de se-
qUncia. A linha da vida representa o tempo de vida do objelo representado pela caixa.
As selas se originam na linha da vida para indicar que o atar enviou uma mensagem para outro
atar ou para o sistema. Quando voc desce na linha da vida, pode ver as mensagens conforme
Introduo AOO (Anlise Ori entada a Objetos)
211
elas se ori ginam seqencial mente, com o passar do tempo. O tempo corre de cima para baixo em
um diagrama de seqUncia. Assim, subi ndo na linha da vida, voc pode reproduzi r a seqncia
de eventos de trs para frente.
Diagramas de colaborao
Voc deve usar di agramas de seqncia se tiver a inteno de chamar a ateno para a seqncia
de eventos com o passar do tcmpo. Se voc quiser modelar os relacionamentos ent rc os atares e o
sistema, ento deve criar um diagrama de colaborao.
A Figura 9. 10 modela o caso de uso Senha como um diagrama de colaborao.
Em um diagrama de colaborao, voc modela uma interao conectando os part ici pantes com
uma linha. Acima da linha, voc rotula cada evento que as entidades geram, junto com a direo
do evento (para quem ele dirigido). Ele tambm aj uda a numerar os eventos, para que voc sai-
ba em qual ordem eles aparecem.
FIGURA 9.10
O diag/'ama de
colaborartio
Se"ha &q/lecidll.
Sil. W.b
Use diagramas de seqncia para modelar a seqncia de event os em um ce-
nrio, com o passar do tempo.
Use diagramas de col aborao para modelar os relacionamentos entre os ata-
res em um cenrio.
Dia 9
Diagramas de atividade
Os diagramas de interao modelam bem as aes seqenciais. Entretanto, eles no podem mo-
delar processos que podem ser executados em paralelo. Os diagramas de atividade o aj udam a
modelar processos que podem ser executados em paralelo.
Considere outro caso de uso Pesquisa. Esse caso de uso pesqui sa o sit e Web c o catlogo de pro-
dutos simultaneamente, usando o caso de uso Pesquisa o catlogo de produtos e o caso de uso
Pesq/lisaosite. No h motivo pelo qual essas duas pesquisas no possam ser executadas simul-
taneamente. O usurio ficari a impaciente se tivesse de esperar que todas as pesqui sas termi nas-
sem seqUencialmente.
A Figura 9. 1 I modela esses processos atravs de um diagrama de ativi dade.
Uma elipse representa cada estado do processo. A barra preta grossa representa um ponto onde
os processos devem ser sincronizados -ou reunidos-, antes que o fluxo de execuo possa ser
retomado. Aqui , voc v que as duas pesquisas so executadas em paralelo e depois reunidas,
antes que o sit e possa exibir os resultados.
FIGURA 9.11
O diagrama de
alil'idade
Pesquisa.
Vamos ver de perto os diagramas de interao e os diagramas de atividade nos prximos dias.
Ent retanto, ambos se mostram teis ao se analisar um sistema.
Introduo AOO (Anlise Ori entada a Objetos)
213
Construindo o modelo de domnio
Atravs da anli se de caso de uso, voc capt ura as interaes do sistema. Entretanto, os casos de
uso tambm o aj udam a capturar o vocabul rio do sistema. Esse vocabulri o constitui o domnio
do problema. O vocabulri o do domnio identi fi ca os pri ncipais obj etos do sistema,
O modelo de domnio lista os objetos que voc precisa para modelarcorretamente o sistema. Pe
gue a loja onl inc. Atravs dos casos de uso, voc pode identificar muitos objctos. A Figura 9. 12
visuali za alguns desses objelos.
Neste ponto, voc pode modelar os relacionamentos entre os objetos do domnio. A Figura 9.1 3
resume alguns desses relacionamentos.
FIGURA 9.12
Os objelos do
domnio.
FIGURA 9.13
0,
relaciOl/alllelltos
dos objetos do
domnio.
ReprfteII""'" do s ..... *' 00 CIiont.
lhW<Io lleglslr_
Sil .. d. W.b
,

Usu6tiO
7*
lIepreHm.nl. de 50rvio ao Client ..
Usujtio Comridado
u...-",>'t '
CII"ogO
O
Item
UI",",- II-;irltado
Pedido

.. '
II <N Comi
Dia 9
o modelo de domnio importante por vrios motivos. Primeiro, o modelo de domni o modela
seu problema independentemente de quaisquer preocupaes com implementao. Em vez dis-
so, ele modela o sistema em um nvel conceituaI. Essa independncia proporciona a flexi bilida-
de para usar o modelo de dom nio que voc const ri para resolver muitos problemas diferentes
dentro do domnio.
Segundo, o modelo de domnio constri a base do modelo de objeto que, fina lment e, se tornar
seu sistema. A implementao final pode adicionar novas classes e remover out ras. Entretanto, o
domni o forneee algo para que voc comece e construa seu projeto - um esqueleto.
Finalmente, um modelo de domnio bem definido estabelece claramente um vocabulri ocOlllum
para seu problema. Encontrando-se um vocabulrio comum, todos os envolvidos no projeto po-
dero encar-lo a parti r de uma posio e um entendimento iguai s.
E agora?
Voc reuniu casos de uso. Voc criou diagramas de interao. Voc at iniciou um modelo de
domnio. O que fazer em seguida?
Os casos de uso tm trs uti lizaes pri ncipais. O primeiro uso trata da funcional idade. Os casos
de uso infonnam a voc como o sistema funcionar. Os casos de uso informam quem usar o sis-
tema. o que esses usuri os faro com ele e o que esperam receber do sistema. A anlise de caso
de uso o aj uda a aprender a respei to do sistema que voc pretende construir.
Segundo, os casos de uso fornecem uma lista de tarefas ' a fazer', medida que voc desenvolve
o sistema. Voc pode comear priori zando cada caso de uso e fornecendo uma estimativa do
tempo que cada um demorar para tenninar. Em seguida, voc pode ptanejar o tempo de seu de-
senvolvimento em torno dos casos de uso. A concluso de um caso de uso pode se tornar um
marco. Os casos de uso tambm se tomam itens de barganha. Freqentemente, as restries de
tempo o obrigaro a sacrificar um caso de uso por outro.
Finalmente, os casos de uso o ajudam a construi r seu modelo de domni o. O modelo de domnio
servir como o esqueleto de seu novo sistema. (E se voc o tiver fe ito corretamente, poder reut i-
lizar esse modelo em qualquer lugar!)
Quando voc perceber que o model o de domnio e a anlise de caso de li SO estil o quase termina-
dos, pode comear a fazer o prottipo das diferentes partes do sistema. Entretanto, no faa o
prottipo de tudo. Voc s deve fazer o prottipo dos aspectos do sistema que parecem confusos
ou arriscados. Fazer o prottipo pode aprofundar o conhecimento, assim como descobri r se uma
idia possvel, identi fi cando e reduzindo os riscos.
Resumo
Introduo AOO (Anlise Ori entada a Obj et os)
215
Dicas para a AOO ef icaz
Evite a paralisia da anli se. A paralisia da anlise ocorre quando voc ten-
ta realizar a anli se perfei ta. Voc ~ n c vai adiant e, pois fica tentando en-
tender perfei tamente o problema. As vezes, o ent endimento total no
possivel sem algum projet o e implementao.
Faa iterao. Faa iterao de t udo. Quando voc comear a anlise, gere
uma lista prelimi nar de casos de uso. Priorize os casos de uso e, em segui-
da, apresente-os atravs de iteraes. Cada iterao deve abranger certa
quantidade de anlise, proj eto e implement ao. A quantidade de imple-
mentao aumentar medi da que o projeto prossegui r: mui to pouco no
inicio, mui to mais durante os estgios posteriores.
Incl ua os especialist as no dominio em sua anlise - mesmo que o espe-
cialista sej a um cli ente. A no ser que voc seja especiali sta no domi nio,
precisar da entrada para modelar o sistema corretamente.
No introduza impl ementao em sua anlise. No deixe a impl ementa-
o ent rar furt ivamente em sua anlise.
A anlise orientada a objetos apl ica objetos ao processo de anlise do problema. A AOO o ajuda
a descobrir os requisitos do sistema que voc pretende construir.
Os casos de uso o ajudam a identi fi car como os usurios vo interagi r com o sistema. Os casos de
uso descrevem a interao, assim como o que os usurios esperam receber do sistema.
Modelos como os diagramas de interao e os diagramas de atividade ajudam a visualizar essas
interacs. Cada tipo de modelo v o sistema de um ponto de vista ligeiramente diferente.
Assi m, voc precisar lembrar das di ferenas e usar cada tipo quando for apropriado.
Os casos de uso oajudam a definir seu modelo de domnio. O modelo de dom nio serve como es
queleto do sistema que voc finalmente construir. O modelo de domni o tem a vantagem dc ser
livre de qua lquer implementao ou uso especfico. Como resultado, voc pode aplicar seu mo-
de lo de domnio em mui tos problemas diferentes.
import ante perceber que a AOO real mente um modo orientado a objetos de ver um proble
ma. Os casos de uso nada mais so do que obj etos. Um caso de uso pode se relacionar com outros
casos de uso, atravs do uso ou da ge nerali zao. As vari ant es dos casos de uso no so diferen
tes da di ferena ent re instncias de classe. Os atares so objetos tambm.
A AOO decompe um problema em vrios casos de uso e objetos de dom nio. Uma vez di vi di
do, voc pode fazer iteraes at obter a soluo final.
Dia 9
Perguntas e respostas
P o que acontece se voc esquece um caso de uso?
R Se voc verificar que se esqueceu de um caso de uso, volte e acrescente-o. Se voc preci-
sar do caso de uso imediatamente, ento deve acrescent- lo imediatamente. Se ele puder
esperar, tome nota c explore-o durante a prxima iterao.
P Ao elaborar um caso de uso, voc sempre precisa fazer diagramas de seqncia, co-
laborao e atividade?
R No. Nem sempre voc precisa fazer todos os trs. Faa o que for necessrio para ajudar
seu entendimento do caso de uso.
Entretanto, voc provavelmente deve pelo menos esboar um dos diagramas. Voc nun-
ca sabe quais problemas ou incgnitas poderia descobrir.
Normalmente, sempre fazemos pelo menos o diagrama de seqncia, a no ser que faa
mais sentido comear com um dos outros.
P Como voc sabe quando tcm casos de uso suficientes?
R Na verdade, voc nunca sabe se encontrou todos os casos de uso. Saber quando parar
vem atravs da experincia. Entretanto, voc provavelmente tem casos de uso suficientes
quando percebe que possui um entendimento adequado do problema eque se sente confi-
ante de que pode prosseguir.
Se voc omiti r um caso de uso, sempre pode voltar e acrescent-lo em sua anlise. Entre-
tanto, voc deve tomar cuidado com a anlise em demasia de um problema. No sucum-
ba paral isia da anlise.
Workshop
As perguntas e respostas do teste so fornecidas para seu mel hor entendimento. Veja as respos-
tas no Apndice A, "Respostas".
Teste
I. o que um processo de software?
2. O que um processo iterativo?
3. No fi nal da AOO, o que voc deve ter feito?
4. O que os requisitos do sistema informam a voc?
5. O que caso de liSO?
6. Quais passos voc deve dar para definir seus casos de LISO?
Intro duo AOO (Anlise Orientada a Obje t os)
7. O que um atar?
8. Quais so algumas perguntas que voc pode fazer para descobri r os atares?
9. COnl O os casos de uso podem se relacionar ent re si?
10. O que uma variante de caso de uso?
I I. O que um cenri o?
12. Quai s so algumas maneiras pelas quais voc pode modelar seus casos de uso?
217
13. Descreva as diferenas entre os vri os modelos usados para visuali zar casos de uso.
14. Para que serve um modelo de domnio?
15. I)ara que servem os casos de uso?
Exerccios
I. Quais outros casos de uso voc poderia acrescentar na lista de casos de uso da loja on-li ne?
2. Pegue um dos casos de uso da questo I e desenvolva-o.
3. Uma variante de caso de uso um caso especfico de um caso de uso mais geral. Quais
variames voc consegue identificar nos casos de uso de usurio convidado e de usurio
registrado?
4. Quais outros objetos de dominio voc consegue encont rar?
SEMANA 2
DIA
Introduo ao POO (Projeto
Orientado a Objetos)
Ontem, voc viu como a AOO (Anli se Orientada a Objetos) o ajuda a entender um problema c
seus requisitos. Atravs da anli se de casos de uso e da construo de um modelo de domnio,
voc pode capturar o ' mundo real ' ou detalhes em nvel de domnio deseu problema. Entretanto,
a ADO apenas parte da histria geral do desenvolvimento.
O roo (Projeto Orientado a Objetos) o ajuda a pegar a domni o que voc encontrou na AOO e a
projetar urna soluo. Enquanto o processo da AOO o aj udou a descobri r mui tos dos objelos de
domnio do problema, o roo o ajuda a descobrire projetar as objetos que aparecero na soluo
especfi ca do probl ema.
Hoje voc aprender:
Como transformar sua anli se cm uma soluo
Como identi fi car e projetar os objelos que aparecero em sua soluo
Como os cartes CRC (Classe Responsabilidade Colaborao) podem aj ud-lo a desco-
brir responsabilidades e relacionamentos de objetos
Como voc pode usar a UML para capt urar seu projeto
Dia 10
POO (Projeto Orientado a Objetosl
Novo TERMO
POO o processo de construir o modelo de objeto de uma soluo. DilO de outra ma
neira, roo o processo de dividir uma soluo em vri os objetos const ituintes.
Novo TERMO
o modelo de objeto o projeto dos objetos que aparecem na sol uo de um proble
ma. O modelo final de objeto pode conter muitos objetos no encontrados no dom
nio. O modelo de objeto descrever as vrias responsabi lidades, relacionamentos e estrutu ra do
objeto.
o processo de POO o ajuda a descobrir corno voc vai implementar a anlise que compl etou du
rante a AOO. Principalmente, o modelo de objeto que conter as classes pri ncipais do projeto,
suas responsabil idades e urna definio de como elas vo interagir e obter suas informaes.
Pense no roo em termos da construo de uma casa para uma famlia. Antes de construi r a casa
de seus sonhos, voc decide quai s tipos de ambientes deseja em sua casa. At ravs de sua anlise,
voc pode achar que deseja uma casa que tenha uma cozinha, dois quartos, doi s banheiros e um
lavabo, uma sala de estare uma sala de jantar. Voc tambm pode precisar de um gabinete de lei
tura, uma garagem para dois carros e urna piscina. Todos os ambientes e a piscina compreendem
a idia e o projeto de sua casa.
O que voc faz em seguida? Um construtor simplesmente comea a construir? No. Primeiro,
um arqui teto descobre como os ambientes mel hor se encaixam, comoa fiao deve ser passada e
quais vigas so necessrias para manter a casa de p. Ento, o arquiteto prepara um conjunt o de
cpias heli ogrficas detalhadas, que capturam o projeto. O construtor usa essas cpias hei iogr
ficas como guia, enquant o constri a casa.
Usando os termos do mundo da construo, voc usa o roo para criar as cpias heliogrficas de
seu programa.
Um processo de projeto formal o ajuda a determinar quais objetos aparecero em seu programa e
como eles vo interagir ou se encaixar. O projeto indicar a estrutura de seus objetos e um pro
cesso de projeto o ajudar a descobrir muitos dos problemas de projeto que voc encontrar ao
codificar.
Ao se trabalhar como parte de uma equipe, importante identificar e resolver o mximo de pro
blemas de projeto possvel, antes de iniciar a construo. Resolvendo-se os problemas ant ecipa-
damente, todo mundo trabalhar sob o mesmo conjunto de suposies. Uma estratgia
consistente para o projeto tornar mais fcil reunir todos os componentes posteri ormente. Sem
um projeto claro, cada desenvolvedor far seu prprio conjunto de suposies, freqUentemente
incompativel com outros conjuntos de suposies. O trabalho ser dupli cado e a diviso de res
ponsabilidades entre os objetos ser desfei ta. De modo geral, o proj eto que emerge poderia se
tornar facilmente uma confuso, se no esti ver todo mundo na mesma pgi na.
Introduo ao POO (Projeto Orientado a Objetos)
Alm disso, erros so exponencialment e mais dispendiosos para corrigir, quanto mais tarde na
seqncia de desenvolvi mento eles forem descobertos. Os erros no projeto tm um custo muito
baixo para corrigir.
Enquanto projetar sua soluo, voc ver que freqi.ienlemenle existe mais de uma soluo para o
problema. O POO pennite que voc explore cada sol uo interessante e decida ant ecipadamente
qual cami nho deve segui r. Atravs do projeto, voc pode tomardeci5es acertadas, e atravs da
document ao, voc pode documentar o motivo pelo qual optou pelas escolhas que fez.
O modelo de objeto identifica os objetos significativos que aparecem na soluo; entretalllo, o
modelo de objeto um superconjunto do domnio. Embora muitos dos objetos que apa recem no
modelo de domnio encontrem seu lugar no projeto, muitos objetos no encontrados no modelo
de domnio tambm aparecero. Do mesmo modo, objetos no encontrados na anli se podem
achar seu lugar no projeto, cxatamente como a fiao no aparece na anlise inicial de uma nova
casa. Uma vez tendo seu projeto, voc pode comear a codi ficar.
Dito isso, no leve o projeto ao extremo. Exatamente como a AOO pode sofrer de paralisia da
anlise, o POO pode sofrer de paralisia do projeto.
Voc deve evitar o projeto demasiado de sua soluo. Simplesmente no possvel prever cada
deciso de projeto que voc precisar tomar, antes de tom-la, e alguma parte do projeto pode ser
deixada para o momento da construo. Voc no quer ser pego tentando criar o projeto perfeito;
voc precisa comear a codificar em algum momento. O que voc precisa fazer projetar os as-
pectos arquitetonicamente significativos do sistema.
Como voc sabe quais aspectos de seu sistema so arqllitetonicGmente significativos? As partes
significativas so os aspectos do sistema onde uma deciso diferente alteraria completament e a
estrutura ou o comportamento do sistema.
Lembre da loja on- line e do carrinho de compras discutidos ontem. Sabendo que tem um objeto
carrinho de compras em sua anlise, voc precisa projetar quais abstraes especificas sero usa-
das para representar o carrinho de compras - como um mostrador de preo, uma loja persistente
e um monitor de expirao. Mas voc no precisa projetar uma tabela hashing ou vetor que ser
usado para representar o contedo do carrinho - esse um assunto apropriado para lima fase de
projeto detalhado (implementao), mas detalhado demais para esta fase.
Como voc aplica POO (Projeto Orientado a
Objetol?
o poo um processo iterativo que identifica os objetos e suas responsabilidades em seu siste-
ma, e como esses objetos se relacionam. Voc refina continuamente o modelo de objetos, quan-
do faz a iterao pelo processo de projeto. Cada iterao deve dar uma idia mais aprofundada
do projeto e ta lvez at do prprio dominio.
NOTA
Dia 10
Quando voc aprender mais sobre o problema que est tentando resol ver du-
rante o proj eto, tal vez preci se aplicar mais anli se. l embre-se de que no h
vergonha em voltar e refinar sua anlise! A nica vergonha est em cri ar soft -
ware intil.
Existem vrios passos pouco definidos que voc pode seguir para construi r seu modelo de obje-
Ias. Nonnal mente, voc:
I. Gerar uma li sta inicial de objetos.
2. Refi nar as responsabi li dades de seus objetos.
3. Desenvolver os pont os de interao.
4. Detalhar os relacionament os entre objetos.
5. Construi r seu modelo.
Seu entendimento do projeto aumentar quando voc completar esses passos e repetir o processo.
NOTA
Exi stem muitas maneiras de completar o poa. Os passos delineados anteri or-
mente const it uem um processo informal que combina aspectos de muitas me-
todologias di ferentes.
A metodologia que voc vai segui r depender da exper incia, do dominio, da
postura da empresa e do bom gosto. No f inal do paa, voc deve ter decom-
posto a soluo em vrios objetos. Como voc chega a esses obj etos fi ca por
sua conta e da sua equipe de projeto.
Passo 1: gere uma lista inicial de objetos
Quando comea a projetar seu sistema, voc precisa comear com o domnio que defi ni u durant e
a anlise. Cada objeto do domnio e cada ator deve se tomar uma classc cm seu novo modelo de
objetos. Voc ver que alguns dos objetos de domnio no tero lugar em seu modelo de objetos
final ; entretant o, neste ponto, voc no pode ter certeza de qual ter; portanto, voc precisa in-
cl uir todos eles.
Lembre da loja on-line do Dia 9, "Introduo AOO (Anli se Orientada a Objelos) ". A Figura
10.1 iluslra as classes bsicas que aparecero em seu modelo de objetos ini cial.
Ao procurar a lista de classes inici al, voc tambm desejar considerar todos os eventos q ue pos-
sam afelar seu sistema. Cada um desses eventos deve aparecer inicialmente como uma classe. O
mesmo pode ser dito para todos os relatrios, leias e disposit ivos. Todos esses elementos devem
ser transformados em uma classe.
Introduo ao POO (Projeto Orientado a Objetos) 223
FIGURA 10.1
''''"
"'"''
As classes ba.icas da
l oja oll lille.
' ,m
CII!JIomerServiceAep
ShopplngClrt
Aecollml nlo,m.tion Glle.tUM'
Aqui esto algumas di cas para animar essa li sta de classes inicial:
Transforme cada ator em uma classe.
Transforme cada objeto de domnio em uma classe.
Transforme cada evento em uma classe.
Consi dere como o sistema apresentar informaes e transforme cada
tela em um objeto.
Represente todos os outros sistemas ou di spositi vos com os quais o siste-
ma interage como classes.
Neste ponto, voc no pode di zer muito a respeito das c lasses que li stou. Voc pode ter uma
idia geral das responsabilidades e relacionamentos dos objetos; entretanto, voc precisa se
aprofundar um pouco mai s, antes de poder finalizar seu entendimento das novas classes.
Passo 2: refine as responsabilidades de seus objetos
Uma li sta de objetos um bom ponto de partida, mas apenas uma pequena parte de seu proje-
to global. Um proj eto completo capturar as responsabilidades de cada obj eto, assim como a
estrut ura e os re lac iona mentos do objeto. Um proj eto mostrar como ludo se encaixa.
Para ter esse entendimento, voc precisa identificar o que cada objeto faz. Existem dois aspectos
que voc precisa explorar para que possa responder pergunta, ' 0 que o objeto faz?"
Primei ro, voc precisa explorar a responsabi lidade. Atravs do encapsul amento, voc sabe
que cada objeto deve ter um nmero pequeno de responsabilidades. Dura nt e o projeto, voc
prec isa identi ficar as responsabilidades de cada objeto e dividira objelo. quando e le comear a
Dia 10
fazer coisas demais. Voc tambm precisa de que cada responsabil idade aparea
apenas uma vez e esse conhecimento espalhado igualmente entre todos os objetos.
Em seguida, voc precisa explorar o modo como cada objeto faz seu trabalho. Os objctos
qentemente delegaro trabalho para outros objelos. Atravs de seu projeto, voc precisa
fi car essas colaboraes.
Novo TERMO
Novo TERMO
Um objero delega trabalho para colaboradores.
Colaboracio o relacionamento onde os objetos interagem para realizar o mesmo
propsito.
Um entendimento profundo dos relacionamentos e responsabili dades de um objeto importante.
Em um nvel prtico, as responsabilidades sero transformadas em mtodos. Os relacionamen-
tos sero transformados em estruturas; entretanto, um entendimento global da responsabilidade
o ajudar a di vidir a responsabilidade eficientemente entre os objetos. Voc precisa evitar ter
um pequeno conjunto de objetos grandes. At ravs do projeto, voc ter a cert eza de dividir as
responsabi lidades.
o que so cartes CRC?
Uma maneira dc distribuir responsabilidades e colaboraes atravs cio lISO de cartes CRC (Classe
Responsabilidade Colaborao). Confonne o nome sugere, um carto CRC nada mais do que uma
ficha de arqui vo 4x6 com linhas.
Quando voc comea a projetar pela primeira vez, di ficil simplesmente comear a listar mto-
dos e atributos. Em vez disso, voc precisa comear a identifi car o propsito de cada objeto.
Os cartes CRC ajudam a definir o propsi to de um objeto, chamando a ateno para as respon-
sabilidades do obj eto. Quando usa cartes CRC, voc simplesmente cria um cart o para cada
classe. Voc escreve o nome da classe no incio do carto e, em seguida, divide o carto em duas
sees. Li ste as responsabilidades no lado esquerdo e, no lado direito, liste todos os outros obje-
tos que o carto precisa para executar suas responsabilidades.
A Figura 10.2 ilustra um modelo de carto CRC.
Os cartes CRC so intencionalmente de baixa tecnologia. Voc intencionalmente limitado
pelo tamanho do carto. Se voc achar que o carto no grande o sufi ciente, sil o boas as chan-
ces de que preciso dividir a classe. Uma grande vantagem dos cartes e RC que voc no fi ca
preso a um computador. Acredite se qui ser, ter de projetar diant e de um computador nem sempre
desejvel. O projeto no um exerccio solitrio e pode exigir conversas e di scusses ent re os
projet istas. Os cart es CRC liberam voc e seus colegas projet istas para projetar quando e onde
quiserem. Projete no almoo; v at uma sala de conferncia ou para um banco de parque. Desde
que possa usar seus cartes, voc pode projetar.
FIGURA 10.2
Um modelo tle
caruio CRC.
Introduo ao POO (Proje to Orientado a Objetos)
Nome da dasse
"'I'i:
-<I-
--
Responsabilidade
"-
CoI.bor.oos
Os cartes CRC tambm o liberam de ter de manter um modelo eJelrnica atualizado. Em breve
seu modelo mudar freqUentement e e ter de manter o modelo atualizado pode ser uma grande in-
convenincia. Em vez disso, voc simplesmente pega seus cartes e apaga, rabisca, dobra, escre-
ve e os rasga, quando necessrio. O custo de mudar um carto muito mais barato (e mais
imediato) do que ter de atua li zar algo em seu computador. Ter de parar a sesso de CRC e atuali-
zar um computador pode interromper o fluxo da sesso.
Finalmente, os cartcs CRC tm apelo em nossos instintos mais primiti vos. Eles apenas aj udam
a ler algo concreto que voc possa pegar. Em vez de ter de modelar vri os projetas alternativos,
voc pode apenas movimentar seus cart es. Para modelar int eraes, voc pode sentar-se com
outros prajetistas, dividir os cartes e percorrer as interaes. Tal processo interat ivo est imula a
discusso.
Como voc aplica cartes CRC?
A criao de cartes CRC no um exercicio solitrio. Em vez disso, voc deve manter sesses
CRC com outros projetistasldesenvolvedores, para que o processo de projeto seja o mai s int era-
tivo possvel.
Voc inicia uma sesso escolhendo vrios casos de uso. A quantidade que voc escol he depende
do tempo de que dispe e da dificuldade dos casos de uso. Se voc tiver alguns casos de uso mui-
to grandes, pode fazer sentido ter uma sesso por caso de uso. Se voc tiver muitos casos peque-
nos, vai querer atacar vrios casos de uso durante a sesso. O important e que voc manipule
casos de uso relacionados e que torne notvel o progresso em seu projeto. No pernlilaqueo pro-
cesso sofra empecil hos.
Quando voc escolher os casos de uso, ident ifique as classes principais e cri e um carto para
cada uma. Quando voc ti ver os cartes, divida-os entre os projeti stas e, em seguida, ini cie a ses-
Dia 10
so. Durante a sesso, voc investi gar o cenrio de cada caso de uso. medida que voc percor-
rer o cenri o, cada projeti sta dever se concentrar nas responsabilidades e colaboraes de sua
classe. Quando sua classe for necessri a no cenri o, notar seu liSO e di r a todos os outros proje-
ti stas se preci sa delegar para outro objeto.
A estratgia que voc adota para a sesso de projeto questo de preferncia pessoal. Algumas
metodologias exigem o desempenho do papel, onde cada projetista recebe um carto e represen-
ta o papel da classe. Out ras metodologias so um pouco mais formais. A estratgia escolhida fi ca
por sua conta e de sua equipe de projeto. O importante que todos fiquem engajados no processo
e que ningum fique excl uido. E durante essas sesses que voc di scut ir alt ernati vas de projeto,
descobrir novos objetos e construir a camaradagem na equipe.
Um exemplo de carto CRC
Vamos considerara caso de uso Pedido do Dia 9 e ver como voc poderia usarcartcs CRC para
atribuir responsabilidades para ele.
Pedido







O usuri o registrado passa para a totalizao e pagamento.
O usuri o registrado fornece informaes de ent rega.
O sistema mostra o total do pedido.
O usuri o registrado fornece infonnaes de pagamento.
O sistema autori za o pagamento.
O sistema confirma o pedi do.
O sistema envia um e-mail de confinnao.
Condies prvias
Um carrinho de compras no vazio.
Condies posteriores
Um pedido no sistema.
Alternativa: cancelar pedi do

Durante os passos I a 4, o usurio opta por cancelar o ped ido. O usurio volta para fi
home page.
Alt ernativa: a autorizao fal hou
No passo 5, o sistema falha em autorizar as informaes de pagament o. O usurio
pode introduzir novamente as infonnaes ou cancelar o pedido.
Comece ident ificando as classes. I mediatamente, voc ver: Usur i o Reg i s trado, Ped i do, Pa-
gamento, Confi nnao de Pedido, Carri nho de Comp ras, Infonnaes de Entrega. Talvez voc
tambm queira incluir Si s tema; entretanto, h um problema. Nos casos de uso, tudo que no foi
feito por um ator foi feito pelo sistema ' tudo incl udo'. O objetivo da anlise era entender o pro-
blema. Ento, em vez de tentar di vidir o sistema em suas partes, a anli se tratou como uma
grande caixa preta. Atravs do projeto, voc vai decompor o sistema em suas panes.
Introduo ao POO (Projeto Orientado a Objetos) 227
Se um carto de sistema vai ser incl uido ou no vai depender da complexidade do sistema. l)ode
ajudar listar todas as responsabilidades do sistema em um cano e, em seguida, divi dir esse car-
to em vrias classes, posteriorment e. Neste caso, entretanto, voc pode tentar decompor o siste-
ma, antes de comear. Sc voc se esquecer de algo, sempre pode acrescentar posteriormente.
Comece lendo os passos do cenrio. Aqui , o sistema autoriza o pagamento, exibe e confi rma o
pedido. O sistema tambm cria e introduz o pedido. Voc pode comear dividindo o sistema em
Funcionrio, Mostra Pedido e Terminal de Pagamento.
Quando voc se sentir confortvel com sua lista de classes, pode cri ar os cartes CRC, como
ilustrado na Figura 10.3.
FIGURA 10.3
Algl/l/:" dos cOr/ue:.' CRC
para Pedido.
-
.,w,., ... c
' ...
u_ ...... ,_
=l
o prximo passo percorrer cada passo do cenrio e identi fi car responsabilidades. O passo I, "o
usurio regist rado passa para a totalizao e pagamento", simplesmente um cl ique em um link
na interface. Por simplicidade, vamos ignorar a interface. O passo 2, "o usuri o registrado forne-
ce informaes de ent rega", um pouco mais interessante. Aqui, voc v que o Usu!rio Reg l s-
t rado responsvel por fornecer suas informaes de ent rega para o Funcion!rio.
A Figura 10.4 il ustra o carto resultant e.
FIGURA 10.4
O carl(io e RC de
Usu6rio Regi s trado.
Usu6rio Registredo
fomoce informaOes de n l r g ~ In lorma6e. de Entrega
NOTA
Dia 10
Quando voc ver que um objeto 'providencie' ou 'fornea' algo, precisar certi -
ficar-se de que o objeto no esteja atuando como uma simples est rutura de da-
dos.
Se o objeto no f i zer nada alm de fornecer acesso s informaes, voc dese-
j ar combinar esse objeto com o que manipula os dados.
o passo 3. "o sistema exibe o total do pedido''. um pouco mais complicado. Antes que o siste-
ma possa exibi r algo, o Funci onri o deve introduzi r o pedido, ver o preo dele e totalizar o pedido.
O Funcionrio usar o Carri nho de Compras para recuperar os itens e o Mostra Pedido para
bir o pedido resultante; entretanto, o Fune i onri o provavelmente no deve ser responsvel
bm por ver o preo ou por totalizar o pedido. Essas tarefas so melhores delegadas para outro
objeto. de que um objeto s deve ler um pequeno nmero de responsabilidades.
O objeto Ped i do deve cuidar de ver o preo e talai izar o pedido. A Figura 10.5 resume as
sabilidades do Funcionlirio at aqui.
O objeto Pedido tambm deve conter as it ens que esto sendo adquiridos. O objeto Item foi
norado durante a cri ao da lista de classes; portamo, voc deve adicion- lo agora. O objelo I tem
contm informaes de preo e produt o, assi m como uma quant idade. O objeto Item tambm
conter todos os incentivos que o usurio possa ter apl icado. I ncent i vo outra classe que voc
deve adi cionar na lista.
Os passos restantes so muito parecidos com os outros. O Usurio Registrado fornece infonna-
es de Pagamento, o Funcionlirio autoriza o pagamento e fina li za o pedido.
As fi guras 10.6e 10.7 resumem as responsabi lidades do Funcionrio edo Usurio Registrado.
FI GURA 10.5
O carl{io CRC
pafO Functom1r io.
funeionrio
recuperllnforma6es de In'rllla. pallamento
Introdu! o pedido
uibe o pedido
d. Entr80'
C'fflnho d. Comp,"
Pedido
Mo",. Ptilldo

Introduo ao POO (Projeto Orientado a Objetos)
229
FIGURA 10.6
O Cl/rlaO CRC para
Funcionl'irio cOlI/plelo.
Funclon6rlo
llK:upera informaes de entrega e pag,mento
introduz o pedido
exibe O pedido
autori .. o pedido
confirma o pedido
Quantas responsabilidades por classe?
InfOfma6e* d.
ea" inho de Compras

Mostre Pedido
Terminal de P'g.mento

Ao desenvolver seus cartes CRe, voc precisa garantir que cada classe tenha apenas duas ou
trs responsabilidades principais. Se voc tiver mais responsabil idades, dever dividi r a classe
em duas ou mais classes separadas.
AL.ERTA
Voc deve consi derar a diviso da classe, mas em si stemas reais, isso no
necessariamente real i sta.
FIGURA 10.7
O C(lrf(io CRC IXlra
Usul'irlo Registrado.
Usu6rio Registrado
101'11_ inlormll6l1 de emr"'ll'
fome inlormll6.s da PIIIamenlO
cIt Entteg.
Pag.mento
--I
Pegue a classe Funcionrio, por exemplo. O Func ionrio responsvel por:


Recuperar infonnaes de pagamento e entrega .
Introduzir o pedido .
I 230 Dia 10
Exibi r o pedido.
Autorizar o pagament o.
Confi rmar o pedido.
Confonne a Figura 10.8 ilustra, ent retanto, todas essas responsabilidades caem sob a responsabi -
lidade de ' Processa Pedido'.
FIGURA 10.8
Processa Pedido.
Funcionrio
r.,;upe .. informa6e. de en!<eGl e ~ m e n t a
introdu. a pedido
exibe a pedido
autoriza o pedido
conllrma a pedido
Uw'rio Roogimado
C.urinha d, Compr
Padldo
Proce_ Pedido
Moerr. Pedido
Terminal de P.Ol menta
Pedido
importante li star subtarefas; entretanto, voc no quer fazer isso em demasia. O important e
que todas as sub-responsabil idades trabal hem para um objeti vo comum. Aqui, todas as tarefas
trabalham para o processament o de um pedido.
Ao trabalhar com cartes CRC. voc tambm precisa lembrar que eles atendem um propsitoes-
pecfico: defi ni r responsabi lidades e relac ionamelllos de colaborao simples. No use cartes
CRC para desc rever relacionamentos complexos.
Voc tambm deve manter os cartes CRC com bai xa tecnologia - no tente automati zar o pro-
cesso de carto CRC.
Limitaes do carto CRC
Assim como toda boa ferramenta, os cartes CRC tm seus usos, bem como suas limitaes.
Os cartes CRC foram desenvolvi dos originalmente como uma ferramenta de ensino. Como re-
sultado, eles so uma manei ra excelente de encarar o projeto inicial de um sistema - especial-
mente se voc for iniciant e em 00.
Entretant o, os cartes CRC so di ficcis de usar quando o projeto se toma mais compli cado. Pode
ser di ficil controlar interaes complexas ent re os objetos, si mplesment e at ravs do uso de car-
tes CRC. Um grande nmero de classes tambm toma o uso de cartes desajei tado. Tambm
Introduo ao POO (Projeto Orientado a Objetos)
pode se tornar dificil continuar a usar cartes CRC, quando voc comear a modelar. Manter os
dois em sincronismo pode ser um desafio.
O melhor conselho usar o que runciona. Use cartes CRC at que eles no mais auxiliem o pro-
cesso de projeto. Nesse momento, simplesmente pare de us- los.
DICA
auando voc deve usar cartes CRC?
Durante os est gios iniciais do projeto.
auando voc ainda iniciante em 00.
Para descobrir responsabilidades e colaboraes.
Para percorrer um cenrio. No apenas os cartes encontraro responsa-
bilidades e colaboraes, como pOdem ajud-lo a ent ender melhor o ce-
nrio.
Em projetas menores ou para se concentrar em uma seo menor de um
projeto grande. No tente atacar um projeto inteiro com cart es CRC.
Passo 3: desenvolva os pontos de interao
Quando tiver completado seus cartes CRC para um conjunto de casos de uso, voc preci sar
desenvolver os pontos de interao. Um ponto de interao qualquer lugar onde um objeto use
Out ro.
Novo TERMO Um pomo de imera(;o qualquer lugar onde um objeto use outro.
Existem vrios problemas a considerar sobre o pont o de interao.
Interfaces
Voc precisa de uma interrace bem definida, onde um obj eto usa Outro. Voc qucr ter certeza de
que uma alterao em uma implementao no v danificar o outro objeto.
Agentes
Voc tambm precisa ver as interaes de forma crt ica. Pegue uma biblioteca, por exemplo.
Uma bibli oteca tem prateleiras e livros. Quando hora de tirar um livro da prateleira, o livro cha-
ma um mtodo removeBook() na prateleira ou a prateleira que chama um mtodo removeBook ()
no livro? Na verdade, a responsabi lidade no pertence ao livro ali prateleira. Nenhuma das es-
colhas modela adequadamente o mundo real. No mundo real, uma bi bliotecria ou um cliente re-
tirar o li vro. As bibliotecrias e os clientes tambm podem aparecer no mundo 00; entretanto,
o mundo 00 chama esses atares de agentes ou intermedirios.
Novo TERMO Um agellle faz a mediao elllre dois ou mais objelos para atingir algum objetivo.
Ao desenvolver pont os de interao, voc desejar prestar ateno em lugares para usar agentes.
Dia 10
Consideraes futuras
Ao considerar as interacs, voc desejar procurar lugares onde o objcto que est sendo usado
possa mudar. Se voc puder local izar tais lugares com preciso, desejar projetar a interao de
tal maneira, que ela no ser desfeita caso novos objetos sejam introduzidos. para planejamen-
to de mudana que serve sofiware prova do futuro. Em tais lugares, voc desejar estabelecer
relacionamentos com capacidade de conexo e usar polimorfismo, para que possa introduzir no-
vos obj etos a qualquer momento.
Assim como em tudo, entretanto, no faa isso em demasia. Planeje a alterao apenas em luga-
res onde voc saiba com certeza absoluta que ocorrer uma mudana. Existem duas maneiras ge-
rais de prever o futuro:


A alterao um requisito. Se os requisitos solicitarem alteraes futuras, projete a alte-
rao.
Se voc est iver usando uma biblioteca de terceiros e quiser migrar para uma nova verso
de forma transparente no futuro, planeje a alterao.
O primeiro caso melhor resolvido pelo estabelecimento de algum tipo de relacionamento com
capacidade de substituio, atravs de herana. O segundo requer um pouco mais de trabalho.
Voc desejar empacotar a biblioteca em classes que criou. Voc deve tomar o cuidado de pro-
jetar esses empacotamentos para tirar proveito da capacidade de conexo e do pol imorfi smo.
Transformao de dados
Durante o projeto, voc pode encontrar lugares onde precisa transformar dados, ant es de pas-
s-los para outro objeto. Normalment e, voc delegari a tal transformao de dados para outro ob-
jeto; se precisar alterar a transformao, voc s precisar atualizar a classe de transformao.
Essa prtica tambm ajuda a dividir responsabi lidades.
Ao considerar esses pontos de interao e adicionar novas classes, talvez voc precise rever e
atuali zarseus cartes CRC ou modelo de obj etos (se voc tiver iniciado a modelagem formal).
Passo 4: detalhe os relacionamentos entre os objetos
Quando voc tiver estabeleci do os relacionamentos de responsabilidade e colaborao bsicos,
precisar detalhar os relacionamentos complexos entre as classes. E a que voc define as depen-
dncias, associaes e generalizaes. Detalhar esses relacionamentos Ulll passo importante,
pois isso define como os objetos se encaixam. Isso tambm define a estrut ura interna dos vrios
objetos.
Comece com os cartcs CRC. Embora eles no capturem cada relacionament o, eles capturam a
colaborao. Eles tambm vo sugerir alguns outros relacionamcntos.
Procure classes que compartilhem responsabili dades semelhantes. Se duas ou mais classes com-
partilham o mesmo conjunto de responsabilidades, so boas as chances de que voc possa contar
Introduo ao POO (Projeto Orientado a Objetos)
com as caractersti cas comuns em uma classe base. Voc tambm desejar rever o passo 3 e con-
siderar todos os relacionamentos com capacidade de substit uio que poderi a preci sar.
Passo 5: construa seu modelo
Quando chegar ao passo 5, voc j ter modelado o sistema fonnal mente. Um modelo completo
consistir em diagramas de classe e diagramas de interao. Esses di agramas descrevero a estru-
tura e o relacionamento das vrasclasses do sistema. A UML tambm define modelos para mooe-
lar interaes, transio de estado e atividades. Para os propsitos deste livro, entretanto, voc vai
se concentrar nos diagramas de classe e interao. Voc viu os dois ti pos em di as anteri ores.
A Figura 10.9 modela a estrutura Pedido.
O modelo Pedido ilustra todos os relacionamentos importantes entre Pr:dido e as classes que exi-
bem o pedido. Concebivelmente, voc tambm ter modelos que ilustram os relacionamentos
entre Func ion.! r io, Pedi dos e Usur i o Registrado.
Novamente, voc quer apenas modelar o que faz os componentes arquitetnicos inte-
ressantes. Lembre-se de que voc est tentando transmitir informaes especficas atravs de
seus modelos e no simplesment e apresentar modelos por questes de documentao.
A Figura 10. 10 ilustra o diagrama de seqncia atua li zado para o caso de uso Pedido.
FIGURA 10.9
MOI/elo Pedido.

, ,
-
Voc tambm pode criar diagramas de seqncia e colaborao para modelar as intcraes im-
portantes do sistema.
Quando tiver terminado de criar os modelos, voc dever ter descri es de todas as principais es-
truturas e int craes encontradas no sistema. Esses modelos dizem como os vrios objetos esto
estruturados, como eles se relacionam e como eles se encaixam para modelar a soluo do pro-
blema elaborado durante a an li se,
FIGURA 10.10
Diagrama de
seqiilla de
Pedido.
Resumo
Dia 10
~ ~ . ' , .. ,..!
,
", I..,),
o POO continua o trabalho da AOO, pegando o domnio e transformando-o em uma soluo
para seu problema. Atravs do processo de POO, voc pega seu modelo de domnio e constri o
modelo de objetos de sua soluo. O modelo de objetos descreve os aspectos arquitetonicamente
significati vos de seu sistema, como a estrutura e os relacionamentos dos objetos - como os obj e-
tos se encaixam. No fi nal do POO, voc dever ter uma boa idia do que implementar no cdigo.
A grosso modo, existem cinco passos iterativos que voc pode segui r, enquanto reali 7..a o POO:
Passo I: gerar a li sta de objetos inicial.
Passo 2: refinar as responsabilidades de seus objetos atravs de cart es CRC.
Passo 3: desenvolver os pontos de inlerao.
Passo 4: detalhar os relacionamentos entre os objetos.
Passo 5: construir seu modelo.
Cada passo refina mais seu modelo de objetos e o deixa mais prximo da cpia heliogrfica de
seu sistema.
Perguntas e respostas
P Por que importante projetar o sistema antes de comear a codificar?
R Existem varios fatores que tornam o projeto importante. O projeto o aj uda a prever pro-
,
blemas de implementao, antes de comear a codifi car. E muito mais fcil corrigi r um
problema em um modelo do que percorrer todo seu cdigo para corri g-Io.
Introduo ao POO (Projeto Orientado a Objetos)
O projeto tambm garante que todos os desenvolvedores de uma equipe de desenvolvi-
mento estejam na mesma pgina. O projeto esclarecer muitas das suposies arquitet-
nicas important es que, de outro modo, teriam sido decididas durant e o desenvolvimento.
Deixando as decises arquitetnicas para o momento da implementao, voc corre o
risco de ter cada desenvolvedor tomando suas prprias decises incompatveis.
fi t)or que importante modelar seu projeto antes de comear a codificar?
R Modelar importante pelo mesmo motivo que a maioria das pessoas redige lima palestra
antes de proferi -la. Modelando o projeto, voc pode ver corno as partes se encaixam.
Tendo urna idia visual do projeto, voc pode decidir se est confortvel com ele. Voc
pode verificar se tudo se encaixa de fonna tranqila e sensata.
,
As vezes, a soluo de um problema parecer simples, quando voc pensar a respeito
dela. Pegar a soluo e escrev-Ia formalmente o obri ga a ser int electualmente honesto
quanto a soluo. Ter de transformar fonnalmente um problema o obriga a pensar de for-
ma crti ca e exata sobre a soluo. O que parece simples em sua ment e pode faz-l o ar-
rancar os cabelos, ant es de voc tenninar!
P Como voc sabe quando seu projeto est concludo?
R No existem regras rgidas e rpidas que indiquem quando um projeto est tenninado. Se
voc se preocuparem ter um projeto perfeito, poder cai r facilmente na paralisia do projeto.
Tudo se resume ao que voc est tentando transmitir atravs de seus modelos, seu nvel
de experincia c o nvel de experincia de sua equipe. Se voc tiver uma equipe experi en-
te, provavelmente poder apenas modelar a arquitet ura de alto nivel do sistema. Se voc
Oll os membros de sua equipe so iniciantes nos objetos, provavelmente desejaro passar
mai s tempo projetando. De qualquer modo, voc termina quando se sente confiante o su-
ficiente de que pode pegar o projeto e implementar a soluo.
O processo de desenvolvimento 00 iterativo. Voc deve usar isso para seu proveito e
fazer as iteraes para obter sua arquitetura final.
Workshop
As perguntas e respostas do teste so fornecidas para seu melhor entendimento. Veja as respos-
tas no Apndice A, 'Respostas".
Teste
I. Quais so as trs vantagens de um projeto fonnal ?
2. O que Projeto Orientado a Objetos - POO?
3. O que c modelo de objetos?
4. Quais so os inconveni entes do projeto em demasia?
Dia 10
5. Como voc sabe quais aspectos de seu sistema so arqllitetollicamente sigllificativos?
6. Quais so os cinco passos bsicos do POO (Projeto Orientado a Objctos)?
7. Como voc gera a lista de objetos inicial?
8. O que um proj eto completo captura?
9. O que os cartes CRC o aj udam a ident ificar?
10. O que uma colaborao?
I I. Por que um entendimento profundo dos relacionamentos e responsabi lidades de um ob-
jeto import ant e?
12. O que um cart o CRC?
13. Descreva um moti vo pelo qual os cm1cs CRC so intencionalmente de baixa tecnologia.
14. Quando voc deve usar cartes CRC?
15. Qual um problema importante dos cartes CRC?
16. O que ponto de interao?
1 7. Quais so as quatro consideraes que voc pode fazer em relao a um ponto dc interao?
18. O que um agente?
19. O que voc far quando detalhar os relacionament os complexos entre os objetos e por
que isso importante?
20. Qual tipo de modelos voc poderia cri ar?
Exerccios
I. No Dia 9, Exercicio 2, voc desenvolveu o seguinte caso de uso:
Remove item
O usurio convidado seleciona um item do carrinho de compras.
O usurio convidado soli cita ao carrinho para que remova o item.
Condies prvias
O carrinho contm um item para remover.
Condies posteriores
O item no aparece mais no carrinho.
Al ternativa: Operao cancelada
O usuri o pode optar por cancelar a transao, aps o Passo I.
Para melhorar suas habilidades, use cart es CRC para descobrir as responsabilidades. Quais res-
ponsabilidades o Carrinho de Compras ter?
SEMANA 2
DIA
Reutilizando projetos atravs de
padres de projeto
No captulo de ontem, voc viu como o projeto orientado a objclos o ajuda a projetar uma solu-
o para um problema. Atravs do POO ( Projeto Orientado a Objclos), voc constri uma cpia
hel iogrfica que diagrama os objclos que compreendem seu sistema. Uma vez que tenha esse
projeto, voc pode comear a implementar sua soluo.
Entretanto, voc provavelmente tcm algumas perguntas.




Como voc sabe que o seu projeto um bom projeto?
Seu projeto ler conseqncias imprevisveis no futuro?
Como outros projel islas resolveram esse problema ou um problema semel hante no passado?
E quanto reutili zao? A POO (Programao Orientada a Objclos) fornece reutili zao
de cdigo, mas o POO ( Projeto Orientado a Objetos) permite reutilizao?'
Este captulo o ajudar a responder essas perguntas e mui to mais. quando voc explorar o assun-
to 'padres de projeto' .
Hoje voc aprender:
Corno usar padres de projeto
Corno aplicar quatro padres comuns
I. N.R.T.: Usaremos o POO p..1ra Projcto Ori entado a Objetos e a 1'00 para Programallo Oricntada a
Objclos
238 Dia 11
Como um projeto pode ti rar proveito do uso de padres
Como evitar uma annadi lha de padro comum
Reutilizao de projeto
Um objet ivo important e da POO a reutilizao de cdigo. Quando reuti li za cdigo, voc ganha
tranqUi lidade, sabendo que seu software est construdo em uma base de cdigo confivel e tes-
tada. Alm disso, voc sabe que o cdigo reutilizado resolver seu problema. Taltranqili dade
enquanto voc programa tima, mas e quant o tranqUi li dade enquanto projeta? Como voc
sabe se seu projeto bom?
Feli zment e, os padres de projeto podem ajudara dirimir muitas das dvidas que voc encontra-
,
r ao projetar. A medida que o tempo passa, muitos projetistas e programadores tm notado que
os mesmos element os de projeto aparecem repetidamente em todos os seus projetas. A comuni-
dade de 00 resolveu identificar, nomear e descrever esses conceit os de projeto recorrentes. O
resultado uma li sta sempre crescente de padres de projeto.
Novo TERMO Um padrfla de projeto um conceito de projeto reut ilizvel.
Veri fi ca-se que voc pode reutil izar padres de projeto em todo o seu projeto, exatamente como
se voc reutilizasse uma classe dentro de seu programa. Essa reutilizao traz as vantagens da re-
ut ilizao da POO (Programao Orientada a Objetos) para o POO (Projeto Orientado a Objc-
tos). Quando usa padres de projeto, voc sabe que baseou seu projeto em proj etos confiveis e
comprovados pelo uso. Tal reutil izao permite que voc saiba se est na trilha certa para uma
sol uo confi vel. Quando voc reuti liza um padro de projeto, est usando um projeto que ou-
tros usaram com xito, muitas vezes ant eri ormente.
Padres de projeto
O li vro Desigll Pallems - Elell/ents of Remab/e Objecl-Oriellled Software, de Gamma, Helm,
Johnson e Vli ssides, apresentou pela primeira vez o conceito de padres de projeto para muitos
na comunidade de 00. Esse trabalho de base no apenas definiu um conjunto de padres de pro-
jeto reutilizveis, mas tambm definiu formalmente o padro de projeto.
De acordo com esse trabalho, um padro de proj eto consiste em quatro elementos:
O nome do padrilo
O problema
A soluo
As conseqUncias
Reutilizando projetas atravs de padres de proj et o 239
o nome do padro
Um nome identi fi ca exclusivamente cada padro de projeto. Assim como a UML fornece uma
linguagem de projeto comum, os nomes dos padres fornecem um vocabulrio comum para des-
crever os element os de seu projeto para out ros. Outros desenvolvedores podem entender seu
projeto rpida e faci lmente, quando voc usa um vocabul ri o comum.
Um simples nome reduz um problema inteiro, a soluo e as conseqncias a um nico termo.
Assim como os objetos oaj udam a programarem um nvel mais alto e abstrato, esses termos per-
mitem que voc projete a partir de um nvel mai s alto e abstrato e no fique preso aos detalhes
que se repetem de um projeto para outro.
o problema
Cada padro de projeto existe para resolver algum conjunto distinto de problemas de projeto e
cada padr.l0 de projeto descreve o conjunto de problemas para o qual foi fei to para resolver. Des-
se modo, voc pode usar a descrio do problema para determinar se o padro se apli ca ao pro-
blema especi fi co que est enfrentando.
A soluo
A sol uo descreve como o padro de projeto resolve o problema e identi fica os objetos arquite-
tonicamente significati vos na soluo, assim como as responsabilidades e relacionamentos que
esses objetos compartilham.
NOTA
importante notar Que voc pode apli car um padro de projeto a uma cl asse
inteira de problemas. A soluo uma sol uo geral e no apresenta uma res-
posta para um problema especfico ou concreto.
Suponha Que voc Quisesse encontrar a melhor maneira de percorrer os itens
do carrinho de compras do captulo 10, " Introduo ao POO (Projeto Orientado
a Objetos )". O padro de projeto Iterator prope um modo de fazer justamente
isso; entretanto, a soluo apresentada pelo padro Iterator no dada em ter-
mos de carrinhos de compras e itens. Em vez disso, a sol uo descreve o pro-
cesso de varredura de qual quer li sta de el ementos.
Quando voc comear a usar um padro de projeto, deve mapear a sol uo
geral para seu probl ema especifico. s vezes, pode ser difrci l fazer esse mapea-
mento; entretanto, o prprio padro de projeto preci sa permanecer genrico
para que permanea apl icvel a muitos problemas especifi cos diferentes.
As conseqncias
No existe um projeto perfeito. Todo bom projeto ter bons compromissos e todo compromisso
assumido ter seu prprio conjuntoespeial de conseqncias. Um padro de projeto enumerar
as principai s conseqUncias inerentes ao projeto.
Dia 11
As conseqncias no so novidades. Voc assume compromissos sempre que opta entre duas
alternat ivas ao programar. Considere a diferena entre usar um array e lIsar uma li sta encadeada.
Um array proporciona pesquisa rpida pelo ndice, mas funciona muito lentamente, quando voc
precisa reduzir ou expandir o array para inserir ou excl uir elementos. Por outro lado, a lista enca-
deada proporciona rpidas adies e excl uses, mas tem uma sobrecarga de memri a maior e
pesquisas de ndice mais lent as. Aqui , as conseqncias de uma li sta encadeada so a sobrecarga
de memria e as pesquisas mais lentas. A conseqncia de usar um array O fat o de que o redi -
mensionamento do array dispendioso, mas as pesquisas indexadas so muito rpidas. O que
voc escolhe depende da importncia da memria e da velocidade em seu projeto, se voc vai
fazer muitas adies e excluses de elementos e se vai fazer muitas pesqui sas.
sempre importante documentar suas deci ses de projeto, assim corno as conseqncias resul-
tantes. Ter essas decises documentadas ajuda os outros a entender as escolhas que voc fez e a
determinar se o projeto pode ajudar a resolver seus prprios problemas. Do mesmo modo, as
conseqUncias do padro de projeto pesaro bastante em sua deci so de usar o padro. Se um pa-
dro de projeto tem conseqncias que no correspondem aos objetivos de seu projeto, voc no
deve us-lo - mesmo que ele possa resolver seu problema.
Realidades do padro
Quando voc comea a aprender sobre padres, importante saber o que eles podem e o que no
podem fazer. As listas a seguir podem ajudara manter corretas as intenes por trs dos padres.
Os padres so:






Projetos reutilizveis que provaram funcionar no passado.
Solues abstratas para um problema de projeto geral.
Solues para problemas recorrentes.
Um modo de construi r um vocabulrio de projeto.
Um regiSlro pblico da experincia do projeto.
Uma soluo para um problema.
Os padres no so:




Uma soluo para um problema espec fi co.
A resposta mgica para todos os seus problemas.
Uma muleta, voc mesmo ainda precisa fazer seu projeto funci onar.
Classes concretas, bibli otecas, solues prontas.
Padres por exemplo
Existem mui tos livros que catalogam os padres de projeto. No h moti vo para repetir fonnal -
mente esses catlogos aqui; ent retant o, existe um conjunto de padres de projeto que voc en-
Reutilizando projetas atravs de padres de proj et o 241
contrar quase que diariamente. Nenhum texto introdutri o sobre 00 ser completo sem
apresentar esses padres para voc.
Em vez de apresentar csses padres ronnalmente, vamos adotar uma est ratgia mais informal,
atravs de exemplo.
Hoje, este captulo apresentar trs padres importantes:
Adaplcr
Proxy
lterator
o padro Adapter
o Captulo 4, "Herana: obtendo algo para nada", apresentou o conceit o de relacionamentos
com capacidade de subst ituio. O Captulo 6, "Polimorfismo: aprendendo a prever o futuro",
mostrou como voc pode usar esses relacionamentos para adicionar novos objelos em seu siste
ma a qualquer momento. Quando voc usa herana para definir capacidade de substituio, en-
tretanto, seus objetos podem se tornar restri tos pelas hi erarqui as resultant es. Para poder se
conectar com seu programa, um objeto deve fazer parte da hierarquia com capacidade de substi-
tuio.
Ento, o que voc faria se quisesse conectar um objeto em seu programa, mas ele no pertences-
se hierarquia correta? Uma soluo seri a pegar a classe que voc quisesse usar e, em seguida,
edit-Ia para que ela herde da classe correta. Essa soluo no 6ti ma por alguns moti vos.
Nem sempre voc ter o cdigo-fonte das classes que deseja usar. Alm disso, sc essa classe j
usar herana, voc ter problemas se sua linguagem no suport ar herana mltipla.
Mesmo que voc tenha o cdigo-fonte, simplesmente no e prtico ou razovel reescrever um
objeto cada vez que voc quisesse que ele fi zesse parte da hierarq uia ' correta'. A definio da hi-
erarquia 'correta' mudar para cada programa. Se voc tiver uma classe razoavelmente abstra-
da, no desejar fi car editando sempre que qui ser reut il iz-Ia. Em vez disso, voc deve
si mplesmente uti I iz-la inalt erada. Reescrev-Ia a cada vez anula os propsitos da reutil izao e
da abstrao. Se voc fi car criando edi es especiais de uma classe, podero restar muitas clas-
ses redundantes para ma nter.
O padro Adapter apresenta uma soluo alternativa que resolve o problema da incompat ibilida-
de, transformando a interface incompatvel naquela que voc precisa. O padro Adapter funcio-
na empacotando o objeto incompati vel dentro de um objeto adaptador compativel. O objeto
adaptador contem lima instncia do objeto e expe o objeto atravs da interface que se encai xa
em seu programa. Como a classe adaptadora empacota um objeto, s vezes esse padro referi-
do como padro Empacotador.
Novo TERMO Um adaptador um objelo que lransfonna a interface de outro obj eto.
Dia 11
Implementando um adaptador
A Figura 11 . 1 resume a hierarquia MoodyObject apresentada no Captulo 7, "I>olimorfismo: hora
de escrever cdigo".
FIGURA '1 .1
ii hicl'(lI'(fllitl
MoodyObject.
r.yd'liootn.tOb;.c:t
..... mln. (ob) , M<XkIyObject)
Happ'j'ObjlCt
getMQOd (): Suing
M ~ I
.. qu.ryModd ( I
I f1fIlMood I J; StrlllQ
*
C.,ef,lHObJICt
S ~ C t
'getMood (): Str ing 'gtlMood II: Sning
Psychi atri stObject 56 pode exami nar um objeto se for um MoodyObject. O mtodo exami nc()
de Psychi atri stObject depende do mtodo queryMood() de MoodyObject. Qualquer outro tipo
de objelo precisar encontrar um psi quiatra diferente.
A Figura 11.2 apresenta a nova hierarquia Pet.
FIGURA " .2
~
ii hierarquia Pet.
..1/1Uk ( 1; SlrinQ
00,
'"
BI,d
.. apeek ( ) : Sning .. apeek II : String lpe.k I ) : Snlng I
Cada Pet fala de sua prpria maneira especializada e fornece sua prpria implementao de speak ().
Ento, qual o problema?
Hoje em dia, at animais de esti mao vo ao psiquiatra. mas o objeto Psychi at ri stObject no
pode examinar um Pet porque um Pet no um objelo MoodyObject. Para que o objelo Psychia-
tristObject possa examinar um Pet ,voc precisar criar um adaptador Pet.
A Li stagem 11. 1 apresenta um possvel adaptador Pet.
Reutilizando projet os atravs de padres de projeto
LISTAGEM 11.1 PetAdapter.java
public class PetAdapt er extends MoodyObject (
}
private Pet pet;
publlc PetAdapter( Pet pet ) {
this.pet pet:
}
protected String getMoodO {
}
II i mplementando apenas porque exigido por
II MoodyObject . como tambm sObrepe queryMood.
II nAo preci samos di sso
return pet.speak( ):
publ ic yold queryMoodO {
System. out . println( getMood{) }:
}
243
o PetAdapter empacota uma instncia de Pet. Em vez de expor a interface Pet, o adaptador
oculta essa interface atrs da interface MoodyObject, basicameme transformando a interface de
Pel. Quando chega um pedido no PetAdapter, o adaptador delega para a instncia de Pet, confor-
me for necessrio.
A Listagem 11 .2 mostra o adaptador cm ao.
LISTAGEM 11.2 Usando o adaptador
PetAdapter dog new PetAdapter( new Dog () ) ;
PetAdapter cat .. new PetAdapter( new CatO );
PetAdapter bird new PetAdapter( new Bird() ) :
PsychiatristObject psychiatrist .. new PsychiatristObject{):
psychiatrist . examlne( dog }i
psychiatrist.examine( cat };
psychiatrist.examine( bird );
Uma vez empacotada, a instncia de Pet se parece com qualquer outro MoodyObject para o obje-
to Psychi a tri s tObject. Essa sol uo mais eficiente do que as al ternati vas, pois ela exige que
voc escreva apenas uma classe adaptadora. Essa classe adaptadora pode mani pular qualquer
objeto Pet que aparea. A parte complicada garantir que o PetAdapter empacote todas as ins-
tncias de Pet, antes que voc passe o objeto Pet para o objeto PsychiatristObject.
Dia 11
A implementao fornecida anteri ormente chamada de adapt ador de obj eto, pois o
adaptador usa composio para transfor mar a interface de uma instncia. Voc tam-
bm pode impl ementar um adaptador atravs de herana. Tal adaptador conhecido
como adaptador de classe, pois ele adapta a prpria definio da classe.
Se sua linguagem suporta heranas ml t iplas, ent o voc sempre pode herdar da clas-
se que deseja usar, assim como de uma classe da hi erarquia.
Se sua linguagem no tem herana mltipla, como Java, suas escolhas podem ser li-
mitadas, dependendo de como a hierarquia foi construrda. Na verdade, talvez voc te-
nha de se privar da herana totalmente e usar composio, no ponto em que tambm
pOderia cr iar um adaptador de objeto_
Embora a herana ml tipl a funcione, essa soluo limitada. Criar uma nova subclas-
se para cada classe que voc quiser usar pode levar a uma proliferao inaceitvel em
classes empacotadoras.
Cada estratgia tem sua prpria limitao. Um adaptador de classe s funcionar para
a classe que herda. Voc precisar de um adaptador separado para cada subclasse.
Do mesmo modo, embora um adaptador de objeto possa funcionar com cada subclas-
se, voc precisar de subclasses do adaptador, se quiser mudar a maneira como ele
empacota vrias subclasses.
Quando usar o padro Adapter
o padro Adapter lt il quando voc quer usar um objeto que tem uma interface incompatvel. O
padro Adapter permite que voc reutili ze diretamentc objetos que, de outro modo, precisaria al-
terar ou jogar fora.
Os adaptadores tambm so lteis no sentido de uma ao preventi va. De tempos em tempos,
voc precisar empregar bibliotecas de terceiros em seus programas. Infelizmente, as APls das
ferramentas de terceiros podem variar substancialmente entre as verses, especialmente para no-
vos produtos ou para tecnologias que esto amadurecendo. As APl s tambm podem variar bas-
tante em relao s bibliotecas de um produt o concorrente.
O padro Adaptcr pode ajudar a evitar que seu programa tenha que trocar de APl s e que fi que
preso ao fornecedor. Criando uma interface adaptadora que voc controla, possvel trocar para
novas verses de urna bibli oteca a qualquer momento. Basta criar uma subclasse do adaptador
para cada biblioteca que voc queira usar.
Tambm important e notar que um adaptador pode ser si mples ou complicado e o nvel de comple-
xidade depende do objeto que est sendo empacotado. Alguns adaptadores se resumem si mplesmen-
te a mapear um pedido para o mtodo correto. Outros precisar.10 realiz,:'lr mais processamento.
Use o padro Adapter, quando:
voc quiser usar objetos incompatveis em seu programa;

voc quiser que seu programa permanea independent e de bibliotecas de terceiros .
A Tabela 11. 1 destaca o usurio do padro Adapter.
Reutilizando projetos atravs de padres de proj eto 245
TABELA 11.1 O padro Adapter
Nome do podrf()
Problema
Solullo
ConseqUlnc ias
o padro Proxy
Adapter, Wrapper
Como reut ilizar objetos incompatveis
Fornecer um objeto que converta a interface incompatvel em uma com-
patvel
Tomar incompatveis objetos compatveis; resulta em classes extras -
talvez muitas - , se voc usar herana ou precisar manipul ar cada sub-
classe de uma fonna diferente
Normalmente, quando um obj eto quer interagir com outro, ele faz isso atuando diretamente so-
bre o outro objeto. Na maiori a dos casos, essa estratgia di reta a melhor estratgia, mas existem
ocasies em que voc desejar controlar o acesso entre seus objetos de forma transparente. O pa-
dro Proxy trata desses casos.
Publicao/assinatura e o padro Proxy
Considere o problema de um servi o de eventos publicao/assinatura onde um objeto vai regis-
trar seu interesse em um evento. Quando o evento ocorrer, o publ icador noti l1car os objetos as-
sinantes do evento.
A Figura 11 .3 ilust ra um possvel relacionamento publicao/assinatura.
FI GURA 11.3
Um re/lIdol/lImemo
pllblica(io/assilwlllm.
h..,te ....... tot
,egl.C" UI.um : lIscene. l:
publistle.
. "boe.lboo.
I.ht..,.

, eceiV<lEV<lnt ( .... ent : Evenll:
Na Figura 1 1.3, muitos L i steners registram seu interesse nos eventos gerados por um EventGe-
nerator. Quando o EventGenerator gerar um evento, ele colocar o evento em cada um de seus
objetos Usteners.
Embora essa soluo fu ncione, ela coloca uma grande carga sobre o EventGenerator. O Event -
Generator no tem apenas a responsabil idade de gerar eventos, como tambm responsvel por
controlar todos os l i s teners e colocar os event os neles.
o padro Proxy apresenta uma soluo elegante para esse problema. Considere a Figura 11 .4.
Em vez de conter seus Listener s diretamente, o EventGenerator pode conter um Listener-
Proxy. Quando o gerador precisa disparar um evento, ele o dispara uma vez para o proxy. Ento,
fica por conta do proxy controlar e atualizar todos os l ; stener s.
Dia 11
FIGURA 11.4
AtNJ,,_u.r_
UlI/lI solutio proxy.
/ .... 111 : E..."f / :
I
u.....-
I
.--1...,E...,nr ( _nr : ev"nt ):
Subse.jl)e.
, ,
Publ illhlr


Subserlbe.
Ev.ntG. n ... ror
Utt.., ..
,egllr .. , (ilor .. n .. , : USl8ne. I :
, _iveEv.nr I.venl: Evem I:
o padro Proxy geral
o cenri o publicao/assi nat ura descreve um possvel uso para um proxy; entretanto, voc pode
usar proxies em muitos lugares.
Primeiro, o que um proxy?
Um proxy um substituto ou lugar reservado que intermedia o acesso ao objeto de int eresse real.
Voc pode usar um proxy em qualquer lugar onde preci se de um substilUto ou lugar reservado
para outro objeto. Em vez de usar um objeto di retamentc, voc usa o proxy. O proxy cuida de to-
dos os detal hes da comunicao com o objeto (ou objetos) real.
Novo TERMO
intennedia.
Um proxy um substituto ou lugar reservado que interrnedia o acesso ao objeto de
interesse real. Para todos os efeitos, o .mbstitullI indistinguivel do objeto real que
Um substituto intermedia o acesso a um objeto (ou objetos) subjacente de forma transparente.
Voc pode considerar um subst ituto como um modo de enganar seus objetos. Por exemplo, en-
quanto o EventGenerator pensa que est se comunicando apenas com um Li stener, o Li ste-
nerProxy pode, na verdade, di vul gar a mensagem para muitos objctos Listeners diferentes.
Poder enganar seus objetos uma capaci dade importante, pois ela permite que voc realize to-
dos os tipos de mgica nos bastidores. Um substituto pennite que voc coloque responsabili-
dades nele, sem ter de incorporar essas responsabilidades no usurio do substituto. Mais impor-
tante, seu substituto pode executar todas essas responsabili dades sem que os outros objetos sai -
bam o que voc est fazendo.
Reutilizando projetas atravs de padres de proj et o 247
As responsabilidades que voc pode colocar no substituto so infi nitas; ent retanto, o uso co-
mum incl ui adicionar otimi 7.acs, realizar tarefas de limpeza, fazer recursos remotos parecerem
locais e adiar operaes dispendiosas.
Ouando usar o padro Proxy
Use subst itut os quando:
Voc quiser adiar lima operao dispendiosa. Considere um objeto que extrai informa-
es de um banco de dados. Embora seu programa talvez precise saber ri respeito dos 01>-
jetos que pode extrair, ele no precisa extrair todas as informaes at que realmente
acesse o objeto. Um substituto pode representar o objeto real e carregar as informaes
extras quando elas forem necessrias.
Outro exemplo um substit uto de arquivo, que permite gravar em um arquivo, mas que
apenas reali za a operao de Entrada e Sada no arquivo real, quando voc j tiver term ina-
do. Em vez de fazer vrias gravaes lentas, o substituto far uma nica gravao grande.
Voc quer proteger de fomm transparente o modo como um objeto usado. A maioria dos
objetos mut ante, como as classes da linguagem Java. Um substituto protetor poderia tor-
nar uma coleo de classes imutvel, interceptando pedidos que de outro modo al terariam
uma coleo de classes. Filtrando todas as chamadas de mtodo atravs de um substituto,
voc pode governar de fomla transparente as operaes permitidas sobre um objeto.
O objeto real existe remotamente, atravs de uma rede Oll processo. Os substitutos so im-
portantes para a computao distribuda. Um substituto pode fazer com que um recurso
distri budo parea como se fosse um recurso local , encaminhando os pedidos atravs de
uma rede ou atravs de um espao de processo.
Quando voc quer executar aes adic ionais de forma transparente, ao usar um objeto. Por
exemplo, talvez voc queira contar o numero de vezes que um mtodo chamado sem que
o chamador saiba. Um substituto de contagem poderia controlar a acesso a um objelo.
A Tabela 11 .2 destaca o usuri o do padro Proxy.
TABELA 11.2 O padro Proxy
Nome do padro
Problema
Soluo
Conseqncias
Proxy, Surrogale
Precisa controlar o acesso a um objcto
Fornecer um objeto que intennedie o acesso a outro objeto de fomla
transparente
Introduz um nvel de procedimento indireto no uso do objeto
o padro Iterator
Os padres de projeto freqUentemente descrevem solues para problemas comuns. Quando
voc programa, so boas as chances de que v gastar muito tempo escrevendo cdigos que fa-
Dia 11
zem laos (Ioops) sobre objetos de uma hierarquia. Conforme voc aprendeu no Captulo 8
" Introduo UM L", o relacionamento entreobjetos uma agregao. O todo contm partes.
A Listagem 11.3 apresenta um mtodo conhecido que faz um lao sobre o contedo de um mao
de cart as (uma coleo) e constri lima representao de caracteres do mao.
LISTAGEM 11.3 Fazendo um lao sobre o contedo de um monte de cartas
public String deckToString( Deck deck ) I
String cards .. "" ;
I
for( i nt i '" O: i < deck.sizeO ; i ++ ) I
Card ca rd .. deck.get( i };
cards .. cards + card.display( );
I
return cards:
Suponha que voc quisesse fazcr um lao sobre um array de cartas. A Listagem I 1.4 mostra o
mtodo que pode manipular justament e esse caso.
LISTAGEM 11.4 Lao sobre o contedo de um ar ray
publiC String deckToString( Card [] deck ) I
String cards .. "";
I
for( int i .. O: i < deck.length; i ++ ) (
cards .. cards + deck (i) .displ ay();
I
return cards ;
Finalmente, e se voc quiser fazer um lao sobre o mao de cartas na ordem inversa? Voc preci-
sar adicionar um OUl ro mtodo. A Listagem 1 1.5 mostra um mtodo que faz um lao sobre o
mao na ordem inversa.
LISTAGEM 11.5 Lao sobr e o contedo de um mao de cartas na ordem inversa
public String reverseDeckToString( Deck deck ) (
I
String cards .. "":
for( int i .. deck.sizeO - 1: i > -1; i - ) I
Ca rd card = deck.get( i);
cards .. cards + card.display();
I
return cards ;
Reutilizando projetas at ravs de padres de projeto 249
Se voc lembrar das I ies sabre acoplamento e responsabil idades, dever ouvir uma voz em sua
mente, gritando, "Cdigo ruim!" Sempre que voc quiser fazer um lao sobre urna coleo de
cartas, precisar adicionar um mtodo que sai ba como fazer um lao sobre esse tipo de coleo
especfico. Na verdade, a lgica no to diferente assim de um caso para outro. Os nicos ele-
mentos que mudam so os mtodos e atri butos que voc acessa na coleo. Agora voc v um
alerta: cdigo repet ido.
O problema que cada um dos mtodos li stados anteriormente dependente da implementao
da coleo, como um Oeck ou um Array. Quando programa, voc sempre quer garant ir que no
fique acoplado a li ma implementao especfica. O acoplamento torna seu programa resistente
mudana.
Pense a respeito. O que acontecer se voc quiser mudar a coleo que contm suas cartas? Voc
precisar atualizar ou adicionar um novo mtodo que faa o lao. Se voc no tiver sorte, simples-
mente mudar a implementao da colco poderia necessitar de alteraes por todo o seu programa.
NOTA
Embora um nico objet o possa conter apenas um lao, seu programa intei-
r o provavelmente vai repetir os laos muitas vezes, em muitos lugares dife-
rentes.
Outro problema com esses exemplos provm do fato de que os mecanismos de navegao esto
,
codificados no mtodo. E por isso que voc precisa de um mtodo para o lao para frente e outro
para o lao inverso. Se voc quiser fazer um lao aleatoriamente pelas cartas, ento precisar de
um terceiro mtodo (e um para cada tipo de coleo). Voc no preci sar apenas de vrios mto-
dos, como tambm precisar implementar novamente a lgica de navegao, sempre que definir
um lao. Infelizmente, tal duplicao de lgica um sintoma de responsabilidade confusa. A l-
gica de navegao deve aparecer em um e apenas um lugar.
Feli zmente, o padro Itera to r resolve muitos dos problemas de forte acoplamento e confuso
de responsabi lidade, colocando a lgica do lao ou iterao em seu prpri o objeto.
A figura 11.5 ilustra a interface Iterator.
FIGURA 11 .5
II illfeljace Iterator.
/ter.for
+ fim fi ." voId
+nufll."WJId
+ ;,Don" ( J : boalH"
+ ( J .. ObjtlCf
I
A interface 1 terator fornece uma interface genrica para iteragir sobre uma coleo. Em vez de
escrever seus laos e mtodos para usar uma coleo especfica, voc pode si mplesmente pro-
gramar a interface genri ca do I terator. A interface Iterator oculta completamente a imple-
mentao da coleo subjacente.
NOTA
Dia 11
A l inguagem Java define uma interface i teradora ligeiramente di f erente:
Java .utll .1 terator. o I terator Java define apenas trs mtodos: pub li c boo-
lean hasNeJl.t(). publlc vold remove() e public Obj ect neJl.t{).
A interface Java Iterator per mite que voc faa uma i terao apenas em uma
di reo. Ao chegar ao f im. voc no pode vol tar para o inicio. Fora essa def i
cincia, a interface Java Iterator semel hante quela apresentada anterior-
mente.
Ao escrever programas Java, voc deve usar Java. ut i 1 .1 terator para que ou-
t ros programas Java possam usar suas implement aes do Iterador. Para os
propsitos deste livro. ent retanto, esta lio continuar sendo verdade para a
defi nio do Iterado r clssica fornecida na Figura 11.5.
A Listagem 11.6 apresenta um mtodo al ternat ivo deckToString (), que faz lao sobre urna ins-
tnc ia de Iterator.
LISTAGEM 11.6 l ao sobr e o contedo de uma i nstncia de Iterator
publi c Stri ng deckToString( Iterator i ) {
String cards " "";
}
for ( i. f i r st() ; !i.isOoneO ; i.nextO ) I
Card card (Card) i.current l tem() ;
cards cards + card.displ ay() ;
}
return cards ;
Apenas porque um objeto passa de volta um iterador, no significa que o objelo realmente anna-
zena seus itens dent ro do iterador. Em vez disso, um iterador dar acesso ao contedo do objeto.
Existem trs vantagens de usar um iterador para percorrer uma coleo.
Primeiro, um iterador no O vincular a uma coleo especfica. Todos os mtodos origi nais fariam
lao sobre implementaes especficas da coleo. Corno resul tado, cada mtodo di feriria ape-
nas nos mtodos que chama na coleo. Se esses mtodos fi zessem um lao sobre um iterador,
como na Listagem 11 .4, voc s6 precisaria escrever um mtodo deckToStr i ngO.
Segundo, o iterador pode retornar seus element os em qualquer ordem que achar conveni ente.
Isso significa que uma implementao do iterador poderia retornar os elementos em ordem. Ou-
tro iterador poderia retornar os elementos na ordem inversa. Usando um iterador, voc pode es-
crever a lgica de navegao uma vez e razer com que ela aparea em apenas um lugar: no
prprio iterador.
Final mente, um iterador torna simples mudar a coleo subjacente, quando isso for necessrio.
Como voc no programou para uma implementao especfica, pode trocar para uma nova co-
leo a qualquer momento, desde que a coleosaiba como retornar uma instncia de I terator .
Reutilizando projetos atravs de padres de projeto 251
Implementando um Iterado r
A mai oria das colees Java j d acesso a um iterador. Por exempl o, a li oked-
l 1st usada internamente pelo objeto Deck j tem um mtodo iterat or() que re
t orna um Java. ut i 1 . I t erator; ent retanto, i sso ajuda a ver uma impl ementao
de iterador real e esse padro no especf ico da linguagem Java. Assim, ig.
nore o mtodo 1 terator() de linkedli st da li nguagem Java por uns instant es.
A Listagem 11.7 mostra uma implementao de Ilerator que permi te ao usuri o percorrer os ele-
mentos de uma coleo LinkedList.
LISTAGEM 11.7 Uma implementao de Iterator
publ i C class Forwardlterator implements Iterator {
pr;vate Object [] items;
}
}
private int index :
publ iC ForwardIterator( java.util.Linkedl1st items ) (
this.items items . t oArray():
}
publ iC bool ean isDone() (
}
if( index items .length ) I
return true ;
}
return fal se :
publi c Object currentItem() I
if( !isDoneO ) I
return items [index l:
}
return null:
}
public voi d next()
I
if( !isDoneO ) (
i ndex++:
}
publi c voi d firstO
I
index ,. O:
}
Dia 11
Outra implementao poderia fornecer uma iterao inversa (veja o cdigo-fonte completo, para
um exemplo disso).
A Listagem I J.8 ilustra as alteraes que voc precisar fazer em Deck para que possa retomar
um hernIaL
LISTAGEM 11 .8 Uma classe Oeck atualizada
public class Deck (
I
private java.util . UnkedUst deck ;
publiC Deck() {
buildCa rdsO;
I
public Iterator itera torO (
return new ForwardIterator{ deck );
I
II reduzido por brevidade
Alternativamente, totalmente vli do, do ponto de vista da 00, consi derar um it era-
dor como uma extenso da coleo a que el e d acesso. Como resul tado, voc tem al -
gumas outras opes de implementao.
A linguagem Java possibilita uma construo conhecida como classe interna. Uma
classe interna uma classe definida dentro de outra classe. Como a cl asse interna de-
finida dentro de outra classe, ela tem total acesso a todos os mtodos pblicos dessa
classe, assim como aos mtodos protegidos e privados, e s variveis internas. A ana-
logia mais prxima na linguagem C++ uma classe friend. friend fornece acesso es-
pecial a outro objeto confivel.
fcil abusar da cl asse friend e da classe interna, pois elas podem destruir o encapsu-
lament o facilmente; entretanto, um iterador realmente faz parte da coleo. A lista-
gem 11 .9 mostra uma implementao de classe interna do Iterator da classe Deck.
LISTAGEM '1.9 Uma impl ementao de Iterator de classe interna
public class Oeck {
private java.util.LinkedList deck;
publ ie DedO {
buildCardSO;
I
publ ic Iterator HeratorO {
I
I
Reutilizando projetos atravs de padres de projeto
return new ForwardIterator();
I
l/reduzido por brevidade
private class Forwardlterator implements Iterator {
int index;
publiC boolean isDoneO {
I
II note que a classe interna tem acesso
II liberado varivel interna deck de Deck
if(index deck.sizeO ) (
return true;
I
return false:
publiC Object currentItem() {
if( !i sDoneO ) (
return deck .get( index ) ;
I
return null;
I
publiC void next() {
if( !isDoneO) (
i ndex++ ;
I
I
public void first() {
index a O'

I
253
Dia 11
Quando usar o padro Iterator
Existcm vrias razcs para se usar o padro llerator:





Voc podc usar um il erador quando quiser ocultar a implementao de uma coleo.
Voc pode usar um iterador quando quiser fornecer diferentes tipos de laos sobre uma
coleo (como lao para frente, lao inverso, lao filtrado etc.).
Voc pode usar um iterador para manter a interface de lima coleo si mples. Voc no
preci sar adicionar mtodos para ajudar a fazer o lao sobre o contedo. Basta deixar os
usurios do obj eto utilizarem um iterador.
Voc pode defi nir uma classe de coleo base que retome um itcrador. Se todas as suas
colees herdarem dessa base, o iterador pennitir que voc trate todas as suas colees
genericamente. Na verdade, java.ut i l.Collecti on faz j ustamente isso. Essa utilizao
tambm a forma geral do padro Iterator. O exemplo Deck uma verso abreviada do
padro I t erat or. A classe Oeck no herda de uma classe de coleo base abstrata; assim,
voc no pode trat-Ia generi camentc.
Os iteradores tambm so lIteis para fornecer acesso otimizado s colees. Algumas es-
truturas de dados, como a tabela hashing, no fornecem um modo otimi zado de fazer a
iterao sobre os elementos. Um iterador pode fornecer lal ordenao, ao custo de um
pouco de memria exlra. Entretanto, dependendo de seu aplicativo, a economia de tempo
pode mais do que compensar a sobrecarga de memria.
A Tabela 11 .3 destaca o usurio do padro lterator.
TABELA 11.3 O padro Iterator
Nome do padro
Problema
SOluo
Conseq6ncias
It erator, Cursor
Fazer lao sobre uma coleo sem se tornar dependente da implement a-
o da coleo
Fornecer um objeto que manipule os detalhes da iterao, ocultando as-
sim os detalhes do usurio
Navegao desacoplada, interface da coleo mais simples, lgica de
lao encapsul ada
Apossando-se de um padro
Alguns padrcs so mais dificeis de ent ender do que outros; entretanto, a complexidade pode ser
enganosa. Antes de poder aplicar ou mesmo pensar sobre a alterao de um padro, voc preci sa
entender o padro: em outras palavras "apossar-se dele". Existem alguns passos que voc deve
dar para poder domi nar um padro:
I. Leia o padro.
2. Leia o padro novamente, prestando bastante ateno nos princi pais participantes e no
exemplo de cdigo.
Reutilizando projetos atravs de padres de projeto 255
3. Pratique a implementao do padro.
4. Aplique o padro cm um problema real.
Quando voc ti ver concludo esses quatro passos, provavelment e ter um ent endimento total do
padro. Neste ponto, voc pode comear a alterar o padro de acordo com as necessidades espe-
cficas de seu problema; ent retant o, voc no deve tentar aument ar um padro com o qual ainda
no esteja familiarizado.
Resumo
Os padres de projeto so uma ajuda til ao projetar suas solues. De sua prpria maneira, os
padres so a conscincia coleti va da comunidade de 00, que tem anos de experi ncia de proje-
to. Os padres de projeto podem fornecer diretrizes valiosas durante o proj eto.
Voc precisa ter cm mente os limites dos padres de projeto, quando os utili zar. Um padro de
projeto lrata de um problema abstraiO e de apenas um problema. Um padro de projeto no for-
nece a soluo para um problema especfico. Em vez disso, o padro fornece uma soluo abs-
trata para um problema geral. Fica por sua conta fornecer o mapeamento entre o problema
abstrato e seu problema especfico.
Mapear um padro de proj eto provavel mente o maior desafi o que voc enfrentar enquanto

usar padres. E uma habi lidade que vem apenas com o tempo, estudo e prtica.
Perguntas e respostas
P A linguagem Java usa padres?
R Sim, muitas das APls Java empregam padres. Na verdade, cada um dos padres que
voc leu a respeito hoje cst representado na linguagem Java. Aqui est uma li sta brcvc
dos padres que voe viu:
Iteralo)": as classes Java Collection
Proxy: RMI da linguagem Java
Adapte)": usado amplamente por receptores de evento
P Todos os padres so traduzidos para todas as linguagens?
R No. Cada linguagem diferent e. Alguns padres so impossveis de implementar em
certas linguagens, enquanto outros so desnecessrios, devido aos recursos internos da
linguagem.
Dia 11
Workshop
As perguntas e respostas do teste so fornecidas para seu melhor entendimento. Veja as respos-
tas no Apndice A, "Respostas".
Teste
I. o que uma classe adaptadora?
2. Qual problema o padro Iterator resolve?
3. Por que voc usaria o padro lterator?
4. Qual problema O padro Adapter resolve?
5. Por que voc usaria o padro Adapter?
6. Qua l probl ema o padro Proxy resolve?
7. Por que voc usaria o padro Proxy?
8. Considere a sit uao a seguir; qual padro voc usaria e por que?
A Sun Microsystems, IBM e Apache fornecem bibl iotecas para analisar documentos
XML. Voc optou por usar a bi blioteca Apache em seu aplicativo XML. No futuro, con-
tudo, voc poderia optar por usar um fornecedor diferente.
9. Considere a situao a seguir; qual padro voc usaria e por que?
Voc deve escrever um aplicati vo que recupere dados de um armazm de dados baseado
,
em arqui vo. As vezes, seu aplicati vo ser executado de forma local e poder acessar o ar-
mazm de dados at ravs de meios diretos. Outras vezes, o cli ente ser executado de for-
ma remota e precisar se comunicar com um servidor para ler o armazm de dados.
10. O padro Adaptertransfonna lima interface. O padro Proxy altera a interface de um objeto?
Exerccios
I. As 1 istagens I I. \ o c I \. I \ apresentam uma classe de carrinho de compras e uma classe
de item. A Listagem 11.12 apresenta uma interface it erator. Use essas defi ni es para
cri ar um ilerator que permita fazer a iterao pelo conteudo do carrinho de compras.
LI STAGEM 11.10 ltem. j ava
publl c class I tem {
prlvate i nt
pr; vate i nt
private fl oat
i d;
quantity;
unit_pr icc ;
Reutilizando projetos atravs de padres de projeto
LISTAGEM 11.10 Item.java (continuao)
private String description;
private float discount;
r
* Cria um novo item com a quantidade. preo.
descrio e desconto por unidade dados.
@param id a id do produto
* @param quantity o nmero de itens selecionados
* @param unit prlce o preo com desconto anterior
* @param description a descrio do produto
* @param discount o valor em dlar a ser subtrado por item
. /
public Item( int id . int quantity. float unit_price. float discount .
String desc) {
}
this.id id;
this.quantity quantity;
this.unit_price ~ unit_price;
this.discount discount;
this.description desci
r
@return int a quantidade do item
. /
pubhc int getQuantityO {
return quantity;
}
r
* @param quantity a nova quantidade
./
public void setQuantity( int quantity ) {
this.quantity ~ quantity;
}
r
* @return o preo u n t ~ r o do item
./
public float getUnitPriceO {
return unit_price;
}
r
* @return float o preo total do item menos todos os descontos
. /
257
Dia 11
LISTAGEM 11.10 Item.java (continuao)
J
publiC float getTotalPrice() I
return ( unit_price * quantity ) - ( discount * quantity ) ;
J
,u
* @return String a descrio do produto
"
public String getOescription() I
return description;
J
,u
* @return int a id do produto
"
public int getID() I
return 1d ;
J
LISTAGEM 11.11 ShoppingCart.java
public class Shoppi ngCart {
java.uti l. linkedList items = new java.util.linkedlist();
'U
* adiciona um item no carrinho
* @param item o item a adicionar
"
public void addItem( Item item) {
items.add( item );
J
,u
* remove o i tem dado do carrinho
* @param item o item a remover
"
public void remove Item ( Item item) {
items.remove( item );
J
,u
* @return int o nmero de itens no carrinho
"
public int getNumber Items() I
return items.size();
J
Reutilizando projetos atravs de padres de proj eto 259
LI STAGEM 11.11 ShoPPlngCart . java (continuao)
}
1
* recupera o item indexado
* @param index o f ndice do item
* @ret un Item o item no indice
<I
public Item getItem( int index) {
return (Item) items.get( index ) ;
}
LI STAGEM 11.12 lterator . java
publi c interface Iterator {
publ ic voi d first() ;
}
publ ic voi d next();
publ i c boolean isDone() :
publ ic Dbject currentltem();
2. O Pe tAdapter, apresent ado anteriormente no captulo, est limitado a apenas empacotar
uma instncia de Pe t . Altere o adaptador de modo que voc possa mudar o objeto que ele
empacota, a qualquer momento.
Por que voc desejaria um adaptador mutant e?
Respostas do teste
I. Uma c lasse adaptadora transforma a interface de um objeto em uma interface esperada
por seu programa. Um adaptador contm um objeto e delega mensagens da nova interfa-
ce para a interface do objeto cont ido.
2. O padro Iterator descreve um mecani smo para fazer laos pelos element os de uma coleo.
3. Voc usaria o padro Iterator para conter lgica de navegao cm um lugar, para fornecer
um modo padronizado para percorrer colees e para ocultar do usurio a implementa-
o da coleo.
4. O padro Adapterdescreve um mecanismo que permilea voc transformar uma interface
de objetos.
5. Voc usari a o padro Adapter quando precisasse uti li zar um objeto que ti vesse uma in-
terface incompatvel. Voc tambm pode usar empacotadores preventivament e, para
isolar seu cdigo das alteraes de APls.
Dia 11
6. O padro Proxy intennedia de fonna transparente o acesso a um objeto. Os proxies adicio-
nam um procedi ment o indireto para uso de objetos.
7. Voc usari a o padro Proxy sempre que quisesse intennediar o acesso a um objeto de
uma maneira que uma referncia simples no permitisse. Exemplos comuns incl uem re-
cursos remotos, oti mizaes e limpeza de objeto geral, como contagem de referncia ou
reunio de estatsticas de utilizao.
8. Nessa situao, voc pode usar o padro Adapter para criar uma interface independente daque-
la fornecida pela Sun, IBM ou Apache. Cri ando sua prpria interr.1ce, voc pode pennanecer
independente da APl li geiramente diferente de cada fornecedor. Empacotando a bibl ioteca,
voc est livre para trocar de bibl ioteca a qualquer momento, seja para migrar para uma nova
verso ou para trocar de fornecedor, pois voc controla a interfce do <Idaptador.
9. Nessa situao, voc pode usar o padro Proxy para ocultar a ident idade do objeto arma-
zm de dados com que seus objetos se comunicam. Dependendo da local izao do clien-
te, voc pode instanciar um proxy interligado em rede ou um proxy local. De qualquer
modo, o restante do programa no saber a diferena; portanto, todos os seus objetos po-
dem usar uma interface proxy sem terde se preocupar com a implementao subjacente.
10. O padro ])roxy no altera uma interface, no sentido de que ele no retira nada dela.
Entretanto, um proxy est livre para adicionar mais mtodos e atributos na int erface.
Respostas dos exerccios
I.
LISTAGEM 11.13 ShoppingCart.java
publiC class ShoppingCart {
java.util.LinkedList items new java .ut il .LinkedLis t O;
r
* adiciona um item no carr inho
* @param item o item a adicionar
./
publ ic void addItem( Item item ) {
items. add ( item) ;
I
r
* remove o item dado do car rinho
* ~ p r m i tem o item a remover
. /
public void removeltem( I tem item) (
items .remove ( item );
Reutilizando projetos atravs de padres de projeto
LISTAGEM 11.13 ShoppingCart . java (continuao)
}
}
/ ..
* ~ r t u r n int o nmero de itens no carri nho
. /
publi c int getNumber Items() I
return ltems . size();
}
/ ..
* recupera o item indexado
* @param index o lndice do item
* @retun Item o item no ndice
./
public Item getItem( int index) {
return (Item) items.get( index );
}
publ ic Iterator iteratorO {
}
II ArrayLi st tem um m todo i terator() que retorna um iterador
/1 entretanto, para propS itos de demonstrao, ajuda ver um iterador
simples
return new Cart I terator ( items );
LISTAGEM 11.14 Cartlterator.java
public class Cartlterator implements Iterator {
private Object [] items;
private int index;
publiC CartIterator( java.util .LinkedList items ) (
this.ltems items.toArray{);
}
publ iC boolean isDoneO (
if(index >- items.length ) {
return true ;
}
return fal se ;
}
public Object currentItemO (
i f( !isDoneO ) {
261
Dia 11
LI STAGEM 11.14 Ca rtIterator. java (continuao)
}
return items [index] :
}
return null;
}
publ i c vo1d nextO I
i ndex++;
}
publ iC void first() I
index O;
}
2. Tornando o adaptador mutante, voc pode usar o mesmo empacotador para empacotar
muitos objetos difcrentes e no precisa instanciar um empacotador para cada obj eto que
precise ser empacotado. A reutilizao de empacotadores faz melhor uso da memria e
I ibera seu programa de tcr de pagar o preo da instanciao de muitos empacotadores.
LISTAGEM 11.15 Mu tableAdapter. j ava
pu bl ic class MutableAdapter extends MoodyObject I
private Pet pet :
}
publl c Mutabl eAdapter ( Pet pet ) {
setPet ( pe t ):
}
protected St ri ng getMoodO (
}
II implementando apenas porque exi gido por
II MoodyObject . como tambm SObrepe queryMood
II no prec i samos dele
return pet . spea k():
public yoid queryMood() {
System. out.pr intln( getMood() ) ;
}
public void setPet ( Pet pet ) {
t hi s.pet pet :
}
SEMANA 2
DIA
Padres avanados de projeto
No captulo de ontem, voc viu como os padres de projeto pennitem reutili zar projetas testa
dos. Hoje, voc continuar seu estudo de padres de proj eto, exami nando mais trs padres.
l-laje voc aprender:
Sobre trs importantes padres de projeto
Corno garantir que seus objelos permaneam nicos
Como aprimorar um exemplo anterior
A respeito de algumas annadilhas comuns de padro que voc deve evitar
Mais padres por exemplo
Vamos continuar nosso estudo sobre padres de projeto, considerando trs padres importantes:
Abstract Factol')'
Singlelon
Typesafe Enum
Cada um desses padrcs aparece cm quase todos os projetas. Na verdade, voc pode usar opa
dro Typesafe Enurn para corrigir um exemplo do Captul o 3, "Encapsulamento: hora de escre-
ver algum cdigo! "
264 Dia 12
o padro Abstract Factory
o Captulo 7, " Polimorfis mo: hora de escrever algum cdigo", mostrou como voc pode combi-
nar herana e pol imorfi smo para escrever software ' prova de futuro'. Os relacionamentos com
capacidade de conexo da herana, combinados com o polimorfismo, permitem que voc comx:-
te novos objelos em seu programa, a qualquer momento; entretanto, h um inconveniente.
Para que seu programa possa instanciar esses novos objetos, voc deve entrar no cdigo e alie-
m-lo para que ele instancie os novos objetos, em vez dos ant igos. (E voc precisar fazer isso em
todos os lugares onde os obj elos ant igos so instanciados !). No seria timo se houvesse um
modo mais fcil de coneclar seus novos objetos?
O padro Abstract Factory resolve esse problema atravs da de legao. Em vez de instanciar oh-
jetos atravs de seu programa, voc pode delegar essa responsabilidade para um objeto chamado
jaclory. Quando um objeto precisar criar outro, ele soli cita r que o factory faa isso. Usando um
factol)', voc pode isolar toda a criao de objeto em um (mico local. Quando voc preci sar intro-
duzir novos objetos em seu sistema, s precisar atualizar o factory. para que ele cri e uma instn-
cia de Sllas novas classes. Os objetos que usam o factory nunca sabero a diferena.
A Figura 12. 1 ilustra o projeto geral do padro Abstracl FaCIOI)'.
FIGURA 12.1
4 bsll..,lfeaory
O padnio Abslracl FaclOIy.
factoryMethodA 4 J : A
factortMethod8 { J : 8
eo.....-Feetorv1
c o nc,.,.Fect0<y2
fectoryMethodA 41: A .. foctoryMethodA { ) : A
feetoryMe1hod8 {): B foctoryMethodB rI: B

.. ',,,,:>
,
/
\
"
"
cnoe, .. >:>
A
..
1/


Padres avanados de projeto 265
o padro Abslracl Faclory usa herana e capacidade de conexo. A classe base de faCI OI)' defi-
ne todos os mtodos de criao de objcto e cada subclasse factol)' defi ne quais objetos cri a, s0-
brepondo os mtodos.
Implementando um Abstract Factory
Existem ocasies em que voc precisar usar bibliotecas de tercei ros dentro de seu programa.
Infelizmente, quando hora de migrar para uma nova verso, voc pode veriricar que as APls
pblicas das bibli otecas mudaram li geiramente. Felizmente, o padro Abstract Factol)' oferece
uma soluo que torna lranqi la a migrao da bibli oteca.
Imagine que voc esteja traba lhando em um projeto que usa um analisador XML. Um ana li sador
XML receber um document o XM L como String e retornar uma representao de objeto do do-
cumento, conhecida como Oocument. Se voc sabe que vai atuali zar a bibl ioteca no futuro e que a
APl vai mudar, existem alguns passos que pode dar para se proteger.
XML
XML, ou Extensible Markup Language, uma linguagem para escrever tags que des-
crevem dados. Assim como a HTML oferece tags para formatar e exibir seus dados, a
XML permite que voc def ina suas prprias tags personalizadas para descrever o sig-
ni ficado conceituaI de seus dados.
A HTMl uma maneira excelente de marcar dados para exibi o. Entretanto, a HTMl
no tem a capaci dade de transmitir o signi fi cado dos dados. A HTML pode dizer para
que voc col oque negrito em uma palavra, mas no pode dizer que a palavra negritada
o ttul o do documento. Em vez disso, voc precisa aplicar esse significado externa
mente ao documento.
Por outro lado, a XML fornece um mecanismo que permite dizer que alguma palavra
em um documento um ttul o. Se voc usar essas tags para marcar seus dados, dife
rentes programas podero ler seus documentos e saber o que significa cada dado.
Assim, por exemplo, voc pode escrever um programa que sabe formatar titulos com
negrito. Ou ent o, voc pode escrever outro programa que l uma lista de documentos
e formula uma lista de ttulos para sua sel eo. Tentar escrever os mesmos programas
para ler um documento HTML seria muito mais difcil.
Nos ltimos anos, a XMl se tornou um padro importante para a troca de dados. Duas
entidades no relacionadas podem se comuni car, desde que ambas entendam as tags
XMl. Como resultado, a XMl tem aparecida como o padro para comunicao entre
empresas. Para comprar e vender, duas empresas podem concordar com um conjunto
de tags comuns. Uma vez que tenham essas l ags, elas podem trocar documentos XML
l ivremente.
Considere o seguinte documento XML de uma receita:
<Recipe>
<Name>Chlc ken Tacos<j Name>
<Ingredient s>
<Ingredi ent>
<Name>Chlc ken<j Name>
Dia 12
<Quantity UOM" lb ">I<j Quantity>
<j lngredi ent>
<! - cortado por brevidade - >
<j lngredi ents>
<j Rec i pe>
Esse documento XML tem tags que descrevem os dados de uma recei ta. Se voc en-
tende a marcao de tag, sabe que os dados que esto entre as tags <Name> represen-
tam o nome da receita. Todos os dados que esto entre as tags <Ingredi ents> contm
informaes de ingredientes.
Voc pOde escrever programas que reconhecem a marcao Rec i pe. Um programa po-
deria permitir que voc selecionasse receitas que gostaria de fazer durante uma sema-
na. Esse programa poderia usar os documentos Recipe que voc escolhesse para
formular e imprimir uma li sta de compras. Outro programa poderia imprimir o menu
da semana.
Para que um programa l eia e entenda um documento XML, ele deve anali sar o docu-
mento. Um analisador de XMl pegar um documento e o converter em uma rvore
de objetos. Cada objeto conter parte do documento. Seu programa pode simples-
mente percorrer esses objetos para extrair informaes do documento. Assim, se voc
escrever um programa que lei a receitas, ele poder percorrer todos os obj etos Ingre-
di ent para construir uma lista de ingredientes.
Atualmente, muitos analisadores de XML esto disponvei s para escolha. Cada anali-
sador tem uma APl ligeiramente diferente, de modo que, uma vez que voc escreva
um programa para usar um analisador especifi co, poder ser dificil trocar de analisa-
dor posteriormente. O padro Abstract Factory apresenta uma maneira de evitar que
voc fique preso ao uso de um analisador em particular.
Novo TeRMO
Um (II /(Ifisador de X/odL pega um documento XML e o transfom18 em uma represen-
tao de objelo.
Inicialmente, voc precisa empacotar o analisador em um objeto que controle.
NOTA
Lembre-se de que um empacotador um adaptor. Um empacotador converte
a interface de um objeto em uma interface alternativa. Normalmente, voc usa
um empacotador para converter a interface em uma interface esperada por
seu programa.
Como voc controla a APl do empacotador, garante uma APl estvel que seu programa pode
usar. A Li stagem J 2. J ilustra um possvel empacotador analisador.
LISTAGEM 12.1 Parser . java
public interface Parser (
publ ic org.w3c. dom. Oocument pa rse( String document );
I
Padres avanados de projeto 267
NOTA
org.w3t.dom.Dotument uma interface def inida pel o W3C para representar um
documento XMl como uma estrutura de obj etos. Voc pode encontrar mais
informaes sobre a interface Document no endereo http: //'rMW . w3 .org/ TRI
2000/CR-DOH-level - 2- 200D0510/ java-binding.html.
As li stagens 12.2 e 12.3 mostram duas possveis implementaes: Vers ionOneParser, que usa a
verso 1.0 da biblioteca, e Vers ionTwoParser, que usa a verso 2.0 da bi blioteca.
LISTAGEM 12.2 Vers i onOneParser .java
public class VersionOneParser implements Parser {
I
publi C org.w3c.dom.Oocument pa r se( Str i ng document ) (
II instancia a verso 1 do anal isador
I
II XMlParser p new XMl Parser{) ;
II passa o documento para o anal i sador e retorna o resultado
II return p.parseXML( document ) ;
LI STAGEM 12.3 VersionTwoParser.java
public class Vers i onTwoParser impl ements Pa r ser I
I
public org. w3c.dom.Oocument parse( String document } I
II instancia a verso 2 do anal isador
I
II OOMParser parser new DOMParser(} ;
II passa o documento para o anal isador e retorna o resultado
II return parser . pa r se( document };
Seu programa pode usar o padnlo Abslract Factory para cri ar a verso correta do anal isador, sempre
que ele precisar anali sar um documento. A Listagem 12.4 apresenta a interface base de faclol)'.
LI STAGEM 12.4 ParserFactory.java
public interface ParserFactory I
publ ic Parser createPar ser() ;
I
Voc precisar de duas implementaes concretas de factory, pois existem duas implementa-
es do analisador. As li stagens 12.5 e 12.6 apresentam essas implemcnlacs.
Dia 12
LISTAGEM 12.5 VerslonOneParserFactory.java
publl C class VerslonOneParserFactory implements ParserFactory I
public Parser createParser () I
return new VersionOneParser();
}
}
LISTAGEM 12.6 Vers i onTwoPa rserFactory .java
public class VersionTwoParserFactory implements ParserFactory (
publi c Parser createParser() {
return new VersionTwoParser();
}
}
Agora, em vez de instanciar anali sadores diretamente, seu programa pode usar uma das classes
factory para recuperar objetos analisadores, quando precisar anal isar um documento. Voc pre-
cisar simplcsmente instanciar a factory correta no incio do programa e torn-Ia disponvel para
os objetos de seu programa.
o padro Factorv Method est intimamente relacionado ao padro Abstracl Fact ory.
Na verdade, um Abstract Factory pode usar Factory Method para criar os objetos que
retorna.
Um mtodo Fact ory nada mais do que um mtodo que cria objet os. createParser()
um exemplo de mtodo Factory. Voc tambm pode encontrar exempl os de mtodos
Factory em toda a APl Java.
Class.newlnstance() um exemplo de mtodo Factory.
Conforme voc pode ver, um mtodo Factory pode aparecer em uma classe normal ou
em uma Factory abstrata. Em qualquer caso, ele cri a objetos, ocultando assim a classe
real do objeto criado.
Quando usar o padro Abstract Factory
Use o padro Abstract Factory, quando:
Voc quiser ocultar o modo como um objeto criado.
Voc quiser ocultar a classe atual do objeto criado.
Voc quiser um conj unto de objetos usados jUlllos. Isso evita que voc use objctos incom-
patveis juntos.
Voc quiser usar diferentes verses de uma implementao de classe. Um Abstract Fac-
tory permi te que voc troque essas diferentes verses em seu sistema.
A Tabela 12.1 destaca o usurio do padro Abstracl Factory.
Padres avanados de projeto
TABELA 12.1 O padro Abstract Fact ory
Nome do padro
Problema
Soluo
Conseqncias
Ahstract Factory
Precisa de uma maneira de trocarobjetos plugveis de ronna transparente
Fornecer urna interface abstrata que providencie mtodos para instanciar
os ohjetos
Pernl ite que voc troque facilmeOle novos tipos de classe em seu siste-
ma; entretanto, dispendioso adicionar tipos no re lacionados
o padro Singleton
Quando projetar seus sistemas, voc ver que algumas classes deveriam ter logicamente apenas
urna instncia, como um factory ou um objeto que acesse al gum recurso no comparti lhado (co-
nexo de banco de dados, regio de memria etc.). Nada, entretanto, i mpedir que um objeto ins-
tancie outro. Como voc impe seu projeto?
O padro Singleton fornece a resposta dessa pergunta. O padro Singleton impe seu projeto co-
locando a responsabilidade da criao e da intennediao do acesso instncia no prprio obje-
la. Fazer isso garant e que apenas uma instncia seja criada, alm de fornecer um unico ponto de
acesso para essa instncia. A Figura 12.2 i lustra a assinatura de uma classe singlclon (carta unica
de detenninado naipe).
FIGURA 12.2
O padrtio Sillglelofl
A Listagem 12.7 ilustra LIma possvel classe singleton.
LISTAGEM 12.7 Uma implementao do padro Singleton
publ ic class Singleton (
II uma referncia de classe para a instncia singl eton
private static Singleton instancej
II o constru t or deve ser oc ulto para que os objetos no possam instanciar
II protected permite que outras classes herdem de Sing leton
protected SingletonO ()
II um mtodo de classe usado para recuperar a i nstncia singleton
public static Singleton getlnstance() (
if( instance nul l ) (
instance new Singleton()j
}
Dia 12
LISTAGEM 12.7 Uma implementao do padro Singl eton (continuao)
return i nstance;
}
}
A classe Si ngl eton contm uma instncia esttica de Si ngl eton e d acesso instncia de 51n-
gl eton atravs do mtodo da classe gctlnslance().
Implementando um Singleton
o Captul o 7, Laboratri o I, apresentou uma classe Payroll. Uma classe de folha de pagamento
' real' provavelmente acessaria um banco de dados de funcionrios. Poderia ser lima boa idia ter
apenas urna instncia de Payroll , para evitar conflitos dc recurso. A classe Payro11 uma boa
candidata para o padro Si ngleton.
A Listagem 12.8 apresenta um singleton Payroll.
llSTAGEM 12.8 Payro 11 Si n9 I eton
publi C class Payroll {
II uma referncia de cl asse para a i nstncia singleton nica
private static Payroll instance ;
pri vate I nt
private Int
private doubl e
total_hours;
total_sales;
total_pay;
II oculta o construtor para que outros objetos no possam instanciar
protected Payroll O II
II observe o uso de stat i c: voc no tem uma instncia. quando recupera
II uma instncia; portanto , o mtodo deve ser um mtodo de cl asse ; daf. II
stati c
public static Payroll getInstanceO {
if( instance null ) {
instance = new Payro] l() ;
}
return instance ;
}
public void payEmployees( Employee [] emps ) {
for ( int i = O: i < emps. length ; i ++ ) (
Employee emp z emps [i];
total _pay .- emp.cal culatePay();
emp.printPaycheck();
Padres avanados de projeto
LI STAGEM 12.8 Payroll Si ngleton (continuao)
}
}
}
public void calculateBonus( Employee [] emps ) (
}
for( i nt i - O: i < emps.length; i ++ ) I
Employee emp emps [i]:
}
System. out.println{"Pay bonus to " + emp.getLastName{) + ", " +
emp.getFirstName{) + " $" + emp.calculateBonusO ):
public void recordEmployeelnfo( CommissionedEmployee emp ) {
total _sales +- emp.getSales():
}
public yoid recordEmpl oyeelnfo( HourlyEmployee emp ) {
total _hours +- emp.getHours():
}
publ ic void printReport() I
}
System.out.println{ "Payroll Report:" );
System.out.println{ "Total Hours: II + total_hours ):
System.out.println( "Total Sales: " + total _sales );
System.out.println( "Total Paid: $" + total_pay ):
271
o singleton Payrol l adiciona um mtodo getlnstanceO. Esse mtodo responsvel por criar e
dar acesso instncia singleton. Preste bem ateno ao construtor; aqui, o construtor protegido
para que outros objctos no possam inadvertidamente instanciar mais objctos Payro 11. Como ele
protegido, outros objelos podem herdar de Payro 11 .
A Listagem 12.9 d um exemplo de como voc pode usar o singleton.
LI STAGEM 12.9 Usando o singleton Payroll
II recupera o singleton de folha de pagamento
payroll payroll - Payroll.getInstanceO;
II cri a e atualiza al guns funcion6rios
Commi ssionedEmployee emp! new Commiss i onedEmployee( MMr.", Sales" , 25000 .00,
l OOO.OO} ;
Commi ssionedEmployee emp2 new CommissionedEmployee( "Ms.", "Sal es", 25000.00 ,
l OOO.OO} ;
empl.addSales{ 7 );
Dia 12
LI STAGEM 12.9 Usando o si ngleton Payroll (conti nuao)
emp2.addSales( 5 }:
Hour 1 yEmp 1 oyee emp3 new Hour 1 yEmp 1 oyee ( NMr. N. "Mi nimum Wage-, 6.50 ) :
Hourl yEmployee emp4 .. new HourlyEmployee{ NMs .
N
, "Minimum Wage-, 6.50 ) ;
emp3.addHours{ 40 }:
emp4.addHour s( 46 );
II usa os mtodos sobrecarregados
payro 11 . recordEmp 1 oyee I nfo ( emp2 ):
payrol1.recordEmployeelnfo( empl ) ;
payrol1 . recordEmployee lnfo( emp3 );
payro 11 . r ecordEmp 1 oyee I nfo ( emp4 ) :
Uma vez que voc tenha uma instncia singleton, ela funci onar como qualquer outra instncia.
O qu interessante a respeito da Listagem 12.9 e:
Payroll payroll Payroll .getlnstance() :
Note que voc no escreve mais:
Payrol l payroll - new Payrol l O:
Herana e o padro Singleton
O padro Singleton apresenta algumas dificuldades de herana. Especificamente, quem geren-
cia a instncia singleton, a progeni tora ou a filha? Voc tem algumas escolhas.
A primeira escol ha simplesmente criar a subclasse singletoll e atual izar a progeni tora para ins-
tanciar a filha. As listagens 12. 10 e 12.11 destacam essa estratgia.
LI STAGEM 12.10 Chi l dSingl eton
publi c class ChildSi ngleton extends Singleton {
protected Chi ldSingletonO {}
publi c String toString() {
return "I am the child singl eton ";
I
I
LI STAGEM 12.11 Updated Si ngleton
public cl ass Si ngl eton {
II uma referncia de classe para a instncia s ingleton
Padres avanados de projeto 273
LI STAGEM 12. 11 Upda ted Singleton (continuao)
}
private static Singleton i nstance:
II o constructor deve ser oculto para que os objetos no possam i nstanc i ar
II protected penmite que out ras classes herdem de Sing1eton
protected ParentS1ngletonO I}
II um m todo de classe usado para recuperar a instncia singleton
public s t atic Si ngleton getInstanee() {
if ( ins tance nul 1 ) I
ins tance new ChildSi ngleton():
}
re turn instance;
}
publi C Stri ng toString() {
return "I am the si ng1eton" :
}
Essa soluo tcm o inconveniente de exigir alteraes na classe progenitora. Uma soluo alter-
nat iva inclui Fazer com que o singleton leia uma varivel de confi gurao na primeira vez que
getInstanceO for chamado. O singleton pode instanciar qualquer objeto que seja especificado
no valor da configurao.
Voc tambm pode pennitir que cada fi lha fornea sua prpria implementao de getInstan-
eeO. Essa estratgia no exigi r alteraes na progenitora.
Este quadro conta com um truque da li nguagem Java, embora exista um anlogo na lin-
guagem C++. Trata-se de uma SOluo interessante que t ira proveito do fato de que os
blocos estticos so executados quando uma classe carregada na linguagem Java.
Atravs de outra estratgia, voc pode adicionar um mtodo protegido regi s tere Si n-
gletons ) na progenitora. Voc pode colocar um bl oco esttico na fil ha, que a instancie.
Dentro do construtor, a filha pode se registrar na si ngleton progenitora.
Aqui est o cdigo da classe Singleton atualizada:
public class Slngleton (
II uma refernCia de classe para a instncia de singleton
private static Singleton ins tance;
II o construtor deve ser oculto para que os objetos nao possam instanciar
II protected permite que out ras classes herdem de 51ngleton
protected 5ingleton () I)
}
Dia 12
II um mtodo de classe usado para recuperar a instAncia de singleton
publ ic static Singleton getInstance() I
If( i nstance null 1 (
Ilvalor pad r<io
Instance new Singl eton() ;
}
return instance;
}
protected static void register( Singleton s } (
if( i nstance nu l l ) I
Instance Sj
}
}
E a cl asse ChildSi ngleton atual izada:
pub l lc class ChlldSingleton extends Singleton I
}
statlc {
new ChildSingleton() j
}
protected ChildSingleton() {
Singleton.register( this );
}
Para fazer t udo isso f uncionar, voc precisar chamar CI asso forName( ~ h l l d S i ngl eton ~ )
Ant es de chamar o mtodo get lnstanceO do singl eton. Aqui est um exemplo:
Class.forName( "ChildSingleton" };
Singleton 5 Singleton.getlnstance() ;
System.out . prlntln( s. t oString() l j
Quando usar o padro Singleton
Use o padro Si ngleton quando voc quiser restringir uma classe a ter apenas urna instncia.
A Tabela 12.2 destaca o usurio do padro Si ngleton.
TABELA 12.2 O padro Si nglet on
Nome do padro
Problema
Soluo
Singlcl on
Deve existirapenas uma instncia de um objeto no sistema em detenni-
nado moment o.
Pemlit ir que o objeto gerencie sua prpria criao e acesso atravs de
um mtodo de classe.
Padres avanados de proj et o
TABELA 12.2 O padro Singlet on (continuao)
Conseq6ncias
Acesso controlado instncia do objcto. Tambm pode dar acesso a um
nmero definido de instncias (como apenas seis instncias), com uma li -
geira alterao no padro. um pouco mais dificil herdar um singleton.
o padro Typesafe Enum
A Listagem 12. 121i sta uma seleo da classe Card, apresentada pela primeira vez no Captulo 3,
Laboratrio 3.
LISTAGEM 12.12 Uma seleo de Card.java
publi c class Card {
J
private int rank :
private int suit ;
private bool ean face_up ;
II constantes usadas para instanci ar
II naipes
publ i c static f inal i nt OIAMONOS - 4;
public static fi na 1 i nt HEARTS 3;
public static final i nt SPAOES 6;
public static fi na 1 i nt CLUBS 5;
II valores
public static fi na 1 i nt I NO
2

public st atic fi nal
i "t
THREE 3;
publl c static fi na 1 i nt FOUR 4;
public static fina 1
i "t
FIVE 5 ;
public static final int 5IX 6;
publi c static final i nt SEVEN 7 ;
public static fi nal i nt EIGHT 8;
public static fi nal i nt NINE 9

public static final
i "t
m 10;
public static fi nal int JACK 74 ;
public static final i nt QUEEN 81 ;
public statlc final int KING 75 ;
publ ic static final fnt ACE 65 ;
II cria uma nova carta - usa as constantes apenas para ini cial izar
publ ic Card( int sult . lnt rank ) {
J
II Em um programa real . voc precisari a fazer a validao nos argumentos.
thi s. suit suft;
this.rank rank ;
Dia 12
Ao instanciar objetos Card, voc precisa passar uma constante de nmero e de naipe vlida. A
utilizao de constant es dessa maneira pode levar a muitos problemas. Nada o impede de passar
qualquer lnl que voc queira. E, embora voc deva referenciar apenas o nome da constante, isso
abre a representao interna de Cardo Por exemplo, para conhecer o naipe da carta (Card), voc
deve recuperar o valor int e depois compar-lo com as constantes. Embora isso funcione, essa
no uma soluo limpa.
O problema reside no fato de que naipe e nmero so objetos propriament e ditos. i nt no resol-
ve isso, pois voc precisa aplicar um significado a i nl. Novamente, isso confunde a responsabi -
li dade, pois voc precisar reapl icar esse signi fi cado sempre que encontrar um inl que
represente um nmero ou um naipe.
Li nguagens corno C++ tm uma construo, conhecida como enllmerao; entretanto, as enu-
meraes se reduzem simplesmente a um atal ho para declarar urna li sla de constantes inteiras.
Essas constant es so limitadas. Por exemplo, elas no podem fornecer comportamento. Tambm
difici l adicionar mais constantes.
Em vez disso, o padro Typesafe Enum fornece lima maneira 00 de declarar suas constantes.
Em vez de declarar simples constantes inteiras, voc cri a classes para cada tipo de constante.
Para o exemplo Card, voc cri aria uma classe Rank (nmero) e uma classe SUl l (naipe). Ento,
voc criari a uma instncia para cada valor de constante que quisesse representar e a tomaria pu-
bl icamcnte disponivel a parti r da classe (atravs de public final, cxatamentc como as outras
constantes).
Implementando o padro Typesafe Enum
Vamos vcr a implementao das classes Rank e SUll, nas li stagens 12. 13 c 12.14.
LISTAGEM 12.13 SuiLjava
puhl i c f i na l class Suit {
Ildef ine estaticamente todos os va lores vl idos de Sui t
public static fi nal Suit OIAMONOS
'"w
Suit ( (char )4 );
public static fi nal Suit HEARTS
'"w
Sui t e (char)3 );
publ ic static fi nal Suit SPADES n, w Sui te (char)6 ) ;
publ ic static final Suit CLUBS n, w
Suite (char)5 ) ;
II ajuda a fazer a iterao pelos valores da enumerao
publ ic static final Sui t [] SUIT = ( OIAMONDS . HEARTS . SPADES . Cl UBS ) ;
II varivel de i nstancia pa ra conter o valor de exibio
private final char displ ay;
II no permite i nstanciao por obj etos externos
private Suite char displ ay ) {
Padres avanados de proj et o 277
LI STAGEM 12.13 Suit.java (continuao)
}
thiS.display displ ay;
}
II retorna o valor de Suit
publlc String toStringO {
return String.valueOf( d;spl ay };
}
SUl t simples. O construtor recebe um char que representa o SUl t. Corno Sui t um obj eto com-
pl eto, ele tambm pode ter mtodos. Aqui, o sua fornece um mtodo toStri ngO. Uma enume-
rao de typesafe que pode adicionar quaisquer mtodos que se most rem teis.
Voc tambm notar que a constante privada. Isso impede que os obj etos instancicm objetos
SUl t di retmnente. Em vez di sso, voc est restrito a usar apenas as instncias de constante decla-
radas pela classe. A classe tambm declarada como final para que outras classes no possam
ser subclasses dela. Existem ocasies em que voc permi ti r a herana. Nessas ocasies, torne o
construtor protegido e remova a declarao final.
NOTA
Devi do ao modo como a linguagem Java funciona, certi f iquese de fornecer
verses f inais de equal sO e hashCode() que chamem super, caso voc abra sua
enumerao para a herana. Se no, voc estar abert o a probl emas estra-
nhos, caso suas subclasses redefi nam esses mt odos incorretamente.
Voc notar que a classe SUl t define vrias instncias de constante, uma para cada um dos naipes
vlidos. Quando voc preci sa de um valor constante de sua, pode escrever Su;t.DIAMONDS.
A classe Rank, na Listagem 12.14, funciona de modo semelhante a SUl t ; entretanto, ela acrescen-
ta mais alguns mtodos. O mtodo getRank() retoma o valor de Rank. Esse valor pode ser impor-
tante para calcular o valor de uma jogada. Ao contrrio das constantes ori ginais, voc no
precisa mais apl icar signifi cado s constantes Ra n k ou Su; t. Em vez disso, elas contm seus pr6-
prios significados, pois so objelos.
LISTAGEM 12.14 Rank . java
publ;c final class Rank {
publ ;c static final Rank
'.O
new Rank( 2, "2
M
} ;
publ ic static fi nal Rank THREE oe. Rank( 3, "3
M
} ;
public static final Rank FOUR ne. Rank( 4, "4
M
} ;
public stati c fi nal Rank FIVE ne. Rank( 5,
"5 M
} ;
public static fi nal Rank
SI'
ne. Rank( 6,
6 ~
} ;
publi c stat ic fi na 1 Rank SEVEN ne. Rank( 7, "7" } ;
Dia 12
LISTAGEM 12.14 Rank.java (continuoo)
public stati c f inal Rank EIGHT ne. Rank(
8.
"8- );
public s tati c fi nal Rank NINE ne. Rank(
9.
"9" );
publ ic s tati c fi na 1 Rank
TE'
ne. Rank( 10. "10"
I ;
publlc s tatic fi na 1 Rank JACK ne. Rank(
11. " J "
);
publ ic s ta tic fi na 1 Rank OUE EN ne. Rank( 12. "O- );
pu bl ic s tatic f inal Rank KING ne. Rank(
13.
" 1("
I ;
publ i c static f inal Rank ACE ne. Rank(
14. "A"
I ;
public stati c fi na l Rank [] RANK "
{ TWO , THREE, FOUR, FIVE, SIX , SEVEN,
EIGHT, NINE, TEN, JACK, OUEEN, KING, ACE I ;
I
private f ina l
pri vate f ina l
i nt
St r ing
rank :
display ;
private Rank( int rank, Stri ng display ) {
this.rank r ank:
thi s. di splay di splay;
I
publiC int getRank() {
return rank;
}
pubhc St ring toStringO {
return displ ay;
}
Por exemplo, voc no precisa mais apl icar significado a i nt 4 e sabe que 4 significa OIAMONOS.
Quando voc precisar determinar o val or da constante, pode fazer comparaes de objeto usando
equa 1 s ().
A Listagem 12.15 mostra as alteraes que voc precisaria fazer em Ca rd para poder usar as na-
vas constant es. (As classes Oec k e Oea 1 er atualizadas esto disponveis no cdigo-fonte deste ca-
ptulo).
LISTAGEM 12.15 A classe Ca rd. java atuallzada
publ i c class Card {
private Rank rank ;
private Suit suit:
private boolean face_up;
Padres avanados de projeto
LISTAGEM 12.15 A classe Ca r d.java a tua lizada (continuao)
J
II cria uma nova cart a - usa as cons t antes apenas para inicial izar
public Card( Suit suit , Rank rank ) (
J
II Em um programa rea l , voc preci saria fazer a validao nos argumentos.
this.suit = suit;
thi s . rank rank ;
publ ic Sult getSuit () {
re turn sui t;
J
publi C Rank getRank{) {
return rank;
J
publ ic void f aceUp() (
face_up true ;
J
publ ic voi d f aceDown() (
f ace_up false;
J
publiC boolean i sFaceUp() (
return f ace_up;
J
publi C String di splay() (
return rank.toStr ing() + suit .toStri ng();
J
Voc tambm pode ter notado que Ra nk e Sui t declaram arrays de constantes. Isso torna fci l fa-
zer um lao pelos val ores das constantes di sponveis. A Li stagem 12. 16 mostra como esse fato
simplifi ca bastanl e o mtodo bui I dCards O de Ded.
lISTAGEM12.16 O m t odo buil dCards{ ) atualizado
private void buildCards() (
deck new java . uti l . LinkedList() ;
f or( lnt 1 O; i < Suit.SUIT.length; i ++ ) I
for ( i nt j O; j < Rank.RANK. length; j ++ ) I
Dia 12
LI STAGEM 12.16 O m todo buildCardsO atualizado (continuao)
deck.add( new Card( Sui t.SUIT ( i ], Rank . RANK (j]));
}
}
}
Quando usar o padro Typesafe Enum
Use o padrJo Typesafe Enum, quando:
Voc se achar escrevendo numerosas primitivas pblicas ou constantes de String.
Voc se achar impondo identidade em um valor, em vez de derivar a identidade do pr-
prio valor. A Tabela 12.3 destaca o usurio do padro Typesafe Enum.
TABELA 12.3 O padro Typesaf e Enum
Nome do padro
Problema
Soluo
Conseqncias
Typesafe Enum.
As constantes inteiras so limitadas.
Criar uma classe para cada tipo de constante e depois fornecer instncias
de constante para cada valor de constante.
Constantes 00 extensveis. Constantes teis que tm comportamento.
Voc ainda precisa atualizar cdigo para usar as novas constantes,
quando elas forem adicionadas. Exige mais memria do que uma cons-
tante simples.
Armadilhas do padro
Voc pode abusar dos padres de projeto, assi m como acontece com qualquer outra ferramenta,
usando-os incorretamente. Os padres de projeto no garantem um bom projeto; na verdade, in-
cluir um padro em um lugar onde ele realmente no pertence arruinar seu projeto. Voc preci-
sa ser cri terioso em sua deci so de incluir um padro em seu projeto.
Recentemente, os padres de projeto vm sendo cada vez mai s criticados. Infelizmente, existe
uma tendncia, especialmente entre os iniciantes, de ser pego na tentati va de aplicar o mximo
de padres possivel a um projeto. O entusiasmo de usar padres tem feito mui tos desenvolvedo-
res se esquecerem do objelivo dos padres e ate do prprio processo de projeto. No caia nessa
annadilha! No fi que cego com o prazer de aplicar padres e deixe o projeto se reduzir ao mxi-
mo de padres possvel. Voc no ganhar pontos de seus colegas por usara mxi mo de padres,
mas ganhar pontos por produzir um projeto limpo e coerente. Tal projeto poderia nem mesmo
usar padres!
DICA
Padres avanados de proj et o 281
Existem algumas diretrizes que o ajudaro a evi tar a armadil ha do padro:
Dica 1: colocando paraf usos redondos em buracos quadrados. Se voc se
achar pensando, posso usar <insira seu padrlio predlleto aqui:> em
meu projetor, estar com problemas. Em vez disso, voc deve pensar, vi
esse projeto antes; acho que existe um padro que o Agora, v e veja
um livro sobre padres. Sempre comece do ponto de vista do problema e no
da soluo (o padro).
Dica 2: ataques de amnsia. Voc estar com problemas, caso no possa expli-
car, em duas f rases ou menos, porqu escol heu um padro e quais as vanta
gens que ele oferece. Voc deve poder explicar facilmente porque incl uiu um
padro e para que ele contribui em um projeto. A situao sem esperana,
caso voc no consiga pensar em uma explicao.
Existe uma segunda armadi lha, mais sut il , nos padres: tagarelice do padro. No use padres
para tentar parecer inteligente e no tente sugerir o uso de um padro que voc no tenha estuda
do. Voc poderi a mencionar o padro, mas sej a c laro, caso no esteja fami li ari zado com ele.
Voc no deve apenas usar padres apropri adamente em seu projeto, mas tambm em suas con
versas. No uma boa idia contri buir para os fatores que prejudicam a prtica de usar padres.
Resumo
Os padrcs de projeto so uma aj uda t il ao se projetar suas sol ucs. De sua prpria maneim, os
padres so a conscincia colet iva da comunidade de 00, que tem anos de experi ncia em projeto.
Lembrc se dos limites dos padres de projeto, quando utili z los. Um padro de proj eto tmta de
um e apenas um problema abstmto. Um padro de proj eto no fornece a soluo para um proble-
ma especifi co. Em vez disso, o padro fornece uma sol uo abstmta para um problema geral.
Fica por sua conta fornecer o mapeamento entre o problema abstrato e seu problema especfico.
Mapear um padro de projeto provavelmente o maior desafi o que voc enfrentar ao usar pa-
dres. Trata-se de uma habi lidade que s vem com o tempo, estudo e prtica.
Perguntas e respostas
P Como voc escolhe um padro de projet o?
R Cada padro de projeto tem um problema e padres relacionados. Estude o padro, se a
descrio do problema parece corresponder ao seu caso. Tambm ajudar, se voc exa
minar todos os padres relacionados . Se, aps estudar o padro, ele parecer resolver seu
problema, tente aplicar o padro ao seu caso. Certifique se de exami nar as conseqncias.
Se qualquer lima das conseqncias entrar em conflito com seus requisitos, voc prova
vel menle dever ignorar O padro.
P Como voc sabe quando deve usar um padro de projeto?
R No h uma resposta fci I para essa pergunta.
Dia 12
Voc no pode usar um padro, caso no o conhea, e ningum pode conhecer todos os
padres de projeto disponveis. Quando voc projetar, tente obter o mximo de entradas
possvel. Pergunte s pessoas se elas conhecem padres que possam ajudlo a tomar
suas decises de projeto.
Estude os padres. Quanto mai s padres voc conhecer, mais oport unidades ver para
us los.
P A linguagem Java usa quaisquer dos padres abordados hoje?
R Sim. A linguagem Java usa muitos dos padres abordados hoje.
Padro Factory Method: muitas classes Java tm mtodos factory (um padro intima
mente relacionado ao padro Abstract Facto!)').
Padro Singleton: java.lang.System um exemplo dc singlcton na linguagcm Java.
Padro Typesafe Enum: o padro Typesafe Enum ainda no eSlava definido quando mui
tas das APls Java foram cri adas. As adies futuras na APl Java usaro o padro Typesa
fe Enum.
Workshop
As perguntas e respostas do teste so fornecidas para seu melhor entendimento. Veja as respos
tas no Apndice A, "Respostas".
Teste
I. o que uma classe empacotadora?
2. Qual problema o padro Abstract Factory resolve?
3. Por que voc usaria o padro Abstracl Factory?
4. Qual problema o padro Singleton resolve?
5. Por que voc usaria o padro Singleton?
6. Qual problema o padro Typesafe Enum resolve?
7. Por que voc usaria o padro Typesafe Enum?
8. Os padres garantem um projeto perfeito? Por que sim Oll por que no?
Exerccios
A Li stagem 12. 17 apresenta a classe Bank do Capitulo 7. Transforme Bank em um singleton.
Padres avanados de projeto
LI STAGEM 12.17 Bank.java
publie elass Bank {
}
private java.util.Hashtable aeeounts = new java . uti l. Hashtable():
publi e void addAecount( St ring name , BankAceount aeeount ) (
accounts . put( name , account ):
}
public double totalHoldings() {
double total = 0.0:
java.util.Enumeration enum - accounts.elements{):
while( enurn . hasMoreElements() ) {
}
}
BankAccount account = (BankAccount) enum.nextElement():
total ~ account.getBalance( ):
return tota 1 ;
publ ic lnt totalAceounts() (
return accounts.size():
}
publiC void depos ite St r ing name, double ammount ) (
BankAccount account - retr ieveAccount( name );
if( account l- nu11 ) (
account.depositFunds( ammount ) :
}
}
public double balance( String name ) {
}
BankAccount account - ret r ieveAeeount( name ):
if( aeeount ! - null ) {
return account.getBalanee() :
return 0.0;
}
private BankAeeount retrieveAeeount ( Stri ng name ) {
return (BankAceount) aceounts . get( name ) :
}
2. Considere a classe Error apresentada na Listagem 12.18. Essa classe define vrias cons-
tantes. Aplique o padro Typesafe Enum no projeto dessa classe.
I 284 Dia 12
LISTAGEM 12.18 Errar.java
public class Errar (
I
II nheis de erro
publ ic final stati c i nt NOISE
publi c fi na I static i nt INFO
public fi na I statlc
i "t
WARNING
publ1c final statlc
i "t
ERROR
private int leveI ;
publiC Errar( int level ) {
this. l evel level;
I
public int getlevelO {
return leveI;
I
publ iC String toString() {
switch (level) {
case O: return "NOISE ";
case I: return "INFO " .





case 2: return "WARNING ";
default: return "ERROR ";
I
I
O

1 .

2;
3;
3. Projete e cri e um Abstract Factol)' para a hierarquia BankAccount apresentada como uma
soluo no Capitulo 7, Laboratrio 3.
Respostas do teste
I. Uma classe empacotadora transforma a interface de um objelo naquela esperada por seu
programa. Uma classe empacotadora contm um objeto e delega mensagens da nova in-
terrace para a interface do objeto contido.
2. O padro Abstract Factol)' fornece um mecanismo que instancia instncias de classe des-
cendentes especificas, sem revelar qual descenderue realmente criado. Isso permite que
voc conecte de forma transparente diferentes descendentes em seu sistema.
3. Voc usa o padro Abstract Factol)' para ocul tar os detalhes da instanciao, para ocultar
qual classe de objeto inslanciada e quando quer que um conj unto de objetos sejam usa-
dos j untos.
4. O padro Singleton garante que um objeto seja instanciado apenas uma vez.
Padres avanados de projeto
5. Voc usa o padro Singleton quando quer que um objeto seja instanciadoapenas uma vez.
6. Usar constantes primitivas no uma estratgia de 00 para programao, pois voc pre-
cisa aplicar um significado externo constante. Voc viu quantos problemas a decompo-
sio da responsabilidade poderia causar!
O padro Typesafe Enum resolve esse problema, transformando a constante em um obje-
to de nvel mais alto. Usando um objeto de nvel mais alto, voc pode encapsular melhor
a responsabilidade dentro do objeto constante.
7. Voc deve usar o padro Typcsafe Enum quando se achar declarando constantes pbli-
cas que devem ser objetos propriamente ditos.
8. No, os padres no garantem um projeto perfeito, pois voc poderi a acabar usando um
padro incorretamente. A lm disso, usar corretamente um padro no signi fi ca que o res-
tante de seu projeto seja vlido. Muitos projetos nem mesmo contm um padro.
Respostas dos exerccios
I.
LI STAGEM 12.19 Bank . java
publie elass 8ank {
private java.uti l. Hashtable aeeounts = new java .util.Hashtable()i
private statie 8ank instanee;
proteeted Bank o {}
publie stat i e Bank getlnstanee() {
if( i nstanee nul1 li
instanee new Bank()i
}
return instanee:
}
publie void addAeeoun t( Stri ng name . BankAeeount aeeount 1 I
aeeounts.put ( name , aeeount )i
}
publ ie double total Hold ings() {
double total 0.0;
java.util.Enumeration enum: aeeounts.el ements() ;
while( enum.hasMoreElement s() ) {
BankAeeount aeeount (BankAeeount )enum. nextEl eme nt() i
total +- aeeount.getBalanee () ;
Dia 12
LISTAGEM 12.19 Bank.java (continuoo)
}
2.
}
return total:
}
publiC int totalAccounts() I
retur n accounts.size():
}
public void deposite String name , double ammount ) I
Ba nkAccount account = retri eveAccount( name ):
if( account ! - null ) I
account.depositFunds( ammount ):
}
}
publi c double balance( Stri ng name ) {
}
BankAccount account " retrieveAccount( name ) :
if( account ! - nu11 ) {
return account.getBal ance{):
return 0.0;
}
private BankAccount retrieveAccount( String name ) (
return (BankAccount) account s . get( name );
}
LISTAGEM 12.20 Level . java
publi c fina l class leve1 {
pub1i C fi na 1 st at ic
publ ic f i nal stat ic
publ ic fi nal static
publ ic fi na l stat ic
pr'iYate i nt level ;
priva te String name;
level
level
level
level
NOISE
"
",w level (
INFO
"
n.w level (
WARNING
"
n.w level (
ERROR
"
n.w leve 1 (
private leve1 ( int leve l, String name ) (
th i s . level " level :
thi s . name " name;
O, "NOISE" );
1 , "INFa" ) ;
2, "WARNING"
3, "ERROR" ) ;
) ;
Padres avanados de projeto
LISTAGEM 12.20 level. j ava (continuao)
}
}
public lnt getlevel() {
return l evel;
}
public String getName() (
return name ;
}
LI STAGEM 12.21 Errar.java
publi C class Error {
}
pr;vate level level ;
publ iC Errar( Level level ) {
th1s.level - level;
}
public level getlevel() {
return level;
}
publl C String taString() (
return l evel .getName();
}
287
3. A soluo cons iste em uma abstrata Factory de conta bancria (escri ta como uma inter-
face; entretanto, ela tambm pode ser uma classe abstraIa) e lima Concreta Factory de
conta bancria. A Factory tem um mtodo para criar cada tipo de conta bancria.
Essa Factory oculta os detalhes da instanciao e no necessariamente o subti po do objeto.
LISTAGEM 12.22 AbstractAccountFactory . java
public interface AbstractAccountFactory {
public CheckingAccount createCheckingAccount( doubl e initOeposit . int trans ,
dauble fee )i
Dia 12
LI STAGEM 12.22 AbstractAccountFactory . java (continuao)
publiC OverdraftAccount createOverdraftAccount( double initOeposit. double
rate );
publiC RewardsAccount createRewardsAccount( double initOeposit. double
interest . doubl e min };
public SavingsAccount createSavingsAccount( double init6alance. double
interestRate );
public TimedMaturityAccount createTimedMaturi tyAccount{ double init6alance .
double interestRate. double feeRate );
}
LI STAGEM 12.23 ConcreteAccountFactory . java
public cl ass ConcreteAccountFactory implements AbstractAccountFactory I
publ ic CheckingAccount createCheckingAccount( double initOeposit . int trans.
double fee ) I
return new CheckingAccount{ i nitOeposi t . trans. fee );
}
public OverdraftAccount createOverdraftAccount( double initOeposit. double
rate) (
return new OverdraftAccount{ initOeposi t . rate );
}
public RewardsAccount createRewardsAccount{ doubl e initOeposit. double
interest. double min ) I
retur n new RewardsAccount{ initOeposit . i nterest . mi n ) ;
}
publiC SavingsAccount createSavingsAccount{ double initBal ance. double
interestRate ) I
return new SavingsAccount( initBal ance. interestRate ) ;
}
publ iC TimedMaturityAccount createTimedMaturityAccount( double initBal ance.
doubl e interestRate. double feeRate ){
return new TimedMaturityAccount( initBalance. interestRate. feeRate );
}
}
SEMANA 2
DIA
00 e programao da interface
, .
com o usuano
A interface com o usurio (UI) fornece a interface entre o usurio e seu sistema. Quase todo sis-
tema moderno ler alguma fonna de UI , seja grfi ca, dirigida pela linha de comando ou mesmo
baseada em telefone ou fala. (Alguns sistemas podem combinar todos os quatro tipos!). Em
qualquer caso, voc preci sa tomar um cuidado especial no projeto e implementao de suas in-
terfaces com o usurio. Feli zmente, a POO pode trazer as mesmas vantagens para sua UI que
apresenta para Outros aspectos do sistema.
Hoje voc aprender:
Como a POO e a construo da UI se relacionam
Sobre a importncia de uma UI desacoplada
Quais padres o ajudam a desacoplar a UI
POO e a interface com o usurio
Fundamental mente, o processo de projetar e programar interfaces com o usuri o no diferente
do processo de projetar e programar qualquer out ro aspecto de seu sistema. Talvez voc precise
aprender al gumas novas APls para que possa construir suas Uls, mas no fi nal, voc precisa aplicar
na UI os mesmos princ pios orientados a objetos que aplicaria nas out ras partes do seu sistema.
NOTA
Dia 13
Voc aprender como encarar o desenvolvimento de UI do ponto de vista de
um desenvol vedor. Como desenvolvedor, voc projetar e implementar as
classes que constituem e suport am a interface com O usurio.
A lio de hoje no abordar o assunto geral do proj eto de UI. O projeto de UI
abrange todos os aspectos de como os recursos de um programa se tornam
disponveis para um usuri o. O assunto geral do projeto de UI est completa-
mente removi do da programao e est mais enraizado nas artes grfi cas e na
psicologia. O ACM Special Interest Group on Computer-Human Interaction
(SIGCHI) um recurso excelente de informaes sobre projeto e usabilidade
da UI.
A questo merece nfase: ao projetar e programar suas interfaces com o usurio, voc deve apli-
car em suas Uls os mesmos princpios de 00 que aplicaria no restante do seu sistema! Freqen-
temente, as interfaces com O usurio so simplesment e reunidas e jogadas no sistema como uma
cogit ao posterior.
Em vez disso. o cdigo de sua UI precisa ser to ori entado a obj etos quanto o cdi go do restante
do sistema. A implementao da UI precisa usar encapsulamento, herana e polimorfismo corre-
tamente.
Voc tambm precisa cons iderar a UI enquanto realiza AOO e POO (Projeto Ori entado a Obje-
tos). Sem uma anlisee projeto corretos, voc pode perder certos requisi tos e verifi car que escre-
veu uma UI que no suficientemente fl exvel para fornecer o nvel desejado de funci onal idade
ou uma UI que no pode se adaplar s alteraes fut uras.
A importncia das Uls desacopladas
Voc ver que o mesmo sistema freqUentemente exige diversas interfaces di ferentes, muitas ve-
zes no relacionadas. Por exemplo, um sistema de abastecimento pode permitir que as pessoas
faam pedidos pela Web, pelo telefone, atravs de PDA ou de um apl icativo local personalizado.
Cada uma dessas interfaces se li gar ao mesmo sistema; ent retanto, cada estratgia se ligar ao
sistema e apresentar as informaes de sua prpria maneira.
Voc tambm ver que os requis itos da interface com o usurio podem se tornar um alvo mvel.
Os sistemas amadurecem com O tempo, quando novos rec ursos so adi cionados e quando os
usurios expem reas de debi I idade. Em resposta, voc precisar alua i izar continuamente a in-
terface com o usuri o para poder expor cada novo recurso e corrigir todos os defeitos. Essa real i-
dade pede uma interface com o usuri o cujo projeto seja fl exvel e possa aceitar alteraes
prontamente.
A melhor maneira de obter nexi bi lidade projetando um sistema que seja completamente desa-
copiado de sua UI. Um projeto desacoplado pennite que voc adicione qualquer UI no sistema e
faa alteraes nas Uls existentes, sem ter de fazer alteraes correspondentes no sistema em si.
Um projeto desacoplado tambm permite testar os recursos do sistema, mesmo que voc no te-
00 e programao da interface com o usu ri o 291
nha lenninado de desenvolver a UI. Alm disso, um projetodesacoplado permite que voc apon-
te precisamente erros que so da UI ou que so do sistema.
Felizmente, a POO a soluo perfei ta para esses problemas. Isolando as responsabilidades cor-
retamente, voc pode di minuir o impacto das alteraes em partes no relacionadas do sistema.
Isolando funcionalidade, voc deve consegui r adicionar qualquer interface em seu sistema, a
qualquer momento, sem fazer alteraes no sistema subjacente. O segredo no incorporar o c-
di go da UI dent ro do prprio sistema. Os dois devem ser separados.
Vamos ver um exemplo que desacopla incorretamentc a UI. A Listagem 13. 1 mostra como lIo
se deve escrever urna UI.
LI STAGEM 13.1 Vis ualBankAccount.java
i mport javax . swing.JPane1i
import javax . swing.J l abel;
import java.awt.BorderLayout ;
i mport java.awt.event.Actionl istener ;
i mport java.awt.event.Act ionEvent;
i mport javax.swing. JText Field ;
i mpo rt javax.swing.JButtoni
publ i c cl ass V1sualBankAccount extends JPanel implernents Ac t ionlist ener {
II dados privados
private doubl e balance ;
II el ementos da UI
private Jlabel
private JTextfield
private Jbutton
private Jbutton
balancelabel = new JLabelO i
amountField z new JTextField( 10 };
deposHButton = new Jbutton( "OeposH" ) i
wHhdrawButton = new Jbutton( "Withdraw" ) ;
public VisualBankAccoun t( double initOepos i t ) (
setBalance( i nitOeposit )i
buil dUIO j
I
1/ manipula os eventos dos botes
publ ic voi d actionPerfonmed( ActionEvent e ) (
if( e.getSource() aa depositButton ) {
doubl e amoun t Ooubl e. pa rseOouble ( amountFi eld.getText(} l j
depositFunds( amou nt };
}else if ( e.get Source() ~ wi t hdrawBut t on } (
double amount = Ooubl e.parseOouble( amountFiel d.getText() )i
if( amoun t > getBal ance() ) {
amount getBalance() ;
Dia 13
LISTAGEM 13.1 VisualBankAccount.java (continuao )
I
I
withdrawFunds( amount ):
I
I
pr ivate void bUildUI() I
I
setLayout( new 80rderLayout() ):
II constri a tela
JPa ne l buttons .. new Jpanel ( new BorderLayout() ):
JPanel balance .. new Jpanel ( new BorderLayout() ):
buttons.add( deposit8utton , BorderLayout .WEST ):
buttons.add( withdrawButton, BorderLayout.EAST l:
balance.add( balanceLabel , 80rderLayout.NORTH );
balance.add( amountField, Borderlayout.SOUTH l:
add( balance, BorderLayout.NORTH l :
add( buttons , BorderLayout.SOUTH );
II configura os callbacks para que os botes faam algo
II o boto de depsito deve chamar depositFunds()
depositButton.addAc t ionli stener( this ):
II o boto de saque deve chamar withdrawFunds
withdrawButton.addActionListener( this ):
public void depositFunds( double amount ) I
set8alance( get8alance() + amoun t );
I
publiC double getBalance() {
return balance:
I
protected voi d setBalance( double newBalance ) {
balance newBalance;
balanceLabel.setText( "Balance: " + balance):
I
public double withdrawFunds( double amount } I
setBalance( getBalance() - amount };
return amount;
I
00 e programao da inte rface com o usurio 293
VisualBankAccount usa a biblioteca Swing da linguagem Java para se apresent ar. Toda
linguagem 00 tem bibl iotecas para cri ar e exibir i nterfaces grf icas com o usuri o
(GUI). No se preocupe se voc no ent ender t udo que h neste exempl o. importante
apenas que voc entenda o significado geral do exemplo.
Um pouco de experincia pOde aj udar. Swing fornece uma cl asse para cada elemento
importante da GUI, como botes (JButtonl, rtulos (JLabel) e campos de ent rada
(JTextfi eld). Voc coloca esses el ementos j untos, dentro de painis (JPanel), para
const rui r sua UI.
Cada el emento da GUI t em um mtodo addAct ionLi stener(). Esse mtodo permite que
voc registre um objeto que implementa a interface Act i onL is tener como um callback.
Quando o elemento da GUI gerar um event o (normalmente como resultado de um cli -
que de mouse), ele informar cada um de seus receptores de ao. Aqui, Visual-
BankAccount at ua como receptor. Quando recebe um event o de um dos botes, ele
executa a ao corr et a e, em seguida, deposita ou saca di nheiro.
V i sua 1 BankAccount fomece Ioda a funcionalidade da classe BankAccount, apresentada em lies
anteriores. Vi sual BankAccount tambm sabe como se apresentar, como se v na Figura 13. 1.
FIGURA 13.1
VisualBankAccount dentro
de um freme.
Quando voc digitar um vaiar e clicar no boto Deposit ou Wi thdraw, a conta bancri a exlrair o
valor do campo de entrada e chamar seu mtodo wi thdrawFunds () ou depas i tFunds () , com o
valor.
Como VisualBankAccount um Jpanel ,voc pode incorpor-lo em qualquer OUI Java. Infe-
lizmente, a UI no est desacoplada da classe de conta bancria. Tal acoplamento forte toma im-
possvel usar a conta bancria em outras fonnas de interfaces com o usurio ou para fornecer uma
UI diferente, scm ler de allerar a prpria classe Vi sua 1 BankAeount, Na verdade, voc precisar criar
uma verso separada da classe para cada tipo de UI dentro da qual queira que ela participe.
Como desacoplar a UI usando o padro
Model View Controller
o padro de projeto MVC (Modcl Vicw Comroller) fornece uma estratgia para o projeto de in-
terfaces com o usurio que desacoplam completamente o sistema subjacente da interrace com o
usurio.
Dia 13
NOTA
MVC apenas uma estratgia para o projeto de int erfaces com o usuri o orien-
tadas a objetos. Existem outras estratgias vlidas para o projeto de interface
com o usurio; entretanto, a MVC uma estratgia testada que popular no
setor do software. Se voc acabar realizando o trabalho da interface com o
usurio, especialmente em relao Web e ao J2EE da Sun, encontrar o
MVC.
O DocumentNiew Model, popularizado pelas Microsoft Foundat ion Classes e
o padro de projeto PAC (PresentationAbstraction Controf), fornecem alterna
tivas MVC. Veja o livro Pattern-Oriented Sohware Architecture A Sysrem of
Parterns, de Frank Buschmann et ai, para uma apresentao completa dessas
alternati vas.
o padro MVC desacopla a UI do sistema, dividindo o projeto da UI em trs partes separadas:
o modelo, que represent a o sistema
O modo de visualizao, que exibe o modelo
O controlador, que processa as entradas do usurio
Cada part e da trade MVC tem seu conjunto prprio de responsabilidades exclusivas.
o modelo
o modelo responsvel por fornecer:
Acesso funcionali dade bsica do sistema
Acesso s informaes de estado do sistema
Um sistema de noti ficao de mudana de estado
O modelo a camada da trade MVC que gerencia o comportamento bsico e o estado do siste-
ma. O modelo responde s consultas sobre seu estado a part ir do modo de visuali zao e do con-
trolador e aos pedidos de mudana de estado do controlador.
Um sistema poda ter muitos model os diferentes. Por exemplo, um sistema de
banco pOde ser constitudo de um modelo de conta e um modelo de cai xa. V-
rios modelos pequenos repartem melhor a responsabi lidade do que um nico
modelo grande.
No deixe o t ermo modelo confundi -lo. Um modelo apenas um obj eto que
representa o sistema.
o cont rolador a camada da trade MVC que interpreta a entrada do usurio. Em resposta en-
trada do usurio, o cont rolador pode comandar o modelo ou o modo de visualizao para que
mude ou execut e alguma ao.
O modo de visualizao a camada da trade MVC que exibe a representao grfica ali text ual
do modelo. O modo de visual izao recupera todas as infonnaes de estado a respeito do mode-
lo, a partir do modelo.
00 e progra mao da inte rface com o usurio 295
Em qua lquer caso, o modelo no sabe absolutamente que um modo de visualizao ou controla-
dor est fazendo uma chamada de mtodo. O modelo s sabe que um objeto est chamando um
de seus mtodos. A nica conexo que um modelo mantm com a UI atravs do sistema de no-
ti ficao de mudana de estado.
Se um modo de visualizao ou cont roladorestiver interessado na noti ficao de mudana de es-
tado, ele se registrar no modelo. Quando o modelo mudar de estado, percorrer sua lista de ob-
jetos registrados (freqUentement e chamados de recept ores ou observadores) e informar cada
objeto da mudana de estado. Para construir esse sistema de notificao, os modelos normal-
mente empregaro o padro Observer.
o padro Observer
O padro Observer f ornece um proj et o para um mecanismo de publicao/assi natura
entre obj etos. O padro Observe r permite que um objeto (o observador) registre seu
interesse em out ro objeto (o observvel). Quando o observvel quiser noti ficar os seus
observadores de uma alterao, ele chamar um mtodo update() em cada observador.
A Li stagem 13.2 def ine a interface Observer. Todos os observadores que quiserem se
registrar com O objeto observvel devem implementar a interface Observer.
LI STAGEM 13.2 Observer. jovo
publlc interface Observer I
publ ic vold update();
}
Um observvel fornecer um mt odo, atravs do qual os observadores podem regis
t rar e anular o registro de seu interesse em atualizaes. A Listagem 13.3 apresenta
uma classe que implementa o padro Observer.
Implementando o modelo
Aplicar o padnl0 MVC no Vi suai BankAccount pode torn-l o muito mai s nexvel. Vamos come-
ar reti rando a funcionali dade bsica do 'sistema' do cdigo de exibio, para podermos criar o
modelo.
A Listagem 13.3 apresenta a funcionalidade bs ica da conta bancria - o model o.
LISTAGEM 13.3 BankAccountModel . java
i mpo r t java.util.ArrayList

import java.util.lterator

public class BankAccountModel {
II dados privados
private double balance;
Dia 13
LISTAGEM 13.3 BankAccountModel . java
J
prlvate ArrayList l isteners = new Arraylist();
public BankAccountHodel( double initOeposit } {
setBalance( initOeposlt };
J
public void depositFunds( double amount ) {
setBalance( get8alance() + amount ):
J
publi C double getBalance() {
return balance:
J
protected void setBalance( double newBalance ) {
balance newBalance:
updateObservers():
J
public double withdrawFunds( double amou nt } {
if( amount > getBalanceO ) {
J
amoun t get8alance();
J
set8alance(get8alanceO - amount );
return amount;
publiC void register( Observe r o ) {
receptores.add( o );
o.updateO;
J
publi c void deregister( Observer o )
receptores.remove( o );
J
private void updateObservers() {
lterator i receptores.iterator();
while( i .hasNextO )
J
J
Observer o " ( Observer) i .next();
o.update() ;
0 0 e programao da interface com o usu ri o 297
A BankAccount Mode 1 semel hante classe Ba nkAccount original, apresentada em lies ant erio-
res; enlretanlO, o modelo tambm usa o padro ObselVer para adicionar suporte ao registro e atu-
al izao de objetos que estejam interessados na not ifi cao de mudana de estado.
Voc tambm notar que essa classe contm toda a lgica do sistema. Agora, wi thdrawFunds()
,
veri fi ca o valor do saque para garanti r que ele no seja maior do que o saldo. E fundamental man-
ter tais regras de domfn io dent ro do modelo. Se essas regras fossem obedecidas no modo de vi -
sualizao ou no controlador. cada modo de visuali zao e controlador dcsse modelo precisaria
manter a regra. Confonne voc j viu, ter cada modo de visualizao ou controlador impondo
essa regra uma mistura de responsabi lidades e algo propenso a erros. A mistura de responsa-
bil idades tambm torna di fic il mudar a regra, pois voc precisa mud-Ia em cada lugar.
Os relacionament os com capacidade de substituio tambm tornam a colocao de regras no
modo de visuali zao uma prtica perigosa. Devido aos re lacionamentos com capacidade de
substituio, um modo de visuali zao funci onar para qualquer subclasse; ent retanto, se voc
colocar as regras de saque no modo de visuali zao, este no funcionar mais para um objcto
OverdraftAccount. Isso porque os objetos OverOraftAccount pennitem que voc saque valores
maiores do que o saldo corrente.
o modo de visualizao
O modo de visualizao responsvel por:
Apresent ar o modelo para o usurio
Registrar no modelo noti fi cao de mudana de estado
Recuperar informaes de estado do modelo
O modo de visualizao a camada da trade MVC que exibe informaes para o usuri o. O
modo de visuali zao obtm informaes de exibio do modelo, usando a interface publi ca
deste, e tambm se registrar no modelo para que ele possa ser infonnado da mudana de estado
e se atualize de acordo.
NDTA
Um unico modelo pode ter muitos modos de vi sualizao diferentes.
Implementando o modo de visualizao
Agora que existe um modelo, hora de implementar o modo de visuali zao da conta bancria.
A Listagem 13.4 apresenta o modo de visualizao de BankAccountModel.
LI STAGEM 13.4 BankAccountView.java
import javax.swing.JPanel;
import javax. swing . J l abel;
Dia 13
LISTAGEM 13.4 BankAccountView. java (continuao)
import java.awt.Borderlayout;
import javax.swing.JTextField;
import javax.swing.JButton;
public class BankAccountView extends JPanel implements Observer I
public final static String DEPOSIT "-Deposit";
public final static String WITHDRAW " Withdraw";
private BankAccountModel model;
private BankAccountController cont rol ler;
II El ementos da GUI . aloca tudo previ amente para evitar valores nulos
private JButton depositButton " new Jbut ton( DEPOSI T ) ;
private JButton withdrawButton new Jbutton( WITHDRAW };
private JTextField amountField new JTextFiel d() ;
private Jlabel balancelabel "new JlabelO;
publ ic BankAccountView( BankAccountModel mode l ) I
th i s.model z model o
thi s.model.register( this l i
attachController( makeCont rol l er() ) ;
buildUI O;
J
II chamado pelo mode l o quando este muda
publ ic void updateO I
balancelabel .setText( "Balance: " + model.getBalanceO );
J
II d acesso ao valor introduzido no campo
public double getAmount() 1
J
II supe que o usuri o in t roduziu um nme ro vlido
ret urn Oouble.parseDouble( amoun t Fiel d. getText() ) ;
II insere o controlador dado no modo de vi sual izao. permite que um objeto
externo configure o controlador
publ ic void attachController( BankAccountCont roller controller ) I
II cada modo de visualizao s pode t er um cont rolador; portanto. remove
o antigo primeiro
if( thi s.control ler Jw nul l ) ( Il remove o control ador antigo
depositButton.removeActionlistener( cont roller );
withdrawButton . removeActionlistener( controller );
J
00 e programao da inte rface com o usurio
LI STAGEM 13.4 BankAccountView. java (continuao)
}
}
thiS.contro11er I control l er;
deposi tButton.addActi onListener( contro1ler );
withdrawButton. addActi onListener( contro1 l er lj
protected BankAccountContro11er makeContro11er() {
return new BankAccountController( this , mode1 )j
}
private void buildUIO {
setLayout( new BorderLayout() ) i
II as socia cada boto a uma st r i ng encomendada
II o controlador usar! essa stri ng para i nterpretar eventos
depositButton.setActionCommand( DEPOSIT )i
wit hdrawButton.setAct ionCommand( WITHORAW l;
II constri a tel a
JPanel buttons new Jpanel ( new BorderlayoutO ) i
JPanel balance new Jpanel( new Borderlayout() ) j
buttons .add( depositButton, BorderLayout.WEST lj
buttons. add( withdrawButton , BorderLayout.EAST };
balance.add( balanceLabel, BorderLayout.HORTH );
balance.add( amountField, Borderlayout.SOUTH );
add( balance , Borderlayout . NORTH );
add( buttons , Borderlayout.SOUTH ) ;
}
299
o construtor dc BankAccountView aceita uma referncia para um BankAccount Model. Na cri ao,
BankAccountView se regi stra no modelo, cria e se anexa ao seu controlador e constri sua UI. O
modo de visuali zao usa o modelo para recuperar todas as informaes de que necessita para a
exibio. Quando saldo mudar, o modelo chamar o mtodo updateO do modo de visual iza-
o. Quando esse mtodo for chamado, o modo de visualizao atualizarn sua tela de saldo.
Normalmente, um modo de visualizao criar seu prprio controlador, como BankACcountView
faz dentro do mtodo factory makeControll erO. As subclasses podem sobrepor esse mtodo
factory para cri ar um controlador diferente. Dentro do mtodo attachControll er(), o modo de
visualizao registra o controlador nos botes de depsito e saque, para que o controlador possa
receber event os do usurio.
Voc notar, entretant o, quc o modo de visualizao primeiro remove qualquer cont rol ador pre-
viamente existente. Um modo de visual izao normalmente ler apenas um controlador.
Dia 13
Voc tambm notar que attachControll er() um mtodo publico. Usando esse mtodo, voc
pode trocar de cOluroladorsem ter que fazer uma subclasse do modo de visuali zao. Esse mto-
do pennite que voc crie diferentes cont roladores e passe-os para o modo de visualizao. O
controlador que voc ver na prxima seo interpretar os eventos do usurio exatamente como
Vi sua 1 BankAccount os interprelava (apenas com uma li geira modificao). Nada o impede de es-
crever controladores que bloqueiem o usurio ou limitem o que ele pode fazer.
Ao contrri o de um modo de visuali zao, que s pode ter um controlador por vez, um modelo
pode ter mui tos modos de visualizao diferentes. A Listagem 13.5 apresent a um segundo modo
de visualizao para a conta bancria.
LI STAGEM 13.5 BankAccount CLV . java
publ i C class BankAccountCLV implements Observe r {
}
private BankAccountModel model :
publ ic BankAccountCLV( BankAccountModel mode l ) {
this.model mode l :
thi s.model. register( this ) ;
}
publ ic voi d updateO {
System.out.println( ~ u r r e n t Balance: $" + model.getBalanceO ) :
}
BankAccountCLV si mplesmente imprime o saldo na li nha de comando. Embora esse comporta-
ment o seja si mples, BankAccountCLV um modo de visualizao alternativo para BankAccount-
Model. Voc notar que esse modo de visualizao no exige um controlador, pois ele no acei la
eventos do usurio. Nem sempre voc precisa fornecer um cont rolador.
DICA
Um modo de visualizao pode nem sempre aparecer na tel a.
Tome como exemplo um processador de textos. O modelo do processador de
textos controlar o texto introduzido, a formatao, notas de p de pgina etc.
Um modo de visualizao exi bir o texto no editor principal; entretant o, outro
modo de visual izao poder converter os dados do modelo para o f ormato
POF, HTMl ou Post script e, em seguida, grav-lo em um arquivo. O modo de
visualizao que grava em um arqui vo no aparece na tela; em vez disso, o
modo de visualizao exibe em um arquivo. Out ros programas podem ent o
abrir, ler e exibir os dados do arquivo.
00 e programao da interface com o usurio 301
o controlador
o controlador responsvel por:
Interceptar os eventos do usurio do modo de visualizao
Interpretar o evento e chamar os mtodos corretos do modelo ou modo de visualizao
Regist rar-se no modelo para notificao de mudana de estado, se estiver interessado
O controlador at ua como a cola entre o modo de visualizao c o modelo. O controlador inter-
cepta eventos do modo de visualizao e depois os transrorma em pedidos do modelo ou do
modo de visualizao.
NOTA
Um modo de visualizao t em apenas um controlador e um controlado tem
apenas um modo de visualizao. Alguns modos de visualizao permitem
que voc configure seu controlador diretamente.
Cada modo de vi sualizao tem um controlador e toda a interao com o usurio passa por esse
controlador. Se o controlador ror dependente das inronnaes de estado, ele tambm ser regis-
trado no modelo para notificao de mudana de estado.
Implementando o controlador
Com um modelo e um modo de visuali zao j criados, resta apenas construir o controlador de
BankAccountView. A Listagem 13.6 apresenta o controlador do modo de visualizao.
LISTAGEM 13,6 BankAccountControll er . java
import java.awt.evento.Actionlistener;
import java . awt.evento.Act ionEvent;
public class BankAccountCon troller impl ements Actionlistener {
I
private BankAccountView view;
private BankAccountModel model o
publiC BankAccountController( BankAccountView view, BankAccountModel mode l )
}
this.view view;
this. mode l model;
publiC void actionPerfonmed( ActionEvent e ) {
Str i ng command z e.getActionCommand() ;
double amount view, getAmount();
if( command .equals( view.WITHDRAW ) ) {
Dia 13
LI STAGEM 13.6 BankAccountController.java (continuao)
J
J
mode l. withdrawFunds( amount };
}else 1f( command.equals( view.OEPOSIT ) } {
model .depositFunds( amount };
J
Na construo, o cont rolador aceita uma referncia para o modo de visualizao e para o mode-
lo. O controlador usar o modo de visuali zao para obter os valores introduzidos no campo de
entrada. O controlador usar o modelo para realmente sacar e depositar dinheiro na conta.
BankAccountController em si muito simples. O controlador implementa a interface Action-
li stener de modo que possa receber eventos do modo de visualizao. O modo de visuali zao
cuida do regi stro do cont rolador para event os, de modo que o controlador no precisa fazer nada
a no ser interpretar eventos, quando os receber.
Quando o controlador recebe um evento, ele verifica o comando do evento para determinar se o
evento um saque ou um depsito. Em qualquer caso, ele faza chamada correspondente no mo-
delo. Ao contrrio do VisualBankAccount original, o controlador s precisa chamar deposit-
Funds() ou wi thdrawFunds () . Ele no precisa mais se certificar de que o valor do saque no seja
maior que o saldo, pois agora o modelo cui da desse detal he do dominio.
Reunindo o modo de visualizao e o controlador
A Li stagem 13.7 apresenta um pequeno metodo main que rel ne o modelo e dois modos de vi sua-
I izao. O mtodo ma i n no precisa fazer nada no controlador, poi s o modo de visualizao cuida
desse detal he.
LI STAGEM 13.7 Reuni ndo o modelo , modos de visualizao e o controlador
import java.awt.evento.Windowlistener;
import java.awt.evento.WindowAdapter i
import java.awt.evento.WindowEvent;
import javax.swing.J Frame i
public class MVCOriver (
publ i c static void main( St ring [] args ) {
BankAccountModel model
BankAccountView view
BankAccountCLV clv
new BankAccountModel( 10000.00 };
" new BankAccountView( model );
new BankAccountCl V( mode l )i
J Fr ame frame z new JFrame();
00 e programao da interface com o usurio 303
LI STAGEM 13.7 Reunindo o modelo, modos de visualizao e o controlador (cont . )
WindowAdapter wa new WindowAdapter() {
I
I
publ1c void windowClosing( Wi ndowEvent e ) I
Sys tem.e xit( O l i
I
frame.addWindowlistener( wa )i
frame . getContentPane().add( view li
frame . pack() ;
frame. showO i
o pri meiro mtodo ma i n cria uma instncia do modelo. Quando o mtodo mai n tem o modelo,
pode ento criar vrios modos de visualizao. No caso de BankAccountView, o mtodo mai n tam
bm preci sa incorporar o modo de visualizao em um quadro, para que o modo de visualizao
possa ser exibido. A Figura 13.2 ilustra a sada resultante.
FIGURA 13.2
Um ",odeio de COI/Ia
bol/cria com ,rias modos
de I"isllali:a(;Q.
Se voc executar MVCOri .... er, ver dois modos de visualizao separados no mesmo modelo.
Usando o padro MVC, voc pode cri ar quantos modos de visuali zao de seus modelos subja
cernes preci sar.
Problemas com o MVC
Assim como acontece com qualquer projeto, o MVC tem suas deficincias e tambm seus pon
tos crticos. Os problemas incluem:
Uma nrase nos dados
Um rorte acoplamento entre o modo de visualizao/controlador e o modelo
Uma oportunidade de ineficincia
Dia 13
A gravidade dessas defi cincias depende do problema que se est resolvendo e seus requisi tos.
Uma nfase nos dados
Em uma escala 00 de pureza, o padro MVC no se classifica prximo ao topo, devido a sua
nfase nos dados. Em vez de pedir a um objeto para que faa algo com seus dados, o modo de vi sua-
lizao pede seus dados ao modelo e depois os exibe.
Voc pode di minuira gravidade desse problema, exibindo apenas os dados que retirado modelo.
No reali ze processamento adicional nos dados. Se voc se achar reali zando processamento ex-
tra nos dados, aps recuper-l os ou antes de chamar um mtodo no modelo, si'lo boas as chances
de que o modelo deve fazer esse trabalho para voc. Existe uma linha tnue entre fazer muito e
fazer o que necessri o nos dados. Com o passar do tempo, voc aprende r a diferenciar entre
fazer muito com os dados e fazer apenas o que necessri o.
DICA
Se voc verificar que repete o mesmo Cdigo em cada modo de visualizao,
considere a colocao dessa lgica no model o.
Evitar o padro MVC unicamente por motivos de pureza pode insultar algumas realidades da
programao. Tome como exemplo um site Web. Algumas empresas impem uma scparai'lo
clara ent re apresentai'lo (o modo de visualizao) e a lgica corporati va (o modelo). A imposi-
o de tal separao tem uma base corporati va vlida: os programadores podem programar e o
pessoal li gado ao contedo pode escrever contedo. Retirar o contedo da camada de programa-
o signi fi ca que quem no for programador pode criar contedo. Impor o contedo na camada
de programao significa que a pessoa que est escrevendo contedo deve ser um programador
ou que um programador precisa pegar o contedo e incorpor- lo dent ro do cdigo. mui to mais
dificil atualizar um si te, se voc incorporar contedo no cdigo.
A realidade tambm di z que os requisitos no so definiti vos, muito menos conhecidos. Nova-
ment e, o sit e Web se constitui em um exemplo excelent e. Um sit e Web precisa gerar cdigo
HTML para exibir em um navegador da Web. E quanto aos POAs, telefones celul ares e outros
di spositivos de exibio? Nenhum deles usa I-ITML bsica. E quanto daqui a seis meses? So
boas as chances de que vo existir outras formas de exibio. Para satisfazer requisitos desco-
nhecidos, voc precisa de um projeto que seja fl exvel. Se voc tiver um sistema muito esttico,
com requisitos bem definidos, poder usar uma allemativa, como um PAC. Se voc no tiver
sorte sufici ente para ter tais requisitos claros, precisar considerar o MVC.
Acoplamento forte
o modo de visualizao e o cont rolador so fortement eacoplados int erface pblica do modelo.
As alteracs na interface do modelo exigiro alteraes no modo dc visualizao e no controla-
dor. Quando lisa o padro MVC. voc supe impli citamente que o modelo estvel, e provvel
00 e programao da interface com o usurio 305
que o modo de visualizao mude. Se esse no for o caso, voc precisar escol her um projeto di-
ferente ou estar preparado para fazer alteraes no modo de visualizao e no controlador.
O modo de visualizao e o controlador tambm so intimamente relacionados entre si. Um con-
trolador quase sempre usado exclusivament e com um modo de visualizao especifico. Voc
pode tentar encontrar reut il izao atravs de um projeto cuidadoso; mas mcsmo que no encon-
tre, o padro MVC ainda fornece uma boa diviso de responsabil idades ent re os objetos. A 00
no simplesmente um meio de reuti li zao.
Ineficincia
Voc deve tomara cuidado de evitar ineficincias ao projetar e implementar uma UI baseada em
MVC. As inelicincias podem aparecer no sistema em qualquer parte da tdade MVC.
O modelo deve evi tar a propagui'o de notificaes de mudana de estado desnecessrias para
seus observadores. Um modelo pode enfi leirar notificaes de mudana relacionadas para que
uma notificao possa signilicar muitas mudanas de estado. O model o de evento A WT (Abstract
Window Toolkit) da linguagem Java usa essa estratgia para redesenhar a tela. Em vez de redese-
nhar aps cada evento, A WT enfi leira os eventos e realiza uma nica operao para redesenhar.
Ao projetar o controlador e o modo de visualizao, talvez voc queira considerar a colocao
dos dados na memria cache, caso a recuperao de dados do modelo seja lenta. Aps uma noti-
ficao de mudana de estado, recupere apenas o estado que mudou. Voc pode aumentar o pa-
dro do observador para que o modelo passe um identificador para o mtodo update(). O modo
de visualizao pode usar esse identificador para decidi r se precisa ou no se atualizar.
Resumo
A int erface com O usurio uma parte importante de qualquer sistema. Para alguns, ela pode ser
a nica parte do sistema com a qual eles interagem; para esses, a UI ri o sistema. Voc sempre
deve encarar a anlise, o projeto e a implementao da UI exatamente como encara qualquer ou-
tra parte do sistema. Uma UI nunca deve ser uma cogitao posteri or ou algo colocado no siste-
ma no ltimo momento.
Embora existam muitas estratgias para o projeto da UI, o padro MVC fornece um projeto que
oferece Oexibilidade, desacoplando a UI do sistema subjacente. Mas, assim como acontece com
qualquer outra decisi'lo de projeto, voc ai nda precisa ponderar os prs e contras do MVC, antes
de decidir utiliz- lo. O MVC no o exime das reali dades de seu sistema.
Perguntas e respostas
P Sua classe BankAccountModel contm toda a lgica do sistema. O modelo sempre pre-
cisa conter a lgica ou ele pode atuar como um gateway para o sistema real?
Dia 13
,
R Depende. As vezes, o modelo agir como um gateway para o sistema; outras vezes, o
modelo ser incorporado dentro do sistema real. Tudo se resume a uma deciso de proje-
to. Em qualquer caso, a UI no tem meios de saber se o modelo al ua como um gateway ou
no.
P Na Listagem 13.6, voc escreveu:
i f( command.equals( vlew.WITHORAW ) ) I
model.withdrawFunds( amount ) ;
I else if( command.equals( view.DEPOSIT ) ) I
model.depositFunds( amount );
J
Isso no lgica com estruturas condicionais? Achei que voc tinha dito que lgica
com estruturas condicionais considerada 'm' 00.
R Si m. Esse um exemplo de lgica com estruturas condicionais.
Para manter esse exemplo simples, decidimos tornar o controlador um Act i onL is tener
que manipulasse os dois eventos. Em uma implementao real, voc pode evi tar a lgica
com estrut uras condicionais capturando o evento ori ginal dentro do prprio modo de vi-
sualizao e fazendo com que o modo de vi suali zao gere seus prprios eventos perso-
nalizados. Por exemplo, o modo de visualizao poderia gerar eventos de deps ito e
saque. O cont rolador poderia receber cada um desses evelllOS separadamente. Talvez o
controlador implement asse os mtodos depos i tPerformed () e wi thdrawPerformed (). O
modo de visualizao chamaria o mtodo correto no control ador, dependendo do evento;
assim, no haveria mais nenhuma estrutura condicional, mas um exemplo muito mais di -
ficil de eruender.
P Certo. Sua resposta anterior me fez sentir um pouco melhor. Mas se voc imple-
mentar o controlador conforme explicado anteriormente, o modo de visualizao
no ter de executar lgica com estrutura condicional para descobrir qual boto
chamou o evento?
R No. O modo de visuali zao pode evitar a lgica com estruturas condicionais fornecen-
do um receptor separado para cada boto. Quando existe uma correspondncia de um
para um entre um element o e seu receptor, voc no precisa usar lgica com estrut uras
condi cionais para descobrir onde o evento se origina. (Veja no Exercicio 2 a implemen-
tao alternativa.)
Workshop
As perguntas e respostas do teste so fornecidas para seu melhor entendimento. Veja as respos-
tas no Apndice A, "Respostas".
00 e programao da interface com o usurio 307
Teste
I. Como a anlise, o projeto e a implementao da UI so diferentes do restante do sistema?
2. Por que voc deve desacoplar a UI do sistema subjacent e?
3. Quais so os tres componentes da trade MVC?
4. Quais so as duas alternativas para o padro MVC?
5. Descreva as responsabi li dades do modelo.
6. Descreva as responsabi li dades do modo de visuali zao.
7. Descreva as responsabi li dades do controlador.
8. Quantos modelos um sistema pode ter? Quantos modos de visual izao um modelo pode
ter? Quantos controladores um modo de visualizao pode ler?
9. Quais inefi cincias voc deve evitar ao usar o padro MVC?
10. Quai s suposics o padro MVC faz?
I I. Qual a hi stria do padro MVC? (Note que esta pergunta exige que voc reali ze uma
rpida pesquisa na Web.)
Exerccios
I. A Listagem 13.8 apresenta uma classe Employee. Altere a classe Empl oyee de modo que
ela possa registrar e reti rar o registro de receptores, assi m como inform-los de altera-
es de estado. A Li slagem 13.2 apresenta uma interface Obse r ver que voc pode usar
para este exercicio.
LI STAGEM 13.8 Emp l oyeeModel. java
publiC abs tract class Employee (
private Stri ng first_name :
private Stri ng last_name :
pr;vate double wage:
public Employee(String first_name , String last_name.double wage) (
this.first_name = first_name;
thi s.last name last_name :
thi s.wage wage :
}
publ ic double getWage() (
return wage:
}
Dia 13
LI STAGEM 13.8 Empl oyeeModel. java (continuao)
J
publiC void setWage( double wage ) (
this . wage wage:
J
publiC String getFi r stName() (
return first_name :
J
public String getlastName(){
return last_name ;
J
public abstract double calculatePay{):
publ ic abstract double calculateBonus() :
publiC void pri ntPaycheck() (
J
String full _name last_name + ", " + first_name;
System. ouLprintln( MPay: " + full name + " $" + calculatePayO ) :
2. Usando as li stagens 13.9 e 13. IOcomo ponto de partida, escreva um novo BankAccount-
Control 1 er que implemente a nova interface BankActiv i tyl i stener e manipule os even-
tos sem lgica com estruturas condicionais.
A Li stagem 13.9 apresent a um BankAc t i v i tyEvent e seu BankAc t i v i tyl is tener corres-
pondente.
LISTAGEM 13.9 BankActivitylistener.java e BankActivityEvent.java
publ ic inter fa ce Ba nkActivitylistener {
J
public vold withdrawPerformed( BankActivityEvent e ):
pUbli c voi d depositPerformed ( BankActivityEvent e ):
publ ic c l ass BankActivityEvent (
private double amount:
pUblic BankActivityEvent( doubl e amount ) {
thls.amount amount;
00 e programao da interface com o usurio 309
LISTAGEM 13.9 BankActivitylistener.java e BankAct ivityEvent. java (continuao)
}
}
public double getAmount() {
return amount:
}
A Li stagem 13. I O apresenta lima BankAccount V i ew atual izada. Esse BankAccountVi ew in-
tercepta os eventos ActionEvent do boto e encarninha o novo evento BankActivity-
Event para o controlador.
LISTAGEM 13.10 BankAccountView.java
import javax . swlng .JPanel :
i mport javax. swing.Jl abel :
i mport java.awt .Borderlayout :
i mport javax . swing.JText Field :
i mport javax.swing.JButton:
i mpo rt java.util.Arraylist:
i mpo rt java.awt.event.Actionlistener;
import java.awt.event .Ac t ionEvent;
publiC class BankAccountView extends JPanel implement s Observer I
public final static String DEPOSIT "Deposit" :
public final static String WITHDRAW " Withdraw";
private BankAccountModel mode l :
private BankAccountController cont rol leri
II Elementos da GUI , aloca tudo previament e para evi tar valores nulos
private J8utton depositButton - new Jbutton( DEPOSI T ):
private J8utton wit hdrawButton - new Jbut ton( WITHDRAW )i
private JTextFleld amountField new JTextFiel d() :
private Jlabel balancelabel new Jlabel ():
publ ic 8ankAcceuntView( BankAccountModel mede l ) (
this.model mode l:
thi s. model.register( this ) :
attachController( makeControl l er() ) :
buildUI O;
}
II chamado pelo mode lo, quando este muda
Dia 13
LISTAGEM 13.10 BankAccountView. java (continuao)
publiC void update() {
balancelabel.setText( "Balance: + model.getBalanceO );
J
II codifica o cont rol ador dados no modo de visualizao. permite que objet o
externo con fi gure o controlador
public voi d attachController ( BankAccount Controll er controller ) {
this . control ler cont roller:
J
protected Ba nkAccountController makeCont roller () {
return new BankAccountController( this. model );
J
II d acesso ao valor i ntroduzido no campo
private double getAmount() {
J
II pressupe que o usurio i ntroduz i u um nmero vlido
return Double.parseDouble( amount Field .getText() ) ;
private void fireDeposHEventO {
J
BankActivityEvent e new BankActivityEvent ( getAmount() );
control l er.depositPerformed ( e ) :
pr ivate voi d fireWHhdrawEventO {
J
BankActivityEvent e " new BankActivi tyEvent ( getAmount() ) ;
control l er.withdrawPerformed( e )i
private void buildUI () {
setLayout( new BorderLayoutO }i
II associa cada boto a uma string de encomenda
depositButton . setAc ti onCommand( DEPDS IT li
withdrawButton.setActionCommand( WI THORAW l i
II const ri a tela
JPane l buttons new Jpanel ( new BorderLayoutO ) i
JPanel balance" new Jpanel ( new BorderlayoutO l;
buttons.add( depos itButton . Borderlayout.WEST l:
but t ons . add( wit hdrawBut ton. Borderlayout.EAST );
bal ance .add( bal ancelabel, BorderLayout.NORTH )i
balance.add( amountField . BorderLayout. SOUTH };
add( balance . Borderlayout.NORTH ) ;
00 e programao da interface com o usurio
LISTAGEM 13.10 BankAccountView. java (continuao)
J
J
add( buttons. BorderLayout.SOUTH );
depositButton.addAct ionLi stener(
new ActionListenerO I
J
J ;
publi c voi d actionPer formed( Action[vent e ) {
f ireOeposit[vent();
J
withdrawButton.addActionListener(
new ActionListenerO I
J
J ;
public void actionPerformed( Act i onEvent e ) {
fireWithdraw[vent() ;
J
311
,
PAGINA E B NCO
SEMANA 2
DIA
Construindo software confivel
atravs de testes
Quando voc usa programao orientada a objetos, se esfora para escrever software natural,
confivel, reutilizvel, manutenvel, extensvel e oportuno. Para ati ngi r esses objetivos, voc
deve entender que a 'boa' 00 no acontece por acidente. Voc deve atacar seus problemas atra-
vs de uma anlise c um projeto cuidadosos, e ao mesmo tempo nunca perder de vista os princ-
pios bsicos da POO. Somente enloa 00 pooe comear a cumpri r suas promessas. Mesmocom
uma anlise e um projeto cuidadosos, entretant o, a POO no uma fnnuta mgica. Ela no o
proteger de seus prprios erros ou dos erros dos outros. E erros acontecero! Para produzir soft-
ware confive l, voc precisa test-lo.
Hoje voc aprender:
Onde os testes entram no processo iterativo
Sobre os diferent es tipos de testes
Como testar suas classes
Como testar software incompleto
O que voc pode fazcr para escrever cdigo mai s confivel
Como tornar seus testes mais eficazes
Dia 14
Testando software 00
A 00 no evitar que erros aconteam em seu software. Mesmo os melhores programadores co-
metem erros. Os erros so nonnalmente considerados como um defeito de software que surge de
um erro de digitao, de um erro na lgica ou apenas por um engano bobo comet ido durante a co-
di ficao. Embora a implementao de um objeto seja uma fonte de erros comum, eles aparecem
em outras formas.
Erros tambm podem resultar quando um objeto usa out ro incorrctamente. Os erros podem at
ser provenientes de falhas bsicas na an! ise ou no prprio projeto. Por sua prpria natureza, um
sistema 00 repleto de objetos interagi ndo. Essas interaes podem ser a fonte de todos os ti-
pos de erros.
Felizmente. voc pode proteger seu software de erros, atravs de testes de software, onde pos-
svel validar a anlise, o projeto e a implementao de seu software.
Assim como a 00, o t est e no uma soluo mgica; ext remamente difci l
testar seu software completamente. O nmero total de caminhos possiveis
atravs de um programa no t rivial torna difci l e demorado obt er cobertura to-
tal do cdigo. Assim, mesmo um cdigo testado pode abri gar erros ocultos.
O melhor que voc pode fazer realizar uma quantidade de testes que garan-
tam a quali dade de seu cdigo, enquant o tambm permitam cumprir seus pra-
lOS finais e permanecer dent ro do oramento. A 'quantidade' real de t estes que
voc realizar depender da abrangncia do proj et o e de seus prprios nveis
de bem-estar.
Testes e o processo de desenvolvimento de
software iterativo
A Figura 14. I i lustra a iterao apresentada pela primeira vez no Captulo 9, " I ntroduo anl i-
se orient ada a objetos". O teste a lti ma etapa de uma iterao.
Antes de voc sair de lima it erao, o teste uma etapa importante. O estgio de testes verifica se
todas as al teraes fe itas por voc durante essa iterao no danificaram qualquer funcional ida-
de existente. O estgio de testes lambm verifica se toda nova funci onalidade adicionada agora
funci ona corretamente. Por esses motivos, os testes realizados antes de se sair de uma iterao
so freqent emente referidos como testesfimcionais Oll de aceitao.
FIGURA 14.1
Uma ileratio.
NOTA
Construindo software confivel atravs de testes 315
Inicio da itera60
'\
An6li ..
/

Projlll1O
..-..j Implementalo
l
Testa
...
Fim di itlra60
o test e no fi nal de uma iterao um marco importante. Para sair da iterao,
seu sistema deve passar pelos testes; entretanto, t ambm devem ocorrer tes-
tes durante outros estgios de uma it erao. As li es de hoje most raro a
voc como usar testes eficientemente, durante a impl ementao e estgios de
t estes da iterao.
Torne os testes um objetivo e algo que voc faz por todo o desenvol vimento.
Se voc no pensar nos testes at o final do desenvolvimento, poder desco-
bri r que no possivel testar seu software. Em vez disso, voc precisa desen-
volver pensando nos testes. Voc deve tornar os testes uma parte integrante
do processo de desenvol vimento.
Se erros forem encontrados, voc dever voltar e corrigi-l os. Normalmente, voc voltar para a

implementao e tentar corri gi r o problema no cdigo. As vezes, isso tudo que voc preci sar
fazer: bastar corrigir a implementao, testar tudo novamente e prosseguir. Entretanto, os erros
podem ser provenientes de uma fal ha de projeto ou mesmo de um requi si to ignorado ou
mal -entendido. Talvez voc precise voltar ao projeto ou anli se, antes de poder corrigir um
erro na implementao.
ApS corrigir um erro, no suficiente apenas testar o erro corrigido. Em vez
disso, voc precisa realizar todos os testes. Ao corrigir um erro, voc pode in-
troduzir facil mente um ou mais erros novos!
Um mal-entendido na anlise signi fi ca que o sistema no funcionar confonne o cl iente espera.
Um sistema deve funcionar confomle o esperado e o cliente que conduz o sistema deve concor-
dar com o que esperado do comportamento. No apenas voc precisa testar o cdigo quanto a
Dia 14
falhas de implementao, como tambm precisa testar o cdigo para ver se ele funciona confor-
me o esperado.
Para testar um sistema, voc precisa escrever e executar casos de teste. Cada caso de teste testar
um aspecto especifico do sistema.
Novo TERMO
Um caso de teste o bloco de construo bsico do processo de teste. O processo de
teste executa vrios casos de teste para poder validar completamente um sistema.
Cada caso de teste consiste em um conj unto de entradas e sadas esperadas. O teste executar um
caminho especifico atravs do sistema (caixa branca) ou testar algum comport amento de fi nido
(caixa preta).
Um caso de teste exerci ta uma funcionalidade especfi ca para ver se o sistema se comporta como
deveria. Se o sistema se comportar conforme o esperado, o caso de teste passa. Se o sistema no
se comportar conforme o esperado, o caso de teste falha. Um caso de teste falho indica que existe
um erro no sistema. Voc sempre quer que todos os seus casos de teste passem 100% das vezes.
No tente ignorar um caso de teste fa lho, se cem outros casos passarem. Todo teste deve passar
ou voc no poder cont inuar seu trabalho!
Existem duas maneiras de basear seus casos de teste: teste de caixa preta e de caixa branca. Uma
estratgia de teste efi caz ter uma mi stura de casos de teste baseados em caixa preta e em caixa
branca.
Novo TeRMO
O teste de caixa preta testa se o sistema funciona confonne o esperado. Dada uma
entrada especlica, o teste de caixa preta testa se a sada ou comportamento correto,
vis vel externamente, resulta confonne definido pela especi fi cao da classe ou do sistema.
Novo TERMO
No lesle de caixa branca. os testes so baseados unicamente na implementao de
um mtodo. Os testes de caixa branca tentam atingir 100010 de cobertura do cdigo.
Ao testar classes indi viduais, o teste de caixa preta baseado nos requisitos funcionais da classe.
Ao testara sistema inteiro, o teste de caixa preta baseado nos casos de uso. Em qualquer caso, o
teste de caixa preta verifica se um objeto ou sistema se comporta conforme o esperado. Por
exemplo, se um mtodo deve somar dois nmeros, um teste de caixa preta enviar dois n(J meros
para o mtodo e, em seguida, verificar se a sada ou no a soma correta dos dois nmeros. Se
um sistema deve permi tir que voc adicione e remova itens de um carrinho de compras, um teste
de caixa preta tentar adicionar e remover itens do carri nho.
O teste de caixa branca, por outro lado, baseado na implementao de um mtodo. Seu objetivo
garanti r que cada desvio do cdigo seja executado. O teste de caixa preta avaliado para cobrir
apenas de um tero metade do cdigo real. Com o teste de caixa branca, voc projeta seus testes
de modo a exercitar cada desvio do cdigo e na esperana de el iminar todos os erros latentes.
DICA
Construindo software confivel atravs de testes 317
Os testes de caixa branca, exceto quanto aos programas mai s simples, rara-
mente podem alcanar uma cobertura razovel da combinao de caminhos
atravs do programa. Existem dois passos que voc pOde dar para melhorar a
eficincia de seus testes:
Escreva seus programas de modo que eles tenham um numero mnimo de
caminhos .
Identi f ique caminhos crticos e certifique-se de test-los.
Por exemplo, se um mtodo divide dois nmeros e existe um desvio de erro que executado
quando voc tenta dividir por 0, ser preciso garantir que exista um caso de teste que exerci te
essa condio de erro. A no ser que seja especificado na documentao da interface, voc sabe-
ria a respeito desse desvio examinando o prpri o cdigo. Assi m, os testes de caixa branca devem
ser baseados no prprio cdi go.
Em qualquer caso, os testes de caixa preta e de caixa branca governam o modo como voc cria
seus casos de teste. Cada um desempenha um papel importante na forma de teste que voc pode
executar.
Formas de teste
No todo. existem quatro fOnllaS importantes de teste. Esses testes variam de testes de nvel mais
baixo, que examinam osobjetos individuais, at os testes de nvel mais alto, que exami nam o sis-
lema inteiro. A execuo de cada um ajudar a garanti r a qualidade global de seu soft ware.
Teste de unidade
o teste de unidade a unidade de nvel mai s baixo dos testes. Um leste de unidade examina ape-
nas um recurso por vez.
Novo TERMO
Um leslede unidade o disposit ivo de teste de nvel mais baixo. Um leste de unidade
envia uma mensagem para um objeto e depoi s veri fica se ele recebe o resultado espe-
rado do objeto. Um teste de uni dade verifica apenas um recurso por vez.
Em termos de 00, ulllteste de unidade examina uma nica classe de objeto. Um teste de unidade
verifica um objeto enviando uma mensagem e verifica se ele retorna o resultado esperado. Voc
pode basear os testes de unidade no teste de caixa preta e no de caixa branca. Na verdade, voc
deve realizar ambos, para garantir que seus objetos funcionem corretamente. Embora cada clas-
se escrita deva ter um teste de unidade correspondente, voc provavelmente deve escrcvcrocaso
de teste ant es de escrever a classe. Voc vai ler mais sobre esse ponto posteri omlcnte.
Hoje, focalizaremos o teste de unidade, pois ele fundamental para a escrita de software 00
confivel. Na verdade, voc deve reali zar os testes de unidade por todo O desenvolviment o.
Dia 14
Teste de integrao
Os sistemas 00 so constit uidos de objetos que interagem. Enquanto os testes de unidade exa-
minam cada classe de objeto isoladamente, os testes de integrao verificam se os objetos que
compem seu sistema interagem corretamente. O que poderia funcionar isoladamente pode no
funci onar quando combinado com outros objetos! As fontes comuns de erros de integrao so
provenientes de erros ou mal-entendidos a respei to dos fomlatos de entrada/sada, confl it os de
recurso e seqincia incorreta de chamadas de mtodo.
Novo TERMO
Um leSle de inlegraiio verifi ca se dois ou mais objetos funcionam em conjunto cor-
relam ente.
Assim como os testes de unidade, os testes real izados durante os testes de integrao podem ser
baseados nos conceitos de caixa branca e de caixa preta. Voc deve ter um teste de integrao
para cada iterao importante no sistema.
Teste de sistema
Os testes de sistema veri fi cam se o sistema inteiro funciona conforme descri to pelos casos de
uso. Enquant o executa testes de sistema, voc tambm deve testar o sistema de maneiras no
descri tas pelos casos de uso. Fazendo isso, voc pode veri fi car se o sistema manipula e se recu-
pera nonnalmente de condies imprevistas.
DICA
Tente fazer estes testes em seu si stema:
Testes de ao aleat ri a
Os testes de ao aleatria consistem em tentar executar operaOes em ordem
aleatria.
Testes de banco de dados vazio
Os testes de banco de dados vazio garantem que o sistema pode falhar nor-
malmente, caso exista um probl ema maior no banco de dados.
Casos de uso mutantes
Um caso de uso mutante transforma um caso de uso vlido em um caso de uso
invlido e garante que o sistema possa se recuperar corret amente da interao.
Voc fi caria surpreso com o que um usurio pode tentar fazer com seu sistema. Ele pode no cair
sob um dos casos de uso ' normais'; portanto, melhor estar preparado para o pi or.
Novo TERMO
Um leste de sistema examina o sistema inteiro. Um teste de sistema verifica se o sis-
tema funciona confonne mencionado nos casos de uso e se ete pode manipular nor-
malmente sit uacs incomuns e inesperadas.
Os testes de sistema tambm incluem testes de esforo e de desempenho. Esses testes garant em
que o sistema sati sfaa quaisquer requisitos de desempenho e possa funcionar sob as cargas es-
Construindo software confivel atravs de testes 319
peradas. Se possivel, melhor executar esses testes em um ambiente que corresponda o mxi mo
possvel ao ambient e de produo.
Os testes de sistema so um aspecto importante dos testes de aceitao. Os testes de sistema veri
ficam unidades funcionais inteiras si multaneamente, de modo que um unico teste pode mexer
com muitos objetos e subsistemas diferentes. Para sai r de uma iterao, o sistema deve passar
nesses testes com xi to.
Teste de regresso
Um teste vlido apenas enquanto o que for testado no mudar. Quando um aspecto do sistema
mudar, essa parte - assim como todas as partes dependentes - dever ser novamente testada.
Teste de regresso o processo de repetio dos testes de unidade, integrao e de sistema aps
as alteraes serem feitas.
Novo TERMO
Os te.ltes de regresso examinam as alteraes nas partes do sistema que j foram
validadas. Quando uma alterao feita, a pane que foi alterada - ass im corno to
das as partes dependentes - deve ser novamente testada.
absol utamente fundamental testar novamente, mesmo depois de uma pequena alterao. Uma
pequena alterao pode int roduzir um erro que poderia danificar o sistema inteiro. Fel izment e,
para executar o teste de regresso basta executar novamente seus testes de unidade, int egrao e
sistema.
Um guia para escrever cdigo confivel
Embora cada forma de teste seja importante para a qualidade global de seu software, hoje voc
vai foca li zar o que pode fazer de melhor em seu trabal ho dirio para garantir a qualidade dos sis
temas que escreve. Para escrever cdigo confivel, voc precisa fazer o teste de unidade, apren
der a diferenciar entre condies de erro e erros, e escrever documentao til .
Combinando desenvolvimento e teste
Um fato esquecido na Figura 14.1 que os testes devem ser um processo dinmico. O teste no
deve ser al go a ser evitado, inserido somente no final , feit o por outra pessoa ou completamente
ignorado. Na verdade, podc scr impossvel comear a testar de repente, quando o sistema esti ver
pronto. Em vez disso, voc precisa aprender a comear a testar enquanto desenvolve. Para testar
enquant o desenvolve, voc preci sa escrever testes de unidade para cada classe que criar.
Um exemplo de teste de unidade
Vamos ver um teste de unidade para a classe SavingsAccount, apresentada pela primcira vcz no
Captulo 5, "Herana: hora de escrever algum cdigo". A Listagem 14. 1 apresenta a classe Sa-
vi ngsAccountTes t.
Dia 14
LISTAGEM 14.1 SavingsAccountTest.java
public class SavingsAccountTest (
public s tati c voi d main( St r ing [] args ) I
Savi ngsAccountTest sat : new SavingsAccountTest();
sat.test_applyinglnterest();
J
public vo1d test_applyinglnterest() (
SavingsAccount acct new SavingsAccount( 10000.00, 0.05 );
acct.addlnterestO ;
print_getBalanceResult( acct . getBalance() , 10500 . 00 , 1 );
J
private void print_getBa lanceResult( double actual, double expected, int
- test ) (
if( actual == expected ) ( II passou
System.out.pr i ntln ( "PASS : test I" + test +. interes t applied
- properly ) ;
System. out . println();
) else ( II f alhou
Sys tem.out.println(
- incorrectly " ) :
"FAIl: test '" + test + " interest applied
J
J
J
System.out.println( "Val ue returned:
System.out.pr intln ( "Expected
System.out. pri ntl nO;
value:
" + actual );
" + expected ,;
SavingsAccountTest um teste de unidade que exami na a classe SavingsAccount. Um teste de
unidade pode ser constit uido de vrios casos de teste. Aqui, a classe SavingsAccountTest s6 tem
um caso de teste: tes t _ app l yi ng Interest. O caso de teste test_ app l yi nglnteresl verifica se uma
instncia de SavingsAccount aplica corretamente osjuros em seu saldo. Um teste de unidade pode
ter mui tos casos de teste, mas cada caso de teste deve verificar apenas um recurso do objeto.
Construindo software confivel atravs de testes 321
Sav; ngsAccountTest referido como teste de unidade porque exami na o bloco de construo ou
unidade de nvel mais baixo no mundo 00: o objeto. Um teste de unidade deve exami nar apenas
um objeto por vez. Isso significa que cada objeto deve ser testado, assi m como uma ent idade in-
dependente. Se no for assim, voc no poder testar o objeto. Mesmo que isso seja possvel.
voc poder acabar testando inadvertidamente muitos objetos ao mesmo tempo.
Ao escrever testes de uni dade, voc deve evitar o mximo possvel a validao manual da sada.
Confonne voc pode ver cm test app lyinglnterest, o caso de teste reali za toda a validao ne-
cessria automati camente. FreqUentemente, a validao manual demorada e propensa a erros.
Ao executar casos de teste, voc quer resultados precisos o mais rpido possvel e com o menor
esforo. Caso cont rri o, voc poder comear a negli genciar os testes.
Por que voc deve escrever testes de unidade
Os testes de unidade o ajudam a detectar erros. Se voc danificar algo em sua classe, saber ime-
di atament e, pois o teste de unidade lhe informar. O teste de unidade sua primeira linha de de-
fesa cont ra erros. A captura de um erro em nvel de unidade muito mais fcil de manipular do
que tentar rastrear um erro durant e o teste de integrao ou de sistema.
Os testes de unidade tambm pennitem que voc saiba quando tenninou de escrever uma classe:
uma classe est pronta quando todos os seus testes de unidade passam! Como desenvolvedor,
pode ser extremamente til ter tal ponto final bem definido. Caso contrrio, poder ser di ficil sa-
ber quando uma classe est ' pronta'. Saber que voc terminou e pode prosseguir evita que fiq ue
tentado a acrescentar mais funcionalidade do que precisa em uma classe.
A escrita de testes de uni dade pode ajud-lo a pensar a respeito do projeto de suas classes, espe-
ci al mente se voc escrever seu caso de teste ant es de escrever a classe; entretanto, para escrever
o caso de teste, voc precisa usar sua imaginao e fingir que a classe j existe. Fazer isso pro-
porciona a voc muita liberdade para experimentar a interface de suas classes. Quando terminar
de escrever O teste, voc poder escrever a classe e, em seguida, tudo ser compilado.
,
Os testes de uni dade podem aj ud-lo a refazer seu cdigo. E mais fcil fazer alteraes em seu
cdigo, se voc ti ve r um teste de uni dade, pois assim tem um retorno instantneo em relao s
suas alteraes. Voc no precisa se preocupar muito quanto introduo de erros; voc pode
simplesmente executar seu teste novamente, para ver se algo foi danificado. Usando testes de
unidade, voc no precisa ficar assombrado com a aborrecida pergunta, ;'ser que eu danifiquei
algo?" Voc pode fazer alteraes com mais confiana.
Finalmentc, voc ncm sempre pode estar por peno para testar o sistema. Voc pode mudar para
outros projetas ou outros membros de sua equipe podem precisar reali zar os testes. Os lestes de
unidade pennitem que outra pessoa, que no seja o aut or, teste um objeto.
Dia 14
Escrevendo testes de unidade
Sav; ngsAccountT es t e tes t _ app 1 yi n9 Interes t () so exemplos muito simpl es de teste de unida
de e de caso de teste; entretanto, escrever testes de unidade desde o incio para cada classe, pode
se tornar demorado. Imagi ne um sistema onde voc precise escrever centenas de casos de teste.
Se escrever cada teste de unidade desde o incio, voc acabar fazendo muito trabalho redundan
te. Voc precisa criar ou reut ili zar uma estrut ura de teste.
Novo TERMO
Uma /wrlllllr(l um modelo de domnio reutili zvel. A estrutura contm todas as
classes comuns a um dom nio inteiro de problemas e serve como a base para um apti
cati vo especifico no dom nio.
As classes de uma estrutura deli nem o projeto geral de um apli cativo. Como desenvolvedor,
voc simplesmente estende essas classes e, em seguida, fornece suas prprias classes especificas
para o problema, para cri ar um apl icativo.
No caso de uma estrutura de teste, a estrutura define um esqueleto que voc pode reut il izar para
escrever e executar testes de unidade. Uma estrutura de teste permite que voc escreva testes de
unidade rpi da e convenientemente, eliminando trabalho redundante e propenso a erros. Lem
brese de que ludo que voc programa pode conter erros, at seu cdigo de leste. Ter uma estru
tura bem testada pode resolver muitos erros de teste. Sem uma estrut ura, a sobrecarga extra dos
testes poderia ser suficiente para impedilo de faz los.
Uma estrutura de teste completa conter classes base para escrever testes de unidade, suporte in
terno para automao do teste e ut il itrios para ajudar a interpretar c relatar a sada. Hoje, voc
aprender a usar JUnit, uma estrut ura de teste gratuita, lanada sob a " I BM Public License", para
testar classes Java. Voc pode fazer download da J Uni! a parti r do endereo http://www.junit.orgl.
NOTA
JUnit
o downl oad de JUnit inclui o cdigo-fonte. JUnit tem um projeto excel ente e
voc faria muito bem em estudar o cdigo e a documentao includa. Em par
ti cular, a documentao realiza um excelent e trabalho de documentar os pa
dres de projeto usados para escrever JUnit.
A JUnit fornece classes para escrever testes de unidade, para vali dar a sada e para executar os
casos de teste em urna GUi ou em um ambiente de linha de comando. j uni t. framework.TeslCase
a classe base para defi nir testes de unidade. Para escrever lestes de unidade, voc simplesmente
escreve lima classe que herda de TestCase, sobrepe alguns mtodos e fornece seus prprios m
todos de caso de teste.
Construindo software confi vel atravs de testes 323
NOTA
Ao escrever casos de teste JUnit, voc deve iniciar o nome de qualquer mto-
do de caso de t est e com testo A JUnit fornece um mecanismo que carregar e
executar automaticamente qualquer mtodo que comece com testo
A Listagem 14.2 apresenta uma verso JUnit de Savi ngsAeeountTest.
LISTAGEM 14 ,2 SavingsAecountTest.java
import junit.framework.TestCase ;
import junit.framework,Assert;
publie elass SavingsAeeountTest extends TestCase {
publie void test_applyinglnterest () {
SavingsAceount aeet new SavingsAeeount(10000 .00 , 0,05 );
aect.addlnterest() ;
Assert.assertTrue( "interest appl ied ineorreetly", aeet.getBalaneeO
- 10500.00 };
}
}
public SavingsAecountTest( St r ing name } I
super( name );
}
A verso J Unit de Sav i ngsAecountT es t muito mais simples do que a origi nal. Ao se usar J Unir,
no h mot ivo para reproduzir cdigo de exibio ou testes lgicos. Voc pode simplesmente
usar a classe Assert fornecida pela JUnit. A classe Assert fornece vrios mtodos que recebem
um valor booleano como argumento. Se o valor booleano for fa lso, um erro ser gravado. Ass im,
aqui, o teste passa para Assert o valor booleano retornado pela comparao aeet . getBa 1 ance ()
z= 10500 .00. Se a comparao for avali ada como falsa, JUnit sinalizar um erro.
Ento, como voc execula esses testes?
A JUnit oferece a voc vrias opes para a execuo de seus casos de leste. Essas opes caem
em duas categorias: es/a/icas e dinmicas. Se voc optar por usar o mlodo esttico, precisar
sobrepor o mtodo runTest() para chamar o teste que deseja executar.
Na linguagem Java, o modo mais conveniente escrever lima classe annima para que voc no
precise criar uma classe separada para cada leste que queira execut ar. A Listagem 14.3 mostra a
delarao annima:
I 324 Dia 14
LISTAGEM 14.3 Uma Anonymous SavingsAccountTest
SavingsAccountTest test
new SavingsAccountTest( "test _applyi nglnterest" ) (
public void runTest() I
test_applyinglnterest();
J
J ;
test. run() j
As classes annirnas so convenientes porque elas permitem que voc sobreponha um mtodo
ao instanciar um objeto, tudo sem ter de criar uma classe nomeada em um arquivo separado.
Aqui, o mtodo principal instancia um Savi ngsAccountT es t , mas sobrepe o mtodo run T es t O
para executar o caso de teste tes t _ app 1 yi ng Interes t ().
Novo TERMO
Uma c/asse annima uma classe que no tem um nome. As classes anni mas no
tm nome porque elas so simplesmente definidas ao serem instanciadas. Elas no
so declaradas em um arquivo separado ou como uma classe interna.
As classes anni mas so uma excelente escolha para classes usadas uma lmica vez (se a classe
for pequena). Usando uma classe annima, voc evita a necessidade de criar uma classe nomea-
da separada.
Apesar de serem to convenientes, as classes annimas tm defi cincias. Voc precisar criar
uma para cada mtodo de caso de teste que queira chamar. Se voc tiver muitos casos de teste, o
uso de classes annimas pode exigir muito cdigo redundante.
Para superar essa deficincia, a JUni t tambm fornece um mecanismo dinmico, que procurar e
executar qualquer mtodo que comece com testo Para os propsitos da lio de hoje, contare-
mos com esse mecanismo dinmico.
A JUnit tambm forn ece um mecanismo, conhecido como conjunto de teste,
para executar vrios casos de teste. A JUnit fornece um mecani smo para defi-
nir estaticamente a bateria de testes a serem executados como um conjunto;
entretanto, o mecanismo dinmico pesqui sar e encontrar cada mtodo de
teste. Hoje, contaremos com esse mecanismo automtico para encontrar e
executar os testes.
A JUnit tambm fornece alguns out ros recursos convenientes. Considere a verso atualizada de
SavingsAccountTest , na Listagem 14.4, que tambm testa o mtodo wHhdrawFundsO.
LISTAGEM 14.4 SavingsAccountTest.java
import junit.framework.TestCasej
import junit.framework . Assertj
Construindo software confivel atravs de testes
LI STAGEM 14.4 SavingsAeeountTest.java (continuao)
publiC class SavingsAecountTest extends TestCase (
private SavingsAccount aeet;
publi e void test _applyinglnterest() (
aeet.addlnterest();
325
Assert . assertTrue( "interest applied acet . getBalance()
- 10500.00 );
I
publi c void test_withdrawFunds() t
aect.withdrawFunds( 500.00 )i
Assert . assertTrue ( "i neorreet amount wi thdrawn", acct . getBa 1 ance ()
- 9500.00 );
}
I
proteeted void setUpO (
acet new SavingsAeeount( 10000.00. 0.05 );
I
publie SavingsAeeountTest(String name) I
supere name ):
}
Nessa verso, voc notar que o teste contm dois mtodos novos: test_withdrawFundsO e
setup(). setup() sobrepe um mtodo na classe base TestCase. Sempre que a JUni t chamar um
mtodo de teste, primeiro ela far urna chamada a setup(} para estabelecer o acessrio de teste.
Um acessrio de teste define o conjunto de objetos sobre os quais um teste operar. Estabelecer um
acessri o de leste pode consumira maior parte do tempo que leva para escrever casos de teste.
Novo TERMO
o acessri o de teste prepara o conjunto de objetos sobre os quais um caso de teste
aluar. Os acessrios tambm so convenientes, pois eles permitem que voc compar-
tilhe o mesmo acessrio dentre um conjunto inteiro de casos de tesle, sem ter de duplicar cdigo.
Dia 14
A JUnit garante que os objetos acessrios estaro em um estado conhecido, chamando setup()
antes de executar cada teste. A JUnitlambm fornece um mtodo tearOown{) correspondente,
para realizar toda limpeza do acessri o, depois que o teste for executado.
Para executar seus casos de teste, a J Unit fornece executores de teste para exerci tar e reunir os re-
sultados de um teste. A JUnit fornece uma verso grfi ca e urna verso baseada em linha de co-
mando desse utilitrio.
Para executar SavlngsAccountTest graficamente, basta digitar:
java juni t.swingul .TestRunner
A Figura 14.2 ilustra ajanela principal de lUnit.
FtGURA 14.2
A UllJrincipal de JUII;I.
. . -
u
Usando a UI, voc pode navegar at a classe SavingsAccoun tTest. Uma vez carregada, voc
pode simplesmente executar o teste, pressionando o boto Run.
Conforme a Figura 14.3 mostra, a UI da lUnit exibe o nmero de testes executados, assim como
o nmero de testes fa lhos. A UI tambm fornece uma barra grfica que mostra se os testes falha-
ram ou no.
A J Uni t uma fermmenta excelente, pois ela penn ite que voc receba retorno claro e instantneo
de seus casos de teste. Assim, se aquela voz em sua mente importun-l o com, "e se eu danifiquei
algoT', voc pode descobrir rapidamente, executando novament e seus testes de unidade.
Escrevendo testes de unidade avanados
Vamos considerar um exemplo ligeiramente mais complicado. O Exercicio I do Capitulo I I,
"Reutili zando projetas atravs de padres de projeto", apresentou uma possvel implementao
de um I tem. At ualmente, para apresentar um I tem,voc deve chamar vri os mtodos de obteno
Construindo software confivel atravs de testes 327
e processar os dados para exibio. Infelizmente, solici tar os dados para um objeto no a me-
lhor estratgia de 00. Voc deve pedir ao objeto para que faa algo com seus dados.
FIGURA 14.3
A UI,)riIICipal de JUllil. o/Js
e.T.ecular com xito os casos
de leSfe.
IHt.'PI"'''''''''''
-.-...".""
u
Considere a Listagem 14.5, que apresenta uma implementao alt ernat iva de Item.
LISTAGEM 14.5 Item.java
publlC class Item {
private in t i d;
private int quantity;
private float un1tPrl ce ;
private Stri ng descri pti on ;
private float di scount ;
publiC Item( int id . int quantity. float unitPrice . fl oat discount. String
- desc) {
}
this.ld i d;
th i s.quantity 2 quantity;
this.unitPrice unitPrice;
thi s.d i scount discount;
th i s.descript i on desc;
publ ic void displ ay( ItemOisplayFonmatter format ) {
fonmat .quantity( quantity );
I 328 Dia 14
L ISTAGEM 14.5 Item.java (continuao)
}
}
format.id( i d );
format.unitPrice( uni tPrice );
format.di scount( discount ) ;
format.description( descripti on );
format.adjustedPri ce( getTotaIPrice() ) ;
publi c float getTotalPrice() {
return ( unitPrice * quantity ) - ( discount * quantity ):
}
Aqui, voc pode pedir a Item para que se apresente, usando um formatador de exibio. O forma-
tador cuidar da formatao dos dados para exibio. Ter um objeto de formatao separado
uma estratgia mel hor do que fazer com que outro objeto chame mtodos de obteno ou incor-
porar a lgica de exibio no prpri o objeto Item. Quando os requi sitos de exibio mudarem,
voc poder simplesmente criar novas implementaes de ItemDispl ayFonnatte r.
A Listagem 14.6 define a interface Iten)1splayFonna tter e a Listagem 14.7 apresenta uma pos-
sivel implementao da interface.
LISTAGEM 14.6 I temDispl ayFormatter . java
publi c interface ItemDisplayForma tter {
public void quant i ty( int quantity ) :
public void ide int ld ):
}
publ ic void unitPri ce( float unitPrice }:
publi c voi d discount( float discount ):
publi c void descri ption( String desc r iption ):
publi c void adj us tedPri ce( float total }:
publi c Stri ng formatO :
LI STAGEM 14.7 ItemTableRow. java
publi C class I temTabl eRow impl ements ItemDisplayfonnatter I
private
i "t
quantity:
private i nt i d' ,
private float un1tPr ice ;
pri vate fl oat di scount ;
Construindo software confivel atravs de testes
LISTAGEM 14.7 ItemTableRow.java (continuao)
J
private String description;
private float adjPrice:
publlC void quantity( lnt quantity ) (
this .quantity z quantity;
J
publ ic vo1d
this.1d
id(intid){
1d:
J
publiC void unitPrice( float unitPrice ) (
this.unitPrice uni tPrice :
J
publ ic void discount( float discount ) {
this.discount discount;
J
public void descri pt ion{ String descripti on ) {
this.description description:
J
publiC void adjustedPrice( float total ) (
this . adjPrice total:
J
publiC String format() {
String row "<tr>";
row row + "<td>"
cow
row + "<td>"
cow
row + "<td>"
cow row + "<td>$"
cow
o
row + "<td>$"
cow row + "</tr>" ;
return row:
J
+ i d + "</td>":
+ quantity + "</td>":
+ description + "</td>";
+ unitPrice + "<jtd>" ;
+ adjPri ce + "<jtd>" ;
329
o formatador I temTabl eRow cria uma representao de linha de tabela HTML para o Item, usan-
do smbolos da moeda norte-ameri cana. Outros formatadores poderiam formatar as dados de ou-
tras maneiras,
Dia 14
Esse exemplo apresenta alguns desafios de teste int eressantes, assim como algumas oportunida-
des. Para essas classes, si mplesmente chamar um mtodo e verifi car uma sada no resolver.
O teste do mtodo di splay() de Item de especial interesse, pois um teste de unidade s deve
verificar uma classe isoladamente; entretanto, para testar di sp 1 ay () , voc tambm deve passar
para ele um ItemOispl ayFonnatter.
Feli zmente, os objetos falsificados oferecem uma alternativa que ainda pennitir a voc testar
I tem isoladamente.
Novo TERMO
Um objelOfa/sificado um substit uto simplista de um objeto real. Ele chamado de
objeto ralsificado porque o objeto roi ralsificado para propsitos de teste. Embora o
objeto falsificado possa ter uma implementao simplista, ele pode conter funcionalidade extra
para ajudar nos testes.
Os objetos falsificados so int imamente relacionados aos objelos s tubs. Objetos s tubs real izam
apenas trocas de mensagens enquanto que os objelos falsificados se diferem no senti do de que
eles realmente executam alguma funo, em vez de si mplesmente aceitarem uma chamada e re-
tomarem algum valor prvio.
s vezes, os objctos falsificados so chamados de simuladores.
Um objeto falsificado fornece um substi tut o si mplista para um objelo real. Esse subst itut o no
aparecer no sistema real, apenas no cdigo de teste.
O objeti vo de um objeto falsificado no fornecera funcionalidade real do objelo que imita. Em
vez disso. o objeto falsificado deve fornecer uma implementao simplista que pode ter mais su-
porte para leste.
Mantenha os objetos fatsifi cados o mai s simples possivel. Normalmente, um
objeto falsificado deve ser um objeto independente que no conta com quais-
quer outros obj etos falsificados. Se seu objeto falsificado tiver dependncias
demais, provavelmente ele muito compl icado.
Por exemplo, considere um acessar de banco de dados que retoma objetos Item. Voc codificaria o
acessor fa lsificado para retomar O mesmo objelo I tem repetidamente; ent retanto, se voc fizer tes-
tes de uni dade em um objeto que recupera objetos Item usando o acessor, ele no saber a diferen-
a. Tal estratgia isola o objcto que est sendo testado dos defeitos nos objetos que utiliza.
Voc pode usar um objelo falsificado para testar se o mtodo di spl ay() de Item usa objetos Item-
Oi sp 1 ayFonna tter corretamente. A Listagem 14.8 apresenta um I tenOi sp 1 ayForma tter falsificado.
LI STAGEM 14.8 MockOi spl ayFonnatter ,java
import j un1t.framewor k.Assert;
public cl ass MockOisplayFormatter impl ements It emOi splayFormatter I
Construindo software confivel atravs de testes 331
LI STAGEM 14.8 MockDlsplayFormatter.java (continuao)
private
; "t
test_quantity;
priva te
; "t
test_id;
private float test_unitPrice ;
private float test_discount;
pri vate String test_description;
private float test_adjPrlce;
private fnt quantity;
private fnt
id-
o
private float unitPri ce ;
private float di scount;
private Stri ng description ;
private float adjPri ce ;
publ ic void verify() {
Assert. assertTrue ( "quanti ty set i ncorrectly" , test quanl i ty "" quant i ty
) ;
Assert.assertTrue( "id set i nc orrectly", test_id id );
Assert.assertTrue( "unitPrice set incorrectly", test_unitPrice
_ uni tPri ce );
Assert.assertTrue( "di scount set incorrectly". test_discount discount);
Assert.assertTrue( "description set incorrect l y", test_description
- description );
Assert.assertTrue( "adjPrice set i ncorrectl y . test_adjPrlce .... adjPrice) ;
}
pubhc void test_quantity( int quantity ) {
test_quantity quantity;
)
publi C void test_id ( int id ) {
test id .. ido
}
publiC void test_unitPrice( f loat unitPrice ) {
test unitPrice unitPrice;
}
publiC void test_discount( float discount ) {
test_discount di scount;
}
publiC void tes t _description( String description ) {
test_description descr ipt ion ;
}
Dia 14
LI STAGEM 14.8 MockDlspl ayFonnatter.java (continuao)
}
public void test_adjustedPrice( float total ) I
test_adjPrice total;
}
public void quant1ty( int quantity ) {
this.quantity quantity;
}
public voi d i de int id ) {
this. id = id;
}
public void unitPrice( float unitPrice ) {
this.unitPrice unitPrice;
}
publ iC void discount( float discount ) (
thi s.dl scount discount;
}
public void descript lon ( String description ) {
this.description description;
}
publi c void adjustedPrice( float total) {
this.adjPrice = total;
}
public String fonnat() ( II no estamos testando funcionalidade de fonnatador
return "NOT IMPLEMENTED";
}
De certa forma, MockOi spl ayFormatter semelhante implementao real; entretanto, voc no-
tar que ele no implementa um verdadeiro mtodo formatO. Voc tambm notar que ele
acrescenta vrios mtodos para confi gurar os valores esperados, assim como um mtodo para
verificar as entradas de Item em relao a esses valores.
A Listagem 14.9 ilustra como voc poderi a usar a exibio falsificada para fazer o teste de uni-
dade da classe I tem.
Construindo software confivel atravs de testes
LISTAGEM 14.9 ItemTest.java
import junit.framework.TestCase;
import junit.framework.Assert;
publiC class ItemTest extends Tes t Case {
I
private Item item;
II constantes para valores do construtor
private f1 na 1 statlc 1nt lO 1 ;
private fi na 1 static int QUANTITY 10;
private final static float UNIT PRICE
-
100. 00f;
-
priva te final static float DISCOUNT 5. 00f;
private fina 1 static St ring OESCRIPTION "ITEM_TEST";
protected void setUp O {
item new Item( lO, QUANTITY, UNIT_PRICE, OISCOUNT , OESCRIPTION li
I
publiC void test_displayValues() {
I
MockDisplayFonmatter formatter : new MockOispl ayFormatter();
formatter.test_id( 10);
fonmatter. test_quantlty( QUANTITY );
fonmatter.test_unitPri ce( UNIT_PRICE ,;
fonmatter.test_discount( OISCOUNT }i
fonmatter.test_description( OESCRIPTION );
fl oat adj_total = ( UNIT_PRICE * QUANTITY ) - ( OISCOUNT * QUANTITY );
formatter.test_adjustedPrice( adj_total l;
item.display( formatter l;
formatter . verify();
publiC ItemTest( String name ){
supere name }i
I
333
Dia 14
o mtodo test_di spl ayYa l uesO de ItemTest cri a um MockOi spl ayFormatter, confi gura as en-
tradas esperadas, passa isso para o objeto Item e usa o fomlatador para validar a entrada. Interna-
mente, o mtodo veri fy() do formatador usaa classe Assert de JUnit para vali dar a entrada.
Os objetos falsificados so um conceito poderoso, pois voc pode program-los para qualquer
coisa. Voc pode ter obj etos fal sificados que contm o nmero de vezes que um mtodo cha-
mado ou um que controle o volume de dados que um objeto envia por urna rede. Tudo depende
de seu aplicativo e do que voc precisa monitorar. Os objetos falsificados pennitem que voc rea-
lize todos os tipos de monitoramento e teste que no so possveis, caso um objeto simplesmente
cri e todos os objetos de que precisa.
Isso levanta a questo, "e se meus obj etos criarem os objetos de que precisam?" A maior parte
dos exemplos deste li vro cai nessa categoria (espera-se, contudo, que os exemplos tenham per-
manecido mais inteligveis!). Uma soluo editar as classes para que os obj etos instanciem um
objeto fal sifi cado, em vez do objeto real. Tal estratgia, entretanto, no limpa, pois o obriga a
alterar o cdigo que voc est testando. Se voc mudar a implementao do cdigo antes de tes-
tar, no estar realmente testando a classe que entrar em seu sistema. A melhor soluo escre-
ver cdigo quc seja fcil de testar.
Tal conselho pode parecer retrgrado. A sabedoria convencional diz que normal mente voc
escreve testes para testar cdigo que j escreveu. Voc no escreve cdigo para que possa tes-
tar! O exemplo Item ilustra uma lio importante. Projetar suas classes de modo que elas sejam
fceis de testar pode resultarem um cdigo mais OO! Nesse caso, passaras objetos dependen-
tes tornou oobj eto menos dependente de uma classe especfica. tornando-o. assim. mai s afeito
conexo.
DICA
DICA
Proj ete suas classes de modo que voc possa t est -Ias facilmente. Projete
lembrando dos objetos falsificados. Seu cdigo pode se t ornar mais orientado
a objetosl
Escreva suas classes de modo Que os objetos dependentes sejam passados e
no i nstanciados dentro do prprio objeto. Essa prtica leva a objetos inde-
pendentes.
Embora seja verdade que o mtodo d"isplayO de Item seja dependenle da interface ItemOis-
pl ayFonnatter, ele no dependente de uma implementao especfica da interface, como Ta-
hleRowFonnatter ou mesmo MockOi splayFormatte r . Em vez disso, Item est livre para usar
qualquer implementao de I t enl i splayFormat ter, pois ele no se obriga a usar qualquer uma
especfica, cri ando a instncia por si mesmo.
DICA
Construindo software confivel atravs de testes 335
Di cas para testes efi cazes:
Voc deve otimizar a velocidade de seus testes. Testes rpidos fornecem
retorno instantneo; portanto, voc poderia estar mais apto a us-los.
Compile seus casos de teste junto com suas classes normai s. Essa prtica
o obrigar a manter seus casos de teste atuali zados com o cdigo.
Evite val idao visuaVmanual de sada de t este, pois ela propensa a er-
ros. Em vez disso, use algum mecanismo automtico.
Se voc precisa manter uma base de cdigo que no possui testes de unidade,
escreva os test es medida que precisar deles.
Escrevendo cdigo excepcional
Teslar uma maneira importante de garantir a qualidade do cdigo que voc escreve; entretanto,
esse no o nico passo que voc pode dar. Voc tambm precisa aprender a identificar a dife-
rena entre uma condio de erro e um erro. Uma condio de erro e um erro no so a Illesma
coisa!
Voc sabe o que um erro; um erro um defeito. Uma condio de erro li geiramente diferente.
Uma condio de erro ou exceo uma falha previsvel que acont ece sob ccrtas circunstncias
no domnio. Pegue como exemplo a loja on-line. Perodos de inatividade da rede acontecem o tem-
po todo. Um peri odo de inatividade da rede no um erro (a no ser que seu cdigo tenha causado
isso!). Em vez de tratar condies de crro como erros, voc precisa codificar em tomo delas.
Por exemplo, se sua conexo com o banco de dados falha, voc precis.1. tentar reconectar. Se ela
ai nda estiver inativa. voc precisar tratar da condio nonnalmente e infonnar o usurio do erro.
Toda li nguagem tem sua prpria maneira de relatar condies de erro. As linguagens Java e C++
empregam um mecanismo conhecido como excees para sinal izar condies de erro. Li ngua-
gens como C contam com cdigos de retorno. Qualquer que seja a linguagem usada, voc deve
escrever seu cdigo para detectar e se recuperar nonnal mente de condies de erro.
As excees Java e C++ funcionam de modo semelhante. As excees so apenas outro tipo de
objeto; entretanto, o compilador Java o obriga a tratar delas, se dctcnninar que uma exceo
pode ocorrer e voc no tratar dela.
Aqui est um dos mtodos da classe URL da linguagem Java:
publi c URLConnection openCon nection( ) throws IOExceptlon
Voc v que o mtodo tem algumas infonnacs extras. O mtodo indica que pode lanar
IOException, significando que, sob condies nonnais, o mtodo retomar um objeto URlCon-
nect i on. Se houver um erro na abertura da conexo. ent retanto. o mtodo lanar lima exceo
rOException.
Na linguagem Java, voc trata de excees em blocos t ry/ catch. A Listagem 14. 10 mostra
como voc poderia mani pular uma chamada de openConnection.
Dia 14
LI STAGEM 14.10 Tratando de uma exceo
java . net.URL url .. new java.net.URL( .. http: //www.samspubl ishi ng.com/ .. ) ;
java.net. URLConnection conn;
try I
conn = url.openConnection();
I catch ( j ava. lo .IOExcept ion e ) { II um erro ocorreu
II registra um erro , escreve al go na tel a
II faz algo para tratar do erro
I
Quando voc faz uma chamada para openConnect i on, faz isso normalmente; erllretanto, voc
deve fazer a chamada dent ro de blocos try/catch ou dizer explici tamente que o mtodo no qua l
a chamada fei ta tambm lana uma exceo IOException.
Se a chamada para openConnection () resultar no lanamento de uma exceo, conn no ser con*
figurado. Em vez di sso, a execuo conti nuar dentro do bloco cat ch, onde voc pode tentar re*
cuperar, registrar um erro, impri mir uma mensagem na tela ou lanar outra exceo.
Se voc no capturar a cxceo expl icitamente ou lanar urna nova exceo, a exceo subir
como bolha na pil ha de chamadas, at chegar ao topo ou que algum finalmente a capture.
O import ante que voc programe para condies de erro, usando o mecanismo incorporado
sua linguagem. Isso signi lica que, quando voc projetar suas classes, tambm dever considerar
as diversas condies de erro, model*las atravs de objetos exceo e fazer com que seus mto-
dos as lancem.
Escrevendo documentao eficaz
H mais um passo que voc pode dar para melhorar a qualidade de seu trabalho: document*lo.
Existem mui tas formas de documentao, cada uma com seu prprio nvel de eficcia.
Cdigo-fonte como documentao
O cdigo*fonte, at seus testes de unidade, urna fonna de document ao. Quandooutras pesso-
as precisam pegar e manter seu cdigo, import ante que ele seja legvel e bem organizado. Caso
contrrio, ningum poder ter idia do que ele faz.
O cdigo-fonte a forma mais importante de documentao, pois a nica documentao que
voc tem de manter.
Conve nes de codificao
O primei ro passo que voc pode dar para transformar seu cdigo em boa documentao esco-
lher uma conveno de codi fi cao e fi car com ela. As convenes de codificao podem cobri r
tudo, desde corno voc endenta suas chaves at corno nomeia suas variveis. A conveno espe-
Construindo software confivel atravs de testes 337
cfica no to importante assim. O importante que sua equipe de projeto, e preferi velmente
sua empresa, escolha uma conveno e fique com ela. Desse modo, qualquer um pode pegar um
trecho de cdigo e acompanh lo - bem, pelo menos no se atrapalhar com a fonnatao.
A Li stagem 14.1 1 apresenta uma maneira de declarar classes Java.
LISTAGEM 14.11 Um exempl o de classe
public class <ClassName>
(
I
extends <ParentClassName>
implements <lIST OF INTERFACES>
II
vari vei s pblicas
II
variveis protegidas
II
varilivei s privadas
II
constantes
II
mtodos pblicos
II
mtodos protegidos
II
mtodos privados
DI CA
Os nomes de classe sempre devem comear com uma letra maiscula. Os no-
mes de mtodo sempre devem comear com uma letra mi nscula. Os nomes
de varivel sempre devem comear com uma letra minscula.
Qualquer nome contendo vrias palavras deve ter as palavras reunidas e cada
palavra comear com letra maiscula.
Por exemplo o mtodo someMethod() e a classe HappyObj ect.
As constantes sempre devem aparecer em MAISCULAS. As variveis normais
devem aparecer em minsculas.
(Not e que essas convenes so voltadas li nguagem Java. As convenes
para Smalltalk e C++ podem ser diferentes.)
Aqui est uma maneira de declarar mtodos e instrues i f /e 1 se aninhadas:
public void method() {
I
if ( condicional) {
I else {
I
Dia 14
Constantes
As constantes lambm podem servir corno uma forma de documentao. Use constantes quando
voc se achar ut ilizando um valor codificado. Uma constante bem nomeada pode dar uma idia
do objetivo de seu cdigo.
Comentrios
Assim como uma constante bem colocada, nada aj uda a tomar o cdigo mais intel igivel do que
um comentri o bem colocado; entretanto, voc precisa encontrar um equilbrio em seus
trios. Coloque comentrios demais e eles perdero o signifi cado.
Aqui est um erro de comentrio intil, mas comum:
publ i c voi d i d( int id ) {
thi s . 1d 1d ; II configura id
}
Comentri os inteis informam o que o cdigo est fazendo. Se voc precisa explicar cd igo,
to ele pode eSlareompli cado demais. Os coment rios devem dizer para que serve o cdigo. Eles
devem descrever impl ementaes no intuiti vas.
NOTA
Nomes
Noteque um comentri o sob uma assinatura de mtodo no substi tui um bom
e ctaro nome de mtodo.
Os nomes de varivel, mtodo e classe devem ser significativos. e seja consistente em
sua grafi a. I)or exemplo, sempre coloque inicial maiscula na segunda palavra de um nome com
vrias palavras, como em testCase. Como alternati va, voc pode dividi r as palavras com um
fen (-), corn o cm test -case. Novamente, o aspecto mais importante a consistncia. Torne sua
regra de atribuio de nomes parte de sua conveno e ento a uti lize consistentemente.
Cabealhos de mtodo e classe
Quando voc escrever uma classe ou um mtodo, sempre se cert ifique de incluir um cabealho.
Um cabealho de mtodo incluir uma descrio, uma lista de argumentos, uma descrio do
torno, assim como condies de lima exceo e efeitos colaterai s. Um cabealho pode al incluir
condi es prvias. Um cabealho de classe nonnalmente incl uir uma descrio, o nmero da
verso, a lista de aUlores e o histrico de reviso.
Quando voc programar em Java, de tirar proveito do Javadoc. (Veja o Apndice B
para mai s informaes.) O Javadoc fornece vrias tags para escrever cabeal hos. Se voc usar
Javadoc, poder si mplesmente executar suas classes atravs de um processador, que far auto-
maticamente documentao da APl baseado na Web, conveniente para suas classes.
Construindo software confivel atravs de testes 339
DICA
Quando voc ti ver documentado algo, ter se comprometido a manter essa
documentao atualizada, seja com o Javadoc, um documento de projeto ou
um comentr io. Uma documentao obsoleta intil. Mantenha-a atualizada!
Resumo
Hoje, voc aprendeu sobre os testes e o que pode fazer como desenvolvedor para garantir a qua-
lidade de seu trabalho. Ao todo, existem quatro fonnas gerais de teste:
Teste de uni dade
Teste de integrao
Teste de sistema
Teste de regresso
Em seu trabalho dirio, o teste de unidade sua primeira li nha de defesa cont ra erros. O teste de
unidade tambm tem as vantagens de obrig-lo a considerar seu projeto do ponto de vista do tes-
te e de fornecer a voc um mecanismo que torna mais fcil refazer as coisas.
Voc tambm viu a importncia do tratamento correto das condics de erro e da manut eno da
documentao. Todas essas prticas aumentam a quali dade de seu cdigo.
Perguntas e respostas
P Por que os desenvolvedores detestam testar?
R Parece haver uma cultura do 'evitar teste' entre os programadores. Achamos que esse
um problema cult ural. Na maioria das empresas, o pessoal de controle de qualidade um
grupo separado dos desenvolvedores. Eles vm, testam o sistema e redigem relatri os de
erro. Essa estratgia coloca o programador na defensiva, especialmente se o gerent e de
projeto pressionar o desenvolvedor a refazer o trabalho. De certa forma, os testes se tor-
nam uma punio e uma fonte de trabal ho extra.
Ver os testes como trabalho extra tambm faz parte do problema. Muitas equipes de pro-
jeto deixam os testes para o tinal do desenvolvimento; assi m, ele se torna algo que voc
faz quando j terminou de fazer o trabalho 'real'. Infel izmente, quanto mai s voc retarda
os testes, mais difceis eles sero de fazer. Quando voc comear a testar, provavelmente
encontrar um grande nmero de erros, pois no tinha testado at esse ponto. Isso o leva
de volta fase de punio, especial mente porque voc, provavelmente, est perto de seu
prazo final. E se voc estiver prximo ao seu prazo final , a presso do gerente de projeto
aumentar.
o evitar teste UIll problema que se auto-alimenta.
Dia 14
P 110r que os testes so feitos freqcntcmente por um grupo de controle de qualidade
separado?
R Testes independentes ajudam a garamir que o pessoal de teste no evite, subconsciente
mente, reas onde podem existir problemas - uma fal ha na qual os desenvolvedores p0-
dem estar propensos.
P Em todas as lies de hoje, voc usou JUnit. Por que voc escolheu J Unit?
R JUni t uma fermment a de teste gmtuila que faz bem seu tmbalho. A J Unit bem projeta
da e suficientemente pequena para que voc possa por suas mos no proj eto faci lmente.
Ela ta mbm no possui os detal hes que muitos outros produtos tm.
Em nossa opinio, evitar os detal hes durante os testes de unidade uma vantagem. A
JUnit o coloca mais perto do cdigo, pois voc preci sa escrever seus prpri os lestes, con-
fi gumr os dados e vali dar a sada. Ela o obriga a considerar seu projeto e at a aumen
t- lo, para que seja fcil testar.
Com algumas das ferra mentas de teste mai s aut omati zadas, voc pode perder essas van-
tagens; entretanto, a J U nit uma estrutura de teste de unidade. Voc precisar encontrar
outras ferramentas para alguns dos testes de integrao c de sistema.
P O teste de unidade parece um fardo. No tenho tempo para fazer o teste de unidade.
O que devo fazer?
R Os testes de unidade podem parecer um fardo na pri meira vez que voc escreve um deles.
Com todo honest idade, s vezes, os testes de unidade so dispendiosos para escrever.
Eles se pagam com o passar do tempo. Quando voc escreve um teste, pode reutiliz-lo
repet idamente. Sempre que voc mudar a implementoo de sua classe, bastor executar
novamente seu teste de unidade. Os testes de unidade tornam mui to mais fcil fazer alte-
raes em seu cdigo.
No ter tempo um argumento fraco. Imagine quanto ser mais demorado encontrar, ras-
trear e corrigir erros, se voc deixar os testes para o fi m - um moment o em que voc
normalmente est sob ainda mais presso.
P Como voc sabe se j testou o suficiente?
R Voc j testou em um nvel mnimo, quando ti ver um teste de unidade para cada classe,
um teste de integrao para cada interao important e no sistema e um leste de sistema
para cada caso de uso. Se voc vai ou no fazer testes adicionais depende de seu pmzo fi-
nai, assim como de seu nvel de bem estar.
Construindo software confivel atravs de testes 341
Workshop
As perguntas e respostas do teste so fornecidas para seu melhor entendimento. Veja as respos-
tas no Apndice A, "Respostas".
Teste
I. Como erros podem entrar em seu software? (Ou talvez a pergunta deveria ser, ;;como
voc causa erros em seu software?")
2. O que um caso de teste?
3. Quai s so as duas maneiras nas quais voc pode basear seus testes?
4. Defi na teste de caixa branca e de caixa preta.
5. Quai s so as quatro formas de teste?
6. Defina teste de l/IIidade.
7. Qual o objeti vo por trs dos testes de integrao e dos testes de sistema?
8. Por que voc deve evitar ler de deixar os testes para o final de um projeto?
9. Por que voc deve evitar validao manual ou visual ao testar? Qual a alternati va?
10. O que uma estrutura?
I I. O que um objeto fal sificado?
12. Por que voc deve usar objetos fa lsificados?
13. Qual a diferena entre um erro e uma condio de erro?
14. Ao escrever seu cdigo, como voc pode garantir sua qualidade?
Exerccos
I. Faa download da JUnit c leia cooks t our, que encontrado no diretri o doc.
2. Escreva um teste de unidade para HourlyEmployee do Captulo 7, " Polimorfi smo: hora
de escrever algum cdigo", que testa o mtodo cal culatcPay().
SEMANA 2
Em reviso
Nesta semana, voc aprendeu a respeito da est ratgia iterativa para o processo de desenvolvi-
mento de software. O processo de desenvol vimento de software incl ui os estgios de anlise,
projeto, implementao e teste. Voc aprendeu que a estratgia iterai i va para O desenvol vimento
de software permite voltar e re finar qualquer estgio do processo. Esse refinamento contnuo
leva a lima soluo mais completa e correta para seu problema.
O Dia 8 apresentou a Unified Modeling Language. No Dia 9, voc aprendeu sobre AOO (Anli-
se Orientada a Objctos), o primeiro passo do processo de desenvolvimento. A AOO pcnni te que
voc entenda o problema que est tentando resolver. Um mtodo de ADO atravs do uso de ca-
sos de li SO para descrever como os usurios utilizaro o sistema. Uma vez que voc tenha seus
casos de uso mapeados, pode usar linguagens de modelagem, como a UML, para visuali zar gra-
ficamente o domnio de seu problema.
O Dia 10 descreveu o POO ( Projeto Ori entado a Objetos), o processo de pegar o modelo de do-
mnio e cri ar o modelo de objetos que voc usar durante a implement ao. A li sta a seguir apre-
senta os passos bsicos necessrios para completar o roo.
I. Gere uma lista de objetos inicial.
2. Refine as responsabilidades de seus objetos.
3. Desenvolva os pontos de interao.
4. Detalhe os relacionamentos entre objetos.
5. Construa seu modelo.
Os cartes CRC o ajudam no mapeamento das responsabilidades e das interaes entre cada ob-
j eto. Os dois dias seguintes abordaram os padres de projeto, conceitos de projeto reutil izvel
que rornecem atal hos para o POO. Voc aprendeu sobre padres, como Adapter, Proxy, Itera-
tor, Abstract Factory, Singleton e Typesare Enum, e quando apropriado us-los.
O Dia 13 explicou o projeto de UI com o padro MVC. O padro MVC rornece nexibilidade, de-
sacoplandoa UI do sistema subjacente. Ele tambm enratiza a necessidade de executar o proces-
so de projeto de software para a UI como para qualquer out ra pane do sistema.
Construindo software confivel atravs de testes 343
Finalmente, o Dia 14 apresentou os testes nos estgios de implementao e lestes de cada itera-
o. Voc aprendeu a respeito das duas maneiras de testar seu cdigo: teste de caixa branca e tes-
te de caixa preta. Voc tambm aprendeu as quatro formas de teste: teste de uni dade, de
integrao, de sistema c de regresso. O teste a maneira fi nal de garantir a qualidade de seu c-
di go. Se ele no for levado em considerao durante todo o processo de desenvolvimento, voc
poder se deparar com sri as conseqncias.
Agora que voc tenni noll as li es desta semana, deve entendera processo de desenvolviment o
de software.
SEMANA 3
Reunindo tudo:
um projeto 00 completo
15 Aprendendo a combinar teoria e processo
16 Iterao 2 do j ogo vinte-c-um: adi cionando regras
17 Iterao 3 do jogo vinte-c-um: adi cionando aposta
18 Iterao 4 do jogo vinte-c-um: adicionando uma GUJ
19 Aplicando uma alternativa ao MVC
20 Di vertindo-se com o j ogo vi nt e-c-um
21 O ltimo quilmetro
Panorama
Na pri meira semana, voc aprendeu a teoria por trs da POO. A segunda semana forneceu um
processo para seguir ao aplicar essa teori a. Nesta semana, voc reuni r as li es das duas primei-
ras semanas, em um proj eto de POO completo. Esse projeto fa r voc percorrer todas as fases do
desenvolvi mento - do incio ao fim do projeto.
Seu projeto final ser o desenvolvimento dojogo de cartas vi nte-c-um. O Dia 15, o primei ro dia
desta semana, o conduzi r na pri meira iterao do j ogo e adicionar as funci onalidades bsicas
da ADO, atravs de implernentaoe leste. Nos dias 16 e 17, voc vai adicionar mais funcionali-
dades no j ogo, atravs de mai s duas iteraes. O Dia 18 mostrar como se acrescenta uma GUI
ao sistema.
o Dia 19 fornecer uma outra maneira de implementar uma GUI, atravs do padro de projeto
PAC. No Dia 20, voc vai aprender a adicionar vrios j ogadores no-humanos e ver como
transformar seu jogo em um simulador. Finalmente, o Dia 21 reunir tudo e retirar todas as apa-
ras.
SEMANA 2
DIA
Aprendendo a combinar teoria e
processo
A Semana I o ajudou a entender a teoria por trs da POO. A Semana 2 forneceu um processo
para segui r ao aplicar essa teoria. A Semana 3 mostrar a voc como reunir as li es das semanas
I e 2, apresentando um projeto de POO completo. Esse projeto o conduzir por Iodas as rases do
desenvolvimento, do incio ao fim do projeto.
A lio de hoje apresentar o jogo vinte-c-um, um jogo de cartas popular. No final da lio de
hoje, voc completar a anlise, projeto e implementao funcional iniciais do jogo. Voc no
criar um jogo virllc-c-um inteiro em uma nica etapa grande. Em vez disso, voc vai aplicar o
processo iterat ivo durante a semana, medida que completa o jogo vi nt e-c-um.
Hoje voc aprender como:
Aplicar anlise e projeto 00 em um jogo de carias real
Usar o processo iterativo para obter e ver resultados rpidos
Evitar muitas tent aes comuns do desenvolvimento
Evitar caractersticas procedurais que podem peneirar em seu programa
Jogo Vinte-e-um
o vi llle-e-um um j ogo de cartas popular, onde o obj etivo obter a contagem mais alta de cartas
do que a banca, sem ultrapassar 21. O objeti vo desta semana criar um jogo vi nt e-e-um bastante
Dia 15
completo, escrito em Java, usando os conceitos de POO que voc aprendeu por todo o livro.
Embora alguns recursos sejam omi tidos por mot ivos de ctareza e brevidade, voc dever ter um
j ogo to viciante e demorado quanto os j ogos de pacincia ou FreeCell que acompanham mui tos
sistemas operacionais populares.
ALERTA
o autor no se responsabil i za pelo t empo perdido enquanto se joga este jogai
Por que vinte-e-um7
A pergunta pode vir mente, "por que vinte-e-um?"
O objet ivo de programar o vi nte-e- um no transform- lo em um jogador profi ssional. Existem
dois mot ivos pam se usar o vinte-e-um como um projeto de roo introdutrio:
Quase todo mundo est familiarizado com pelo menos um jogo de cartas.
Acont ece que o j ogo vi nt e-e-um se encaixa bem no paradigma da roo.
Em geral, a maioria das pessoas est fami liarizada com o domni o do j ogo de cartas. Uma parte
important e da AOO e do POO ter um especialista no domnio presente, enquanto se identifica
os casos de uso e o modelo de domni o. Si mplesment e no possvel conseguir um especiali sta
no domnio como parte da conct uso destas li es.
Um jogo de cartas no exige um especiali sta no dom nio. Em vez disso, sua prpria experincia e
um bom li vro de regras ou site Web fornece tudo de que voc precisa para completar a anl ise e o
projeto por conta prpria. Se ficar confuso, voc pode at pegar um baralho e simular um cenrio.
Como resultado, um jogo de cartas muito mais acessvel do quc tentar aprender um domnio
completamente desconhecido. Um domnio conhecido no o desviar do obj eti vo real destas li-
es - aprender a aplicar os princpios da 00.
O vinte-c-um - na verdade, como a maioria dos jogos de cartas cm geral - tambm tende a se
encaixar bem no paradigma da roo. As interaes entre bancas, jogadores, suas mos e as car-
tas podem ajud-lo a ver que um sistema 00 consti tudo das interaes entre os vrios objetos.
Os jogos de cartas tambm tendem a manter caractersticas procedurais suficientes para que seja
fcil ver como uma estratgia de roo pode ser muito diferente de uma procedural, especialmen-
te ao se aplicar regras de jogo.
Declarao da viso
Ao se ini ciar um projeto, freqUentemente aj uda comear com uma dcctarao da viso ou objeti-
voo O objetivo da declarao formar o propsi to gera l do sistema que voc vai cri ar. O objetivo
Apre nde ndo a combinar teoria e processo 349
da declarao no capturar cada aspecto do problema que voc est tentando resolver. Em vez
disso, a declarao simplesmente infonna o intento e fornece um ponto de partida para a anlise.
Novo TERMO
A declaralio da viso forma o propsito geral do sistema que voc vai criar e do
problema que est tentando resolver.
Aqui est a declarao da viso do sistema do j ogo vinte-c-um:
O jogo vinte-e-um penni te que um jogador participe dele, de acordo com regras de cassino co-
muns.
Embora seja aparentemente evidente, essa declarao serve como um catali sador excelente para
a anlise.
Requisitos de sobreposio
Antes de iniciar a anlise, ajuda enumerar todos os requisitos de sobreposio. Exi stem apenas
algumas restries no jogo vinte-e-um. A nica restrio importante agora como o usuri o vai
interagi r com O sistema.
O j ogo vi nte-e- um permi te que o usurio interaja com o sistema atravs de uma linha de coman-
do ou UI grfi ca. claro que a iteraes iniciais pennitiro apenas uma interao atravs de uma
interface de li nha de comando.
O jogo vinte-e-um tambm deve ser implementado na linguagem de programao Java.
importante listar tais restries antecipadament e, para que voc no aparea com um projeto
que tome a obedincia a essas restri es impossvel.
Anlise inicial do jogo vinte-e-um
O Captulo 9, " Introduo (AOO) Anlise Orientada a Objetos", apresentou a AOO, assim
cama o processo de desenvolvimento iterativo. De acordo cam as inrormaes do Captulo 9,
este projeto segui r um processo de desenvol vi mento iterativo e iniciar cada iterao desse pro-
cesso com a anlise.
Ao se iniciar a an li se, freqentemente util comear com a declarao da viso mencionada an-
teriormente:
O jogo vinte-e-um permitc que um jogador part icipe dele, de acordo com as regras dc cassino co-
muns.
Voc pode usar a declarao para gerar uma lista inicial de pergunt as. So essas perguntas que
dirigiro sua anlise.
350 Dia 15
As regras do jogo vinte-e-um
A partir da declarao da viso do jogo vinte-c-um, voc pode naturalmente pergunt ar, "quais
so as regras de cassino comuns dojogo vi nt e-c-um?" Voc vai usar essas regras para modelar o
jogo vi nte-c-um.
O objcli vo pri ncipal do j ogo vi nte-c-um reunir uma mo de cartas cujo valor seja maior que a
mo da banca, sem ultrapassar 2 1. Cada carta recebe um valor numrico de 1 a II , onde os vale
I Oll 11 (dependendo do que orerea a voc uma mo mel hor), as cartas numricas valem os seus
respecti vos nmeros e todas as cartas de fi gura valem 10. O naipe no tem rel ao com o valor da
cart a.
A Figura 15. 1 mostra alguns exemplos de mos.
clara que o jogo real um pouco mais complicado. Vamos ver cada componente importante do

Jogo.
Aposta
Antes quea banca distribua as cartas, cada jogador deve fazer uma aposta. Nonnalmente, a apos-
ta est sujeita a algum li mite, como USS25 Oll USS50 por jogo.
Distribuindo as cartas
APS cada jogador ter feilo uma aposta, a banca pode distribuir as cartas. Comeando com o pri-
meiro jogador, a banca distribui urna carta aberta, para cada jogador, termi nando consigo mesmo.
Ento, a banca repete esse processo, mas dist ri bui sua prpria carta fechada. A carta fechada da
banca conhecida como carta oculta.
A distribuio de cartas termina quando a banca servir a cada jogador, incluindo ela mesma,
duas cartas. O jogo comea quando a di stribuio terminar.
Jogando
o jogo pode diferir dependendo da carta aberta da banca. Se a carta aberta da banca valer 10
(chamado de valor 10) ou for um s (valor I I), a banca dever verificar sua carlaoculla. Se a car-
ta oculta resul tar em um total de 2 I (chamado de 21 ou vi nt e-e- um natural ), o jogo tenninar au-
tomaticamente e se passar para o pagamento. Se a carta oculta no resul tar em um total de 21 , o
jogo comear nonnalmente.
Se a carta aberta da banca no for de valor 10 ou um s, o jogo passar automaticamente para o
primeiro j ogador. Se o jogador tiver um 21 nat ural, ele tcr bat ido e o jogo passa para o jogador
seguinte. Se o j ogador no tiver 21, ter duas escolhas: receber mai s cartas ou parar:
Aprendendo a combinar teoria e processo
FIGURA 15.1
ExemlJ/o de II/(ios do jogo
rime-e-11m.
10 de Copas s de Paus
10

10
5 de Ouros
5

5
Rei de
Ouros
K

9 de Espadas
9

9
A
...
2 de Copas
2

2
Damas de
Copas
Q

6 de Paus
6
...
6
= 21
10 de Espadas
10

=17
10
s de
Espadas
A

= 21
Valete de Espadas
J
=25
J
351
receber mais cartas - Se O jogador no estiver satisfeito com sua mo, ele pode optar por
ti rar outra carta, o que chamado de receber mais cartas. O jogador pode receber mais cartas
at ultrapassar 21 (estouro) ou parar (no precisa de mai s cart as).
parar - Se o jogador estiver satisfeito com sua mo, ele pode optar por parar e no receber
mais cartas.
A ps o jogador estourar ou parar, o jogo passa para o jogador segui nte. Esse processo se repete
at que cada jogador tenha jogado. Aps cada jogador participar, a banca ento joga suas cart as.
Quando a banca completa sua vez, o jogo passa para o pagamento, onde ocorre a cont agem de
pontos e o pagamento.
Dia 15
Pagamento
Aps a banca tcnninar sua vez (ou saber que tem vinte-e-um pontos), o jogo passa para o paga-
mento. Durante o pagament o, cada jogador que estourou perde sua aposta; cada jogador com
uma mo menor que a da banca perde sua aposta; cada j ogador com uma mo melhor que a da
banca ganha sua aposta; e cada j ogador com uma contagem igual da b..1nca empata e nenhum
pagamento feito. As apostas so pagas unifonnemente.
Se um j ogador ti ver um vinte-e-um e a banca no, ojogador receber uma vez e meia o que apos-
tou. Por exemplo, se o j ogador tivesse apostado US$ IOO, receberia US$ 150 ([ I 00 3]/2).
Miscelnea
Precisamos mencionar mais alguns detalhes importantes sobre o jogo virlle-e-um:
O baralho - O jogo vinte-c-um jogado com quatro baral hos padro de 52 cartas. Esses
quatro baralhos so combinados em uma unica pilha de cartas grande.
Nmero de jogadores - De um a sete jogadores podem j ogar vi nt e-e-um.
Dobrando - Aps receber suas duas cartas, o jogador pode opiar por dobrar. Quando o jo-
gador dobra, ele duplica sua aposta, recebe mais uma carta e termina sua vez.
Seguro - Quando a carta aberta da banca um s, o j ogador pode optar por fazer uma aposta
segura. A aposta segura igual metade da aposta original. Se a carta oculta da banca forne-
cer banca um 21 natural, o jogador no ganha nem perde. Se a carta oculta da banca no for-
necer a ela o 21 , o jogador perder sua aposta segura.
Dividindo pares - Diz-se que um jogador tem um par, se as duas cartas iniciai s distribudas
ti verem o mesmo valor. Se o j ogador recebeu um par, ele pode optar por desdobrar as cartas
em duas novas mos. Se o jogador dividir o par, a banca di stri buir a cada nova mo mais
uma carta e, em seguida, o jogador dever colocar uma aposta igual na nova mo. Um j oga-
dor pode dividir qual quer par que resulte de urna divi so subseqllente (exceto quant o a um
par de ases). Digno de nota tambm o fato de que qualquer contagem 21 resultante de uma
di viso no tratada como um 2 1 natural. Uma vez fei ta a diviso, o j ogador aposta normal-
mente ou pra, para cada mo.
Identificando os atores
Existem dois mot ivos para se fazer a anlise. Atravs da anlise, voc cria o modelo de caso de
uso: a descrio de como o usurio vai usar o sistema. Atravs da anlise, voc tambm cri a o
modelo de domnio: uma descrio do vocabulrio princi pal do sistema.
O pri meiro passo na defini o de seus casos de uso defi nir os atores que usaro o sistema. A
part ir da descrio da ltima seo, fcil ver que existem dois atores principai s no jogo vin-
te-e-um - 0(5) j ogador(es) e a banca.
Apre nde ndo a combinar teoria e processo 353
Esses dois atares respondem pergunta, "quem usar principalmente o sistema?" Atravs dos
casos de uso, voc pode defi nir como esses atores usaro o sistema.
Criando uma lista preliminar de casos de uso
Uma maneira efi caz de gerar os casos de uso inic iais perguntar o que cada um desses atores
pode fazer.
Os jogadores podem fazer o seguinte:
I. Fazer apostas.
2. Pedir mai s cartas.
J. Parar.
4. Estourar.
5. Conseguir um vinte-e-um.
6. Fazer um seguro.
7. Dividir pares.
8. Dobrar.
9. Decidir jogar novamente.
10. Sair.
A banca pode fazer o segui nt e:
I. Di stribuir cartas.
,
Efetuar o jogo.
-.
J. Receber mais cartas.
4. Parar.
5. Estourar.
6. Conseguir um vinte-e-um.
Podem existi r mais casos de uso, mas essa lista fornece muito materi al inicial.
Planejando as iteraes
o Capt ulo 9 apresent ou o processo de desenvolvimento iterativo. Seguir um processo de desen-
volvi mento iterat ivo permi tir que voc construa rapidamcntc uma implemental'lo de vin-
te-e-um simples. Cada iterao conti nuar a acrescentar mais funcionalidades no jogo.
Dia 15
Tal estratgia possi bilita resultados rpidos e quamificveis. Seguir tal estratgia permite a voc
tratar dos problemas confonne eles apareerem - no tudo de uma vez, no fina l do desenvolvi-
mento. Uma estratgia iterativa impede que voc seja atropelado por uma avalanche de proble-
mas no final do desenvolvi mento.
Fundamental para um desenvolvimento iterativo o planejamento das iteraes o melhor que
voc puder, desde o incio. Quando novos fatos se apresentarem, totalmente aceitvel rever o
plano; entretanto, um esboo das iteraes desde o incio, proporciona uma orientao para o
projeto, objetivos e, mais importante, d uma idia do que se vai obter quando os objet ivos forem
at ingidos.
Normalmente, voc planeja suas iteraes classificando os casos de uso pela importncia. Ao
trabalhar com um cli ente, melhor deix-lo classificar a importncia de cada caso de uso. No
caso do jogo vinte-e-um, voc deve classificar os casos de uso com base em sua importncia
para o j ogo. Escolha os casos de uso absolutamente necessrios para jogar e faa esses casos de
uso primeiro. Outros casos de uso podem esperar iteraes posteriores. Tal estratgia permite
que voc crie um jogo runcional o mais rpido possvel.
Para os propsitos do projeto do jogo vi nte-e-um, existiro quatro iteraes principais.
Iterao 1: jogo bsico
A Iterao I criar o jogo bsico. Ela refinar e implementar os casos de uso preliminares a segui r.
Casos de uso do jogador:
I. Receber mai s cartas.
2. Parar.
3. Estourar.
Casos de uso da banca:
I. Di stribuir cartas.
2. Receber mais erutas.
3. Parar.
4. Estourar.
No final da It erao I, voc dever ter um jogo que jogado na linha de comando. O jogo ter
dois participantes: a banca e um jogador. A banca distribuir as cartas e pcnn itir que cada joga-
dor receba mais cart as, at decidir parar ou estourar. Aps cada j ogador jogar, ojogo terminar.
Aprendendo a combinar teoria e processo 355
Iterao 2: regras
A It erao 2 adicionar regras ao jogo. A Iterao 2 refinar e implementar os casos de uso pre-
liminares a seguir:
Casos de uso do jogador:
1. Consegui r um vinte-e-um.
A banca pode:
1. Efetuar o jogo (detectar ganhadores, perdedores e empates).
2. Conseguir um vinte-e-unt.
No final da Iterao 2, tudo da it erao I ainda func ionar. Alm disso, o jogo detectar e indica-
r quando um jogador ti ver um vinte-e-um, estourar, parar, ganhar, perder e empntar.
Iterao 3: aposta
A Iterao 3 acrescentar aposta bsica e em dobro ao jogo. A Iterao 3 refinar e implementar
os casos de uso preliminares a seguir:
Casos de uso do jogador:
1. Fazer apostas.
2. Dobrar.
Casos de uso da banca:
1. Efetuar o jogo (para aposta).
No final da lterao 3, tudo dns Iteraes 2 e 1 ainda funcionar. Alm di sso, o jogo permiti r
aposta bsica e em dobro.
Iterao 4: interface com o usurio
Alterao 4 dar nlguns toques fi nais na UI de linha de comando e construi r uma UI grfica. A
lterao 4 refinar e implementar os casos de uso preli minares a seguir:
Casos de uso do jogador:
1. Decidir jogar novamente.
2. Sair.
NOTA
Dia 15
Para os propSitos deste projeto, a aposta segura e a diviso de pares foram
omitidas. Esses recursos so deixados como exerccio para o leitor . Vin-
te-e-um um jogo com muitas variantes. Freqentemente, o seguro no per-
mi tido e a di viso complica demasiadamente o sistema. Considere essa
vari ante como um novo livro deste, dedicado ao j ogo vinte-e-uml
l embre-se apenas de que voc ouviu falar sobre isso primeiro aqui.
Iterao 1: jogo bsico
A lio de hoje o conduzir atravs da primeira iterao dojogo de cartas vinte-e-um. No fina l da
lio de hoje, voc ter o esque leto bs ico de um j ogo vi nte-c-um.
NOTA
Antes de cada seo. talvez voc queira deixar o livro de lado e l entar fazer a
anli se, projeto ou impl ementao.
Se voc f izer suas prprias experincias, certifiquese de voltar, ler cada seo
e comparar seu trabalho com o material apresentado, antes de continuar. Ten-
te avaliar criteri osamente todas as di screpncias entre sua sOluo e a sol uo
do livro. Embora voc possa ter uma soluo superior (existem muitas manei-
ras de encarar esse jogo). Certi fique-se de estar correto e de que sua soluo
segue os princpios da poa.
Anlise do jogo vinte-e-um
A iterao de hoje refinar e implementar os casos de uso a seguir:
Casos de uso do jogador:
1. Receber mais cart as.
2. Parar.
3. Estourar.
Casos de uso da banca:
I . Distribuir cart as.
2. Receber mais cartas.
3. Parar.
4. Estourar.
Aps ter um conj unto de casos de li SO refinados, voc pode criar um modelo inicial do domni o e
iniciar o projeto.
Apre nde ndo a combinar teoria e processo 357
Refinando os casos de uso
Vamos comear com o caso de uso de distri buio de cart as da banca, pois essa ao inicia o
Jogo.
Primeiro, voc precisa descrever o caso de uso em um pargrafo:
Comeando com o pri mei ro jogador, a banca distri bui uma carta aberta para cada j ogador,
terminando com ela mesma. Ento, a banca repete esse processo, mas distri bui sua prpri a
carta fechada. A distribuio de cartas tennina e ento o j ogo comea, quando a banca tiver
distribudo para cada jogador, incluindo ela mesma, duas cartas.
Distribuio de cartas:
I. A banca di stribui uma carta aberta para cada jogador, incluindo ela mesma.
2. A banca distribui uma segunda carta aberta para lodos os jogadores, menos para ela
mesma.
3. A banca di stribui uma carta fechada para ela mesma.
Condies prvias:
Novo jogo.
Condies posleriores:
Todos os j ogadores e a banca tm uma mo com duas cartas.
Os casos de uso Jogador recebe mais carIas e Jogador pra seguem natural mente. Vamos co-
mear com o caso de uso Jogador recebe mais carlOs:
O jogador decide que no est satisfeito com sua mo. O jogador ai nda no estourou; portanto,
ele decide receber mais cartas. Se o j ogador no estourar, ele pode optar por receber mais cartas
novamente ou parar. Se o jogador estourar, o jogo passar para o j ogador seguinte.
Jogador recebe mais cartas:
1. O jogador decide que no est satisfeito com sua mo.
2. O jogador solicita out ra carta da banca.
3. O jogador pode decidir receber mais cartas novamente ou parar, se o lotai em sua mo
for menor ou igual a 21.
Condies prvias:
O jogador tem uma mo cuj o valor total menor ou igual a 21.
Condies posteriores:
Uma nova carta acrescentada na mo do jogador.
Alternativa: o j ogador estoura
Uma nova carta faz a mo do jogador ultrapassar 21 . O jogador estoura (perde). Em se-
guida, comea a vez do prximo jogadorlbanca.
Dia 15
Jogador pra um caso de uso simples:
O jogador decide que est satisfeito com sua mo e pra.
Jogador pra:
1. O jogador decide que est cont ente com sua mo e pra.
Condies prvias:
O j ogador tem uma mo cujo valor menor ali igual a 21.
Condies posteriores:
A vez do jogador termina.
Neste pont o, est se tornando claro que Jogador/Banca estoura no um caso de uso, pois isso
um subproduto de outras aes. A banca e o jogador nunca executaro uma ao de estouro; n ~
tretanto, os j ogadores optaro por receber mais cartas ou parar.
Com os casos de uso E:Nouro removidos, apenas os casos de uso Banca recebe mais carias e
Bal1ca pra permanecem. Vamos comear com o caso de uso Banca recebe mais carIas:
A banca deve receber mais cartas se o total em sua mo for menor que 17. Se a banca no s t o u ~
rar aps receber mai s cartas e o total em sua mo ainda for menor que 17, ela deve receber mais
cartas novamente. A banca deve parar em qualquer total maior ou igual a 17. Quandoa banca s ~
toura ou pra, o jogo termina.
Banca recebe mais cartas:
I. A banca recebe mais cartas se sua mo menor que 17.
2. Nova carta acrescentada na mo da banca.
3. Se o talaI for menor que 17, a banca deve receber mais cartas novamente.
Condies prvias:
A banca tem uma mo cuj o total menor que 17.
Condies posteri ores:
Nova carta na mo da banca.
O jogo termina.
Alt ernativa: banca estoura
A nova carta faz a mo da banca ser maior que 21. A banca estOura.
Al ternativa: banca pra
A nova carta faz a mo da banca ser maior ou igual a 17. A banca pra.
Assi m como Jogador pra, Banca pra relati vament e si mples:
A banca tem na mo um total maior ou igual a 17 e pra.
A banca pra:
Aprendendo a combinar teoria e processo
4. A mo da banca tem um total maior ou igual a 17 e pra.
Condies prvias:
Mo da banca maior Oll igual a 17 .
Condies posleri ores:
Jogo tennina.
Modelando os casos de uso
359
Para a It erao 1, os casos de LI SO so mui to simples. Os modelos de caso de uso seri am mais pe-
sados do que interessantes; portanto, eles sero omitidos.
As interaes entre a banca e os jogadores so um pouco mais interessantes. A Figura 15.2 mos-
tra a seqUncia de eventos seguida dentro do caso de uso Distribuir carias. A Figura 15.3 mostra
a seqncia de eventos seguida dent ro do caso de uso Jogador recebe mais carias.
FIGURA 15.2
O diagrama da .eqll/lcia
do caso de liSO Di stribui
cartas.
Jogador
,
MICO de Cartas
, ,
__ ___ -1- ____________ -O
. ..:. uma carta I
\- DistribuI carta aberta _ I :
Recupera carta . D'

: uma carta
, ,
Oistribui carta abarta I I
, ,
f- :
,
- - - - - - - - - - - - ' - - - - - - - -1]
Distribui carta aberta
,
,
,
,
,
,
,
,
,
,
Dia 15
FIGURA 15.3
*- *-
MI'; "I '11l1::!
O diagra/J/a da seqiil!lIcia do
caso de liSO Jogador recebe
Jogador
..
,
,
,
,
mais cartas.
,
,
,
,
,
,
,
,
,
,
,
Sol icita uma nova carta
Modelando o dominio
,
,
,
,
,
,
,
,
,
,
,
,
Adiciona carta na mo
Recupera uma Ctlrta
------- -----<,J
uma carta
Usando os casos de uso como base para o modelo de dom nio, voc pode isolar sete objetos do
domnio diferent es: BlackjackGame, Oealer, Player , Card, Oeck, OeckPile e Hand (Jogo vin-
te-e-um, Banca, Jogador, Carta, Baral ho, Mao de cartas e Mo). A Figura 15.4 mostra o diagra-
ma do modelo de domnio resultante.
Projeto do jogo vinte-e-um
Aplicando projeto orientado a objetos na anlise anteri or, voc chegar a um modelo das classes
principais do projeto, suas responsabi I idades e uma definio de como elas vo interagir e obter
suas informaes. Voc pode ento pegar o projeto e trabalhar na implementao.
Cartes CRC
o modelo de domnio fornece um bom ponto de partida para urna li sta inicial de objetos. Com
essa lista de objetos, voc pode usar cartes CRC para mostrar as vrias responsabilidades e co-
laboraes dos objetos.
Antes de conti nuar, pode ser um bom exercicio para voc, tent ar gerar uma li s-
ta de cartes CAC por conta prpria.
FIGURA 15.4
O /1/odelo de
domnjo do jogo
villle-e-/l/1/.
Apre nde ndo a combinar teoria e processo
Vinte-e-um
7'

1 ... 7
Jogador
,
,
,
MOo
Banca
,
,<
0 ... 19
Carta
I
52
36,
Mao de cartas
,
,
4
Baral ho
,
As fi guras 15.5 a 15. 11 ilustram a possvel sada de uma sesso de cart o CRC.
FI GURA 15 .5
O C(m(io CRC do
jogo l,jllle-e-lIl11.
Vinte-e-um


Oiiii


I
,

Banca
FIGURA 15.6
O caru10 CRC
Baralho.
FIGURA 15.7
O camio CRC Corra.
Dia 15
Banca
Carta
FIGURA 15.8
O caru10 CRC
Jogador.
FI GURA 15.9
O cllrll10 CRC
Banca.
Aprendendo a combinar teoria e processo 363
Jogador
Banca herda de jogador
FIGURA 15.10
O caru10 CRC Mt1o.
FI GURA 15.11
O cllrll10 Mao de
cOrlas.
A UI de linha de comando
Dia 15
Mo
Mao de cartas
o Capt ulo 13, ';00 e programao de interface com o usuri o", apresentou o padro de projeto
MVC. A UI do jogo vinte-c-um utili zar o padro de projeto MVC. Como resultado dessa deci-
so de projeto, voc precisa adici onar um mecanismo observador no Jogador, assim como um
objeto Console para apresentar os jogadores e recuperar entrada do usuri o.
Como existe apenas um Consol e, o objeto Consol e um candidato para o padro Singleton.
o modelo do jogo vinte-e-um
Ao todo, nove classes e duas interfaces constituem o modelo de classe Blackj ack (vinte-e-um)
completo. A Figura 15. 12 ilustra o modelo.
FIGURA 15.12
O modelo de
classe
alackjack.
Aprendendo a combinar t eoria e processo
MO"'" 'MI ):booI"
_PiOre< 1";1'1 .,.,,, )
newG.omel )
365
A prxima seo detalhar a implementao desse modelo.
A implementao
As sees a seguir fornecem a implementao das partes principais do modelo ilustrado na Figu-
ra 15. 12.
NeTA
A classe Card
Todo o cdigo-fonte est disponvel para download na pgina da Web deste li -
vro. Visite o endereo www.samspubl i shi ng. com e na guia BookSt ore digi te o nu-
mero ISBN 0672321092; em seguida, na pgina do livro Sams Teach Yoursel f
Object Oriented Programming in 21 Days, d um cli que no link Downloads e
depois em Source Code.
A classe Card (Carta) implementada de fonna muito parecida cam a classe Card apresentada
no Captulo 12, Padres avanados de projeto". A classe Rank (Nmero) mudou um pouco. A
Listagem 15.1 apresenta a nova implementao da classe Rank (Nmero).
LISTAGEM 15.1 Rank.java
i mpo rt java.utll.Col l ections;
impo rt java.utll.list;
impo rt java.ut il.Arrays ;
public final cl ass Rank (
publ i c static final Rank TWO
public static fina l Rank THREE
public stati c fi na l Rank FOUR
public static final Rank FIVE
pu bl ic static fi na l Rank SI X
publi c static fi na 1 Rank SEVEN
pub 1 i c static fi na l Rank EIGHT
pu bli c static fi nal Rank NINE
publ ic st atic fi na 1 Rank TEN
publ ic st atic final Rank JACK
publ ic static fi nal Rank QUEEN
publ ic static fina l Rank KING
publ ic stat i c final Rank ACE
Dia 15
oew Rank( 2,
new Rank( 3,
new Rank( 4,
new Rank( 5,
new Rank( 6,
new Rank( 7 ,
new Rank( 8,
new Rank( 9,
new Rank( 10,
new Rank( 10,
new Rank( lO,
new Rank( l O,
new Rank( 11,
private stati c fina l Rank [] VAl UES =
I TWO. THREE , FOUR, FI VE , SIX, SEVEN,
"2" ) ;
" 3 " ) ;
"4" ) ;
" 5 " ) ;
"6" ) ;
"7" ) ;
" 8 " ) ;
"9" );
"10" ) ;
"J"
) ;
"Q" ) ;
" K" );
"A" );
EI GHT. NINE, TEN. JACK, QUE EN, KING, ACE I ;
)
II fornece uma lista nao modif icve l para fa zer lao
publ ic sta tic final llst RANKS ,.
Collections .unmodif iableLi st( Arrays . asList( VAl UES ) ) ;
private fi nal int rank;
private fi nal St ring di splay;
private Rank ( lnt rank,String display ) {
this.rank a rank;
this.display = di spl ay;
)
public i nt getRank() {
return rank;
I
publi C Stri ng toSt ring() {
return di spl ay;
I
Aprendendo a combinar teoria e processo 367
Voc notar que as constantes da classe Rank (Nmero) foram at ualiL1das para refletiras valores nu-
mricos do jogo vi nte-e-um. A classe tambm foi alterada para comer um objeto pblico l ist no
modificvel, em vez do array modificvel apresentado no Capitulo 12. Usar um objeto l ist
no modificvel impede modificaes inadvert idas da enumerao li sL
As classes Deck e Deckpil e
A classe Deck (Baralho) mudou consideravel mente em relao ao apresentado no Capitulo 12. A
Listagem 15.2 apresenta a nova implementao.
LI STAGEM 15.2 Deck.java
import java.uti l .lterator:
import java.util . Ra ndom:
publi c class Deck (
}
private Card [) deck:
private int index:
publ ic DedO {
buildCardsO:
}
public void addToStack( Deckpile stack) {
stack.addCards( deck ):
}
private voi d bui ldCardS() (
deck new Card [52):
}
Iterator suits E Suit. SUITS.iterator() :
int counter O:
while( s uit s .hasNext() ) (
}
Sui t suit (Suit) suits .next();
Iterator ranks Rank.RANKS .iterator() ;
whi l e( ranks . hasNext() ) (
}
Rank rank (Ra nk)ranks . next():
deck[counter ] new Ca rd( su'it, rank ) :
counter++:
Dia 15
A classe Deck (Baralho) si mplesment e sabe como construir seus objelos Card (Cartas) e depois
inseri r-se em Deckpi l e (Mao de cartas). A Listagem 15.3 apresenta Deckpi 1 e (Mao de cartas).
LI STAGEM 15.3 Deckpil e . java
import java.ut i l.Arraylist ;
import java.ut i l . l t erator;
import java . util.Random;
publiC class Deckpile (
private Arraylis t stack - new Arraylist () ;
private int index ;
private Random rand = new Random() ;
public void addCards{ Card [] cards ) {
}
for( lnt i O; i < cards.lengt h; i ++ ) {
stack.add{ cards [i] ) i
}
publ ic void shuf f le() I
reset();
randomizeO;
randomizeO;
randomi ze O ;
randomizeO;
}
publ ic Card dealUp() (
}
Card ca r d a deal() ;
if( card la nul1 ) {
card.se tFaceUp{ true l ;
}
re turn card ;
public Card deal0ownO (
}
Card card a deal();
i f( card ! - null )(
card . setFaceUp( false );
return cardi
}
publi C void resetO {
index - O;
Aprendendo a combinar teoria e processo
LI STAGEM 15.3 Oeckpile.java (continuao)
J
J
lterator i .. stack.iterator();
while( 1.hasNext() ) I
J
Ca rd card - (Card) i.next() ;
card.setFaceUp(false);
private Card deal () {
J
if( index ,- stack.size() ) I
J
Card card - (Card) stack.get( index , ;
i ndex++;
return card ;
return null;
private void randomize() {
J
int num_cards .. stack.size();
for( int 1 - O; i < num_cards; i ++ ) (
int index rand.nextlnt( num_cards ) ;
Card card_i .. (Card) stack.get( i };
J
Ca rd card_lndex .. (Card) stack.get( index );
stack.set( I, card_index }i
stack.set( index, card_i };
369
A classe Deckpi le (Mao de cartas) sabe como embaralhar seus objetos Card (Cartas), di stri -
bu-los e acrescelllar objetos Card (Cartas) para si mesmo. Ao contrrio da classe Deck (Baralho)
original, Deckpile (Mao de carias) mantm uma referncia para todos os objetos Card (Carta)
que retorna. Desse modo, e le pode recuperar faci lmente todos os objetos Card (Carta) c se recon-
figurar. Embora isso no modele completamente o mundo real, simplifica muito o gerenciamen-
to de cartas.
Entender o raciocnio existente por trs dessas alteraes importante. Oec k (Baralho) e Deckpi-
1 e (Mao de cartas) implementam apenas os comportamentos de que o j ogo precisa. Essas clas-
ses no fornecem funcionalidade adicional ' apenas para o caso de precisarmos algum dia'.
impossvel prever o futuro e voc no tem quaisquer requi si tos de funcionalidade extra; portan-
to, voc no deve acrescent -Ia at saber que precisa dela.
Se voc tentar implementar toda possi bi lidade de ' e se' ou realizar uma abslrao prematura,
nunca acabar de implementar suas classes. Se voc conseguir temlin- Ias, so boas as chances
Dia 15
de que a funcionalidade ou abstrao acrescentada no esteja correta. Alm disso, voc s ter
mai s trabalho a fa7.er, pois preci sar manter uma funcionali dade que ningum mais precisa ou
usa.
Tentar programar toda hi ptese 'e se ' um problema comum, encontrado por programadores
iniciant es em 00. Voc deve evi tara tentao de adicionar mais funcional idade do que a absolu-
tamente exigida para seus objetos! Entretanto, voc deve isolar as partes do sistema que sabe que
mudaro.
As classes Player e HumanPlayer
A classe PI aye r (Jogador) contm um objeto Hand (Mo). A Listagem 15.4 apresenta a classe
Hand.
LISTAGEM 15.4 Hand.j ava
import java.util . ArrayList:
i mport java.ut i l.lterator:
publi c class Hand {
private ArrayList cartas new ArrayList();
private stat ic fina l i nt BLACKJACK z 21:
publiC void addCard( Ca rd card )1
cards.add( card ):
J
publi c boolean bust() {
J
i f( total() > BlACKJACK ) {
return true:
J
return fa lse :
public vo1d reset() {
cards . clear() ;
J
publi c void turnOver(){
J
lterator i z cards. iterator();
while( i.hasNext() ) {
J
Card card (Card)i.next{) :
card. setFaceUp ( true }:
Apre nde ndo a combinar teoria e processo
LI STAGEM 15.4 Hand.java (continuao)
}
publiC String toString() {
Iterator i cards.iterator()j
String string - ."j
whi l e( i.hasNext() ) {
Card card (Card) i .next()j
string string + " " + card.toStringOj
}
return stringj
}
publi C int total () {
int total Oj
}
Iterator i cards .i ter ator() j
wh i le( i .hasNext() ) {
Card card - (Card) i.next{)j
total +- card. getRank() . getRank() j
}
return t ot a I j
371
A classe Hand (Mo) sabe como adicionar objetos Card (Canas) em si mesma, reconfi gurar-se,
virar suas canas, calcular seu total e representar-se como uma String. Voc pode notar que a
classe Hand (Mo) conta ases apenas como II. A prxima iterao acrescentar supone para con-
tagem de ases como I ou I I .
As listagens 15.5 e 15.6 apresentam as classes PI ayer (Jogador) c HumanPI ayer (Jogador Huma-
no), respectivamente.
LISTAGEM 15.5 Player .java
impor t java.uti l . ArrayList j
import java.util.rterator j
publ ic abst ract class Pl ayer {
private Hand hand j
private String name j
private ArrayList l isteners new ArrayList()j
public Pl ayer( St ring name , Hand hand ) {
this . name name j
this . hand hand j
}
Dia 15
LISTAGEM 15.5 P1ayer.java (continuao)
publi C void addCard{ Ca rd card ) I
hand. addCa rd( card ) ;
notifyLis teners();
}
public void play( Dealer dealer ) {
}
II como antes, joga at que o jogador estoure ou pare
while( !isBusted() &&hit() ) (
dealer.hlt( this );
}
II mas, agora, diz banca que o jogador terminou , caso contrrio, nada
II acontecer qua ndo o jogador retornar
stopPlay( dealer );
publi c voi d reset() {
hand.resetO;
}
publi c boolean isBusted() (
return hand.bust();
}
publiC void addListener{ PlayerListener 1 ) (
listeners.add( 1 );
}
publ iC String toString() {
return ( name + ":" + hand.toString() };
}
protected Hand getHand() {
return hand;
}
protected void notifyLis teners() {
Iterator i l i steners . iterator();
while( i .hasNext() ) {
}
lU
}
PlayerListener pl (PlayerListener)i.next() ;
pl.handChanged( this ) ;
A chamada de passTurn DEVE ser dentro de um mtodo protegi do. Oealer
Apre nde ndo a combinar teoria e processo 373
LI STAGEM 15.5 P1ayer.java (continuao)
J
* precisa sObrepor esse compor tamento! Caso contrrio, O l ao ser infinito.
"/
protected void stopPlay( Dea l er deal er ) {
deal er.passTurn();
J
protected abstract bool ean hit();
LI STAGEM 15.6 HumanPlayer .java
publ ic class HumanPlayer extends Player {
J
private fi na 1 static String HIT
,
"H" ;
private f i na 1 static String STAND
,
"S" ;
private final static String MSG "[H] it or [5] t ay' ;
private final static String DEFAUL T
,
"inval id":
publ ic HumanPlayer( String name, Hand hand ) I
supere name , hand );
J
protected boolean hi t() {
J
while( true ) I
Console.lNSTANCE.printMessage( MSG );
J
String response Console.INSTANCE.readI nput( DE FAULT ):
if( response.equalslgnoreCase( HIT ) ) {
return true;
I else if{ response.equalsIgnoreCase( STANO ) ) I
return f alse :
J
II se chegarmos aqui , faz um lao at obtermos entrada significat i va
A classe abstrata Player(Jogador) define todos os comportamentos e atributos comuns a objetos
Player (Jogador) e Dealer (Banca). Esses comportamentos incl uem mani pular a classe Hand
(Mo), cont rolar objetos Pl ayerli stener e jogar uma rodada.
Pl ayer defi ne um mtodo abstrato: public bool ean hit(). Durante o j ogo, a classe base Pl ayer
(Jogador) far uma chamada para esse mtodo, para detenni nar se deve continuar a receber car-
Ias ou parar. Subclasses podem implementar esse mtodo para fornecer seus prprios comporta-
Dia 15
mentos especfi cos. Por exemplo, HumanPlaye r (Jogador Humano) pergunta ao usuri o se vai
conti nuar recebendo cartas ou no ou se vai parar. Quando o objeto Pl aye r (Jogador) acaba de
jogar, ele informa o objeto Oealer (Banca), chamando o mtodo pass TurnO de Oeal er (Banca).
Quando o objeto Pl ayer (Jogador) chama esse mtodo, Oea ler ( Banca) diz a next Player (Joga-
dor) para que jogue.
Dea 1 er - Banca
Deal er (Banca) uma interface que especi fica os mtodos extras que um objeto Dea 1 er (Banca)
vai expor. A Li stagem 15.7 apresenta a interface Dea ler (Banca).
LISTAGEM 15.7 Dealer .java
publ ic interface Dealer (
publ ic voi d hlt( Player jogador )i
publ iC void passTurn( );
I
A Li stagem 15.8 apresenta Bl ackjackOealer.
LISTAGEM 15.8 BlackjackOealer.java
import java . utl1.Arrayl isti
import java. ut i l . l terator;
public class Bl ackjackDealer extends Player i mplement s Dealer (
private Deckpile cardsi
private Arraylist players new Arraylist()i
private int player_l ndex i
publi C Bl ackjackDeal er( Stri ng name , Ha nd hand, Deckpl1e cards ) (
super( name, hand )i
this.cards cards i
I
publ ic void passTurn() (
i f( player index != players.size() ) (
Player pl aye r (Player) players.get( player_index )i
player_index++i
player.play( this ) i
) el se {
Aprendendo a combinar teoria e processo
LISTAGEM 15.8 8lackjackDealer.java (continuao)
this.play( this li
I
I
publiC void addPlayer( Player player l I
players.add( player )i
I
public vold hlt( Player player l {
player.addCard( cards . dealUp() )i
I
II sobrepe para que a banca mostre suas cartas antes que comece a jogar
public void play( Dealer dealer ) I
exposeCardsO j
super.play( dealer )i
I
publ iC void newGame() I
I
II distribui as cartas e diz ao primeiro jogador para comear
d"'(};
passTurnO i
publ i c void deal () I
cards.shuff le();
375
II reconfigura cada jogador e distribui uma carta aberta para cada um e
para si mesma
mesma
Pl ayer [] player new Player [players.size()] i
players.toArray( player li
for( int i Oi i < player. length i i ++ ) {
player [1].resetO i
player [1] .addCard( cards.dealUpO l i
I
this.addCard( cards.dealUp() ) i
II distribui mais uma carta aberta para cada jogador e uma fechada para si
for( int i ., Oi i < pl ayer . length i i ++ ) {
player (i]. addCard( cards.dealUp() )i
I
this . addCard( cards.dealDown(l li
Dia 15
LI STAGEM 15.8 8lackjackDeal er.java (continuao)
}
}
protected vo1d stopPl ay ( Oealer dea l er ) {
}
II no faz nada aqui , na banca, s i mplesmente deixa o jogo parar
II se i sso no fosse sobreposto , chamaria passTurn() e
II faria um lao infinito
protected bool ean hit() {
}
if( getHand().total() <- 16 ) {
return true;
}
return false ;
private vo1d exposeCards ( ) {
getHand() . tur nOver() ;
notifylisteners() ;
}
BlackjackOea ler ( Banca21 ) herda de PI ayer (Jogador) porque um objeto Oea ler ( Banca) t m ~
bm um objeto Pl ayer (Jogador). Alm dos comportament os fornecidos por um objeto PI ayer
(Jogador), a banca tambm contm o objeto PI ayer (Jogador), que di stribui canas para esses ob-
jetos PI ayer (Jogador) e diz a cada um para que j ogue, quando chega sua vez. Quando um objeto
PI ayer (Jogador) chama o mtodo passTurn () de Oealer (Banca), ele sabe deixar o prximo ob-
jeto PI ayer (Jogador) j ogar.
A Figura 15. 13 il ustra a interao entre a banca e os jogadores.
8lackjackDealer (Banca2 1) sobrepe seu mtodo stopPI ay () para que ele termine de jogar. A
banca tambm implementa o mtodo hit ( ) para que ele retorne t rue quando a mo for menor
que 17 e false quando a mi'lo for igual ou mai or que 17.
BlackjackGame (Jogo 211
As listagens 15.9 e 15. 10 apresentam as classes Bl ackj ack e Consol e, respectivamente.
LISTAGEM 15.9 81ac kj ack . java
publ; c cl ass Blackjack {
publ ic s tat; c vo1d ma in ( St r ing [J args ) I
Oeckp ile cards = new Oeckpi le() ;
Aprendendo a combinar teoria e processo
LISTAGEM 15.9 8lackj ack.java (continuao)
for{ int i O; i < 4; i ++ ) (
cards . shuffle () ;
J
Oeck deck new Deck{) ;
deck.addToStack ( cards );
cards.shuffle () ;
Hand dealer hand new Hand();
BlackjackDealer dealer new BlackjackDealer( "Dealer", dealer_hand,
cards );
J
J
Hand human_hand new Hand();
Pl ayer pl ayer new HumanPlayer( "Human", human hand );
dealer.addlistener( Console.INSTANCE ) ;
player.addlistener( Console. INSTANCE ) i
dealer . addPlayer( player );
dealer.newGame( );
FI GURA 15.13
377
II illferalio elllre jogadores
e a bal/ca.
Banca vinte-eum Jogador Jogador
,
,
O
plaV Idealer)
,
/
Enquanto
>
estourado
e pedindo
,
n.
hitO
maiscartu
,
hil()
,
,
O
hit (plaver)
;
'r'
addCard (card)
,
,
,
stopPlav()
,
r'l -
,
passTurn( )
,
,
,
,
,
,
,
,
plav (dealer)
U
,
,
Dia 15
LI STAGEM 15.10 Console.java
i mpo rt java.io. BufferedReader;
i mpo rt java.io. InputStreamReader;
impo rt java.io. IOException;
I
publi C class Console implements Playerlistener (
I
II console si ngl eton
public final static Console INSTANCE = new Console() ;
private BufferedReader in K
new BufferedReader( new InputStreamReader( System.in ) };
public void printMessage( String message ) {
System.out.print l n{ message };
publiC String readlnput( String default_input ) (
String response ;
I
try (
return in.readli ne() ;
) cat ch (IOException ioe) {
return default_input;
I
public void handChanged( Player player ) I
printMessage( player.toString() };
I
II pri vate para impedir instanciao
private Console() {I
A classe Blackjack constri objetos Dea ler (Banca), Hand (Mo), Deckpile (Mao de cartas),
Deck (Baralho) e conecta todos eles. Uma vez conectados, ela comea o jogo dizendo ao objeto
Oea 1 er (Banca) para que inicie um novo jogo.
Consol e um si ngleton que d acesso linha de comando. Ele tambm recebe dados dos objetos
Player (Jogador) e, em seguida, os imprime na tela, sempre que eles so atualizados.
Uma armadilha procedural
Se voc vem de uma base procedural, poderia ser tentador implementar o mtodo newGame () de
BlackjackDeal er como ilustrado na Listagem 15.11.
Aprendendo a combinar teoria e processo 379
LI STAGEM 15.11 Uma impl ementao procedural de BlackjackOeal er
publ1c void newGameO {
I
cards . shuffle();
II reconfi gura cada jogador e distribui uma carta aberta para cada um e para
II si mesma
Player [) player new Player [players . size():
players.toArray( player ) :
for( i nt 1 O: i < player.length: i ++ ) {
player [i).reset();
player [i].addCard( cards.deaIUp() ) ;
I
this.addCard( cards .dealUp() ):
II distribui mais uma carta aberta para cada jogador e uma fechada para si mesma
for( int i O; 1 < player.length; i ++ ) {
player [i ].addCard( cards.dealUp() l;
I
this . addCard( cards.dealOown() ) :
II cada jogador joga e depoi s a banca
for( int i O; i < player.length: i ++ ) I
player [l).play(this):
I
exposeCa rds ();
this.play( this ) ;
Essa implement ao e limi na a necess idade do mtodo passTurn () ; entretanto, essa uma estra-
tgia procedural para o lao do j ogo. Em vez dos objctos PI ayer (Jogador) comuni carem ao ob-
jeto Dealer (Banca) que terminaram de jogar, Dealer (Banca) simplesmente faz um lao
seqUencial atravs dos PI ayers (Jogadores).
A Figura 15. 14 i lustra a interao entre Oea 1 er ( Banca) e seus objetos PI ayer (Jogador).
Voc notar que as interacs da Figura 15. 13 so muito mais dinmicas do que as interacs
que ocorrem na Figura 15. 14. A Figura 15.13 verdadeiramente um sistema de objetos intera-
gindo. Na Figura 15. 14, Dea l er ( Banca) simplesmente espera que o objeto PI ayer (Jogador) re-
tome e, ento, chama seqUencial mente o prximo objeto PI ayer (Jogador). No h nenhuma
interao alm de Oea l er ( Banca) dizer estaticamente para que cada objeto PI ayer (Jogador)jo-
gue em sua vez. Embora essa estratgia funcione, ela no muito nexvel e certamente no to
orientada a obj etos quanto a estratgia apresentada na Figura 15. 13.
380
FIGURA 15.14
A illlera(io procedI/mI
elflre Players Oogadores)
e Dealer (bal/ca).
Testando
Dia 15
Banca Jogador
, ,
play (deaferl
---.J hit ()
hit (pl ayer)
addCard (card)
play (deaferl
hit (playar)
addCard (card)
play (deaferl
,
,
,
, ,
Jogador
loap at
estourar
ou parar
,
,
,
,
,
hit ()

Confonne most rou o Captulo 14, "Construindo software confi vel atravs de testes", os testes
devem ser um processo di nmico. Um conj unto completo de testes est disponvel,j unto com o
cdigo-fonte, para download. Esses testes consistem em um conj unto de testes de unidade e ob-
jetos falsificados que testam completamente o jogo vinte-c-um. O estudo dos testes ser deixado
COmO um exerccio importante para o leitor.
Resumo
Hoje, voc analisou, projetou e implementou um jogo vinte eum bsico. Usando uma estratgia
iterativa, voc obteve os resultados que puderam ser vistos rapidamente. No decorrer da semana,
voc continuar a acrescentar funcionalidades nesse jogo vinte-e-um.
Voc tambm aprendeu algumas lies novas hoje. Ao programar, voc precisa evitar cair nas
annadi lhas procedura is, mesmo que uma estratgia procedural possa parecer a soluo nat ural.
Voc tambm deve aprender a evi tar a tentao de acrescentar mais detalhes em uma definio
de classe do que precisa.
Aprendendo a combinar teoria e processo 381
Perguntas e respostas
P Se os testes so to importantes, por que voc os pulou?
R No pulamos os testes. Todos os cdigos-fonte que podem ser carregados por download
esto repletos de casos de teste.
O texto pulou a discusso dos testes por restries de espao e eficcia. No achamos que
voc teria gostado, se fosse obrigado a ler incontveis pginas de cdigo de teste. O estu-
do e o entendimento do cdigo de teste (e, na verdade, todo o cdigo) so deixados como
exercicio para o lei tor.
P Parece huver muito mais cdigo do que o publicado no captulo-o que aconteceu?
R H muito mais cdigo. Simpl esment e no possvel abordar todo o cdigo efi ciente-
mente dentro do texto. Considere o tcxto como o 'fi lme dos destaqucs' do cdigo. Voc
precisar dedicar uma quantidade considervel de estudo pessoal para entender o cdigo
completamente.
O objetivo destes capt ulos finais apresentar um projeto global, do qual o cdigo apenas
um componente. A anlise e o projeto so igualmente importantes. Voc precisar dedicar
um tempo extra dentro dessa estrutura, estudando o cdigo, se quiser entend-lo totalmente.
Workshop
As perguntas e respostas do teste so fornecidas para seu melhor entendimento. Veja as respos-
tas no Apndice A, "Respostas",
Teste
J. Liste dois dos padres de projeto que voc viu hoje. Onde os padres foram usados?
2. Encontre um exemplo de polimorfismo no cdigo-fonte.
3. Encontre um exemplo de herana no cdigo-fonte.
4. Como a classe Oeck (Baralho) encapsula suas cartas?
5. Como 61 ackjackOeal er (Banca 21) e HumanP1 ayer (J ogador Humano) aluam de forma
polimrfica?
Exerccios
I. Faa o download do cdigo-fonte da iterao de hoje. Aps tero cdigo, compil e-o, faa-o
funcionar execut ando oj ogo vinte-c-um e, depois, tente entender como ele funciona. Ter
um entendimento lotai do cdigo exigir algum tempo e pacincia.
2. A lio de hoje foi bastante longa. No h outros exerccios. Examine o cdigo-fome e
reveja a li o.
SEMANA 3
DIA
Iterao 2 do jogo vinte-e-um:
adicionando regras
Ontem, voc reali zou a anl ise e projeto iniciais de um jogo vi lllce uTn. Hoje, voc conti nuar
esse processo e vai adicionar mais regras no jogo vinte-c- um.
Hoje voc aprender como:
Modelar os estados do jogo vi nte-c-um
Usar estados para remover lgica condicional
Regras do jogo vinte-e-um
Ontem, voc construi LI um j ogo vinte-c-um simples. O jogo que voc projetou e construi u di stri-
bua canas e pennit ia a um jogador jogar at parar ou estourar. Umjogo vinte-c-um real far um
pouco mais. Em um jogo vi nte-c-um real, os ases valem I ou 11 pont os. Osjogadores podem ob-
ter um vi nte-e-um, estourar, empatar, perder ou ganhar. A banca nem mesmo jogar se todos os
jogadores estourarem ou se receber uma mo que d vinte-e-um.
Hoje, voc vai adicionar a lgica necessri a para suportar esses e outros recursos adicionai s no
jogo. Como sempre, voc comear anali sando os casos de uso.
Dia 16
Anlise das regras
Para entender completament e todas as regras do j ogo vinte-e um, voc precisar rever cada um
dos casos de uso de ontem e acrescentar todos os novos casos de uso exigidos. Uma vez identi fi
cados os casos de uso, voc precisar atualizar o modelo de domnio.
Anlise de caso de uso das regras do jogo vinte-e-um
A adio de regras afeta muitos dos casos de uso identificados ont em. Existe tambm um novo
caso de uso: Banca efelllajogo. Vamos comear com o caso de uso Distribuir cartas, que voc
descobriu ont em:
Comeando com o primeiro jogador, a banca distribui uma carta aberta para cada jogador, termi-
nando consigo mesma. A banca repete ento esse processo, mas di stribui sua prpria carta fecha-
da. A distri buio de cartas termina e ento o jogo comea, quando a banca tiver distribudo para
cada j ogador, incluindo ela mesma, duas cartas.
o Distribuir cartas
I. A banca distribui uma carla aberta para cada j ogador, incluindo ela mesma.
2. A banca distribui uma segunda carta aberta para todos os jogadores, menos para ela.
3. A banca distribui uma carta fechada para ela mesma.
Condies prvias
o Novo j ogo.
Condies posteri ores
Todos os jogadores e a banca tm uma mo com duas cartas.
A vez do primei ro j ogador que no tenha vinte-e-um (duas cartas totali zando 2 1), co-
mea.
O j ogo cont inua para cada j ogador que no tenha vi nte-c-um.
o Alternativa: A banca tem vi nte e-ulll
Se a banca tiver um 2 1 natural, o jogo passar para o cumpri mento. Os jogadores no te-
ro sua vez.
O caso de uso Distribuir cartas acrescenta agora vrias novas condies posteriores, assim
como uma alternati va. O importante a notar que, se a banca tiver vinte-e- um, o jogo terminar
automaticament e. Do mesmo modo, qual quer jogador com vinte-e-um no joga.
Em seguida, reveja Jogador recebe mais cartas:
O jogador decide que no est sat isfeito com sua mo. O j ogador ainda no estourou, de modo
que decide receber mais cart as. Se o jogador no estourar, ele pode optar por receber mais cartas
novamente ou parar. Se o jogador estourar, o jogo passar para o j ogador segui nte.
Iterao 2 do j ogo vinte-e-um: adicionando regras 385
o Jogador recebe mais cartas
I. O jogador decide que no est satisfeito com sua mo.
2. O jogador soli cita outra carta da banca.
3. O jogador pode decidir receber mais cartas novamente Oll parar, se o total em sua mo
for menor Oll igual a 2l.
Condies prvias
O jogador tem lima mo cujo valor tOlal menor ou igual a 2 J.
o O jogador no tem vinte-c-um.
o A banca no tem vinte-e-um.
o Condies posteriores
o Uma nova carta ac rescent ada na mo do jogador.
o Alt ernat iva: O jogador estoura
A nova carta faz a mo do jogador ser maior que 21. O jogador estoura (perde); a vez do
prxi mo jogador/banca comea.
o Alternativa: mo do jogador > 21, mas o jogador tem um s
A nova carta faz a mo do jogador ser maior que 21. O jogador tem um s. O valor do s
muda de II para I, fazendo a mo do jogador ser menor ou igual a 21. O jogador pode de-
cidir receber cartas novamente ou parar.
Digno de nOla o fato de que um jogador s pode jogar se ele ou a banca no tiver vinte-c-um.
Esse caso de uso tambm introduz o fato de que um s pode ter um valor igual a I ou I I, depen-
dendo do que toma a mo mel hor.
Jogador pra tambm recebe mais algumas condics prvias.
O jogador decide que est sat isfeito com sua mo e pra.
o Jogador pra
1. O jogador decide que est contente com sua mo e pra.
o Condies prvias
o O jogador tem uma mo cujo valor menor ou igual a 21.
o O jogador no tem vinte-e-um.
o A banca no tem vinte-e-um.
o Condies posteriores
o A vez do jogador tcnnina.
Assim como em Jogador recebe mais carias, voc precisar alUalizar Banca recebe mais carias:
A banca deve receber mais cartas se o total de sua mo for < 17. Se a banca no estourar,
aps receber mais cartas, e o lotai de sua mo ainda for < 17, ela dever receber mais car-
Dia 16
tas novamente. A banca deve parar em qualquer total >= 17. Quando a banca estourar ou
parar, o jogo termina.
Banca recebe mais cart as
I. A banca recebe mais cartas se sua mo for menor que 17.
2. Nova carta acrescentada na mo da banca.
3. O total menor que 17, a banca deve receber mais cartas novamente.
Condies prvias
A banca tem uma mo cuj o total menor que 17.
Deve ser um jogador no estado de parada.
Condies posteri ores
Nova cart a na mo da banca.
Jogo termina.
Alt ernati va: Banca esloura
A nova cart a faz a mo da banca ser maior que 21; a banca estoura.
Al ternativa: Banca pra

A nova cart a faz a mo da banca ser maior ou igual a 17; a banca pra.
Alternativa: Banca lem s, pra
A nova carta faz a mo da banca ser maior ou igual a 21, mas incl ui um s. O valor do s
muda de I I para I, fazendo o lotai da banca ser 17; a banca pra.
Alternativa: Banca tem s, recebe mais cartas
A nova carta faz a mo da banca ser maior ou igual a 21, mas inclui um s. O valordos muda
de I I para I, fazendo o talai da banca ser menor que 17; a banca recebe mais cartas.
Esse caso de li SO acrescenta vrias condies prvias e variantes. A condio prvia, "Deve ser
um jogador no estado de parada", signifi ca que a banca s receber mais cartas se houver um jo-
gador para bater. Se nenhum jogador esti ver parado, isso signifi ca que todos os jogadores estou-
faram ou tm vinte-C-um. Alm disso, as novas alternati vas levam em conta o t to de que um s
pode ser cont ado como J ou como I I.
Do mesmo modo, a banca parar aut omat"icamente, se no houver nenhum oUl rojogador parado.
A banca tem uma mo cuj o total >-= 17 e pra.
Banca pra
I. A mo da banca d um talai maior ou igual a 17 e pra.
Condies prvias
Mo da banca maior ou igual a 17.
Deve ser um jogador no estado de parada.
Iterao 2 do j ogo vinte-e-um: adi cionando regras
Condies posteriores
Jogo tenn ina.
o Alternat iva: nenhum j ogador parado
387
Se no houver nenhum jogador parado, a banca parar automaticament e, independent e da
contagem da mo.
Quandoojogo tiver terminado, a banca precisar descobrir quem ganhou, quem perdeu e os em-
pates. O caso de uso Banca efelllajogo trata desse uso:
Aps todo o j ogo ter terminado, a banca verifica cada mo e determi na, para cada jogador, se ele
ganhou ou perdeu, ou se o j ogo deu empate.
Banca efet ua jogo
I. A banca veri fi ca a mo do primei ro jogador e a compara com a sua prpri a.
2. A mo do jogador maior que a da banca, mas no estourou; o j ogador ganha.
3. A banca repete essa comparao para todos os jogadores.
Condies prvias
Cada jogador passou por sua vez.
A banca passou por sua vez.
Condies posteriores


Resultados fi nais do j ogador detenninado.
Al ternativa: Jogador perde
A banca verifica a mo do jogador e a compara com a sua prpri a. A milo do jogador
menor que a da banca. O j ogador perde.
Alternativa: Empate
A banca verifi ca a mo do j ogador e a compara com a sua prpria. A mo do jogador
igual da banca. O jogo deu empate.
Alternat iva: Banca estoura

Se a banca estourou, cada j ogador que esti ver parado e com vinte-e-um, ganha. Todos
os outros perdem.
Modelando os casos de uso
A maior part e das al teraes nos casos de uso simples. Entretant o, pode ser ti l desenhar a se-
qncia de eventos para Banca elewajogo. A Figura 16.1 ilustra a seqncia de event os encon-
trada no caso de uso Banca ele/lia jogo.
I
388 Dia 16
FIGURA 16.1
*' *'
*'
O diagrama da seqiil!l1cia do
caso de liSO Banca cfctua jogo.
..
Jogado, Jogador
,
,
Solic:ite mio
,
,
'O
,
,
~
,
mio ,
,
,
Compara mios
,
,
,
,
Informa togado. do resultado I
,
,
,
I mo
, ,
,
,
n.
Compare mAas ,
,
,
,
Informa j ogador do resultado
,
,
,
Atualizando O modelo de dominio do jogo vinte-e-um
Da perspectiva do domnio, esses casos de uso novos e atualizados no o aheram.
Projeto das regras
Neste ponto, pode ser extremamente tentador ir di retamente para a implement ao. Superfi cial -
ment e, parece que voc pode implementar as regras atravs de condicionais. Na verdade, voc
pode impl ement- Ias atravs de condicionais. A Li stagem 16. 1 apresenta como poderi a ser uma
dessas condicionais.
LI STAGEM 16.1 Regr as condicionais dent r o de Bl ac kjackOealer ( Banca 21)
prot ec t ed voi d stopPl ay ( Deal er dealer ) {
1/ o j ogo termi nou , i dent i f i ca os ganhado res e os pe rdedores
i f ( isBusted () ) {
Iterator i .. players . i t erator () ;
whil e( 1. hasNext () ) {
I
} else {
Player playe r .. (Pl ayer) i . nextO ;
1f( !player. i sBus t ed() ) {
Console. INSTANCE . printMessage( player. t oSt r ing() .. " WINNER!!" ) ;
I
Iterao 2 do j ogo vinte-e-um: adicionando regras 389
LI STAGEM 16. 1 Regras condicionai s dentro de BlackjackDealer (Banca 2I) (cont . )
;t( hasBlackjackO ) (
lterator; players.iterator()i
while( i.hasNext() ) (
" STANOOFF!!- )i
" LOSER!! " )i
I
Player pl ayer = (Player) i.next() i
i f( player.hasBlackjack() ) (
Console. INSTANCE . printMessage( player.toString() +
I else (
Console.INSTANCE.p rintMessage( player.toStr1ng() +
I
I else ( II a banca no estourou e no tem vinte-e- um
Iterator i players.iteratorO;
wh1 1e( 1. hasNext() ) (
Player player (Player) i .next();
if( player.hasBlackjack() ) {
Console .INSTANCE.printMessage( player . toString() +
M WINNER WITH BLACKJACK!!" );
BUSTED! !" );
" WINNER! !" );
" STANDOFF! !" ) i
" LOSER!!" );
I
I
I
I
I el se if( pl ayer.isBusted() ) (
Console.INSTANCE.pr intMessage ( player.toStri ng() +
I else if( pl ayer.getHand().greaterThan( getHand() ) )(
Console.INSTANCE.pr intMessage( player.toString() +
I else if( pl ayer .getHand().equalTo(getHand() ) ) (
Console.INSTANCE. printMessage( player.toString() +
I else (
Console.INSTANCE.printMessage( player.toString() +
I
claro que essa condicional trata apenas do cumprimento do jogo. A banca precisar de muito
mais condicionais para saber se deve ou no comearajogar aps a dist ri buio e se deve ou no
deixar que um jogador jogue. Por exemplo, se a banca tiver uma mo com vinte-e-um, o jogo de-
ver termi nar automaticamente. Voc precisar de uma condicional para esse e todos os out ros
desvios do jogo.
Dia 16
Tal estratgia frgi l, difici I de manter, propensa a erros e simplesmente horrvel. Ao tratar com
condiciona is, voc freq Uent emente ver que o acrscimo de uma nova condicional faz um antigo
comport amento falhar. Tambm extremamente dificil entender cdigo repleto de condicionais.
Boa sorte para aqueles que precisam manter tal baguna condicional.
As estrut uras condicionais no so part iculannente ori entadas a objetos. O uso incorreto de con-
di cionais estraga as divises corretas de responsabi lidades, que so to importantes para a POO.
Ao usar condicionais, a banca degenera para uma funo procedural que verifica um fi ag no jo-
gador, toma uma deciso e, ento, diz ao j ogador o que fazer. A 00 no funciona assim! As con-
dicionais tm seus usos; ent retanto, elas nunca devem extrair responsabilidades de um objeto.
Em vez di sso, o conhecimento de se um jogador estourou ou se tem vinte-c-um deve estar conti-
do dentro do prprio objeto Pl ayer (Jogador); ento, quando um desses eventos ocorrer, o objeto
Player (Jogador) poder executar a ao correta e informar a BlackjackDeal er ( Banca 2 1), se
apropriado. Em vez da banca instruir os jogadores sobre o que fazer, os jogadores devem usar
seus prprios estados internos para tomar essas deci ses. Tal estratgia mode la mais preci sa-
mente o jogo vinte-e-um real.
O pri meiro passo para se desfazer das condicionais perceber quai s eventos e estados di ri gem o
jogo vinte-e-um. Por todo o j ogo vinte-e-um, os vri os jogadores se movem atravs de estados.
Em um ponto o jogador est esperando; depois est j ogando. Aps j ogar, o jogador passa para
um estado dc espcra ou de estouro. Do mesmo modo, a banca passa da distribuio para a espera
por sua vez, para o jogo e, fi nalmente, para a parada ou estouro.
Tambm existem transies de estado al ternat ivas. Aps receber suas cartas, a banca ou o joga-
dor pode mudar automat icamente para o estado de vinte-c-um, se receber uma mo quc totali ze
vinte-e- um.
Para ter total entendimento dos vrios estados. assim como dos eventos que movem o jogador de
um estado para outro, ajuda modelar os diversos estados atravs de um diagrama de estado.
Diagramas de estado
A UML defi ne um rico conj unto de notaes para modelar diagramas de estado. Em vez de
nos perdermos nos detalhes, usaremos apenas os aspectos necessri os para modelar o j ogo
vi nte-e-um.
Para os propsitos da modelagem do j ogo vinte-e-um, existem estados, transies, eventos, ati-
vidades e condies.
No jogo vinte-e-um, um estado a condio de jogo corrente de um jogador. Tais condies in-
cluem espera, j ogo, estouro, parada e vi nte-e-um, dentre outras.
As transies ocorrem quando um j ogador se move entre seus estados. Por exemplo, um jogador
muda do estado de j ogo para o estado de estouro, quando ele estoura.
Ite rao 2 do jog o vinte-e-um: adicionando reg ras 391
Os eventos so um tipo de estmulo que pode fazer um jogador mudar entre seus estados. Por
exemplo, quando a mo do jogador causar um estouro, o jogador mudar do estado de jogo para
estouro.
A tividades so as aes executadas quando se est em um estado. Por exemplo, ao j ogar no esta-
do de jogo, um jogador optar por receber mais cartas at decidi r parar ou estourar.
Condies de guarda so uma expresso booleana que coloca algum t ipo de restrio em uma
transio. Por exemplo, um jogador mudar para o estado de parada, se decidi r no receber mais
cart as.
A Figura 16.2 apresenta a notao que voc usar para modelar os estados do jogo vinte-e-um.
FIGURA 16.2
A //O/(/r70 do diagrama
de estado.
__
( alividade ..
No modelo, as transies so simbolizadas atravs de setas. As transies podem ocorrer como
resultado de um evento ou de uma condio (ou uma combinao dos dois). O evento e a condi-
o devem aparecer na seta de tronsio para que seja bvio o motivo da ocorrncia da transio.
Voc tambm notar que uma transio pode voltar paro o estado corrente. Tal transio co-
nhecida como outotrollsio.
Finalmente, se o obj eto exccuta cena ao quando est no estado, a ao regi strada como uma
ati vidade dentro do smbolo de estado. completamente vlido paro um estado no ter uma ati-
vidade.
Modelando os estados do jogador
A Figuro 16.3 apresent a o diagrama de estado do jogador.
O jogador tem ci nco estados principais: Espero, Vinte-c-um, Jogo, Parado e Estouro. O jogador
comea no estado Espcra. Aps a distribuio de cartas, o j ogador muda para o estado Vin-
te-c-um ou Jogo, dependendo da mo de canas recebida.
Quando sua vez de jogar, o jogador faz isso (a atividade do estado Jogo). Ao jogar, o jogador
decide receber mais canas ou parar. Se o jogador decidir parar, ele mudar para o estado Parado.
Se o jogador receber mais cart as, mudar para o estado Estouro, se sua mo causar estouro, ou
voltar para o estado Jogo, se der para jogar com a mo. Isso continua at que o jogador estoure
ou pare.
FIGURA 16.3
O diagrama de
eSfado
do jogador.
!
Espers
Dia 16
m60 vinte-e-um [mo __ 211
Vint_um
informs barlCll
Id PI1l jogar com s mo Imlo < 211

Jogo
I lhitOJ
Psrsds I
recebe cartas ou p'ra h..
informs banca
d' para jogar com
a mo Imo < 211
Estouro
Informa banca
Modelando os estados da banca
A Figura 16.4 apresenta o diagrama de eSlado da banca.
A banca lem seis eSlados principais: Dislribuio, Espera, Vinle-e-um, Jogo, Parado e Estouro.
A banca comea no eSlado Distribuio e distribui cartas para cada jogador e para si mesma.
Aps a dislri buio, a banca muda para o estado Vinte-e-um ou Espera, dependendo da mo re-
cebida.
Enquanto est no eslado Espera, a banca espera que todos osjogadores lerminem sua vez. Quan-
do lodos osjogadores tiverem tenninado, a banca mudar para o eSlado Jogoe comear sua vez.
Assim como o jogador, a banca decide se vai receber mais cartas ou parar, no eSlado Jogo. Ao
cOlll rri o dos jogadores, cnlrctanl o, a banca est reslri la a receber mais cartas quando sua mo
for menor que 17 e a parar quando sua mo for maior ou igual a 17.
Assim como o jogador, se a banca receber mais cartas e estourar, ela mudar aulomalicamente
para o eSlado Estouro. Se a banca decidir parar, mudar para o eSlado Parado.
Dignas de nota so as alividades nos eSlados Vinle-e-um, ESlouro e Parado. Enquanlo eSl nes-
ses estados, a banca efelua o jogo e termina de jogar.
o modelo do jogo vinte-e-um atualizado
Quando os estados do jogo eSli verem modelados e completamente entendidos, voc precisar
decidi r como vai encaix-los no projeto. Comece colocando cada estado do jogo em sua prpria
classe. Em seguida, voc precisar descobri r o que gera os eventos.
FIGURA 16.4
Odiagramll
de eslado
da bal/ca.
Iterao 2 do j ogo vinte-e-um: adi cionando regras
Oillribui .....
1 m"" v;nU!-fHIm
1m60- 211
llim_ .....
1M'.
_.
[da p'. jog ... c:om a ...... [m'" < 211
393
.
Eope ..
[nenhum Jogado,

Imao,. 16 < 221
Pa,ado
espe'andol
.....
.flt".l '&cabe
1M'. cada TI' p,,, joga'

mio e'ulII 1110"' 0
[mio,. 21[
[jogadorn "5perand<>1 pa'. Jogar c<>m
"mao [mlo< 111 ESI<>ur<>
af.lua
Esse uso do termoeslado se encaixa na defi nio ori ginal apresenlada anteriormente. Aqui, voc
apenas baseia um objeto em tomo de cada estado que o objeto Pl ayer (Jogador) deve ter em de-
termi nado momento. Isso o li bera de ter mui tas variveis intemasdiferentes. Em vez disso, o ob-
j eto estado encapsul a perfei tamente todos esses di ferent es valores dentro de um objeto, que tem
estado e comportament o.
Voc perceber rapidamente que todos os eventos giram em tomo do estado da mo. Assim,
voc provavelmente deve deixar que o objeto Hand (Mo) gere e envie esses eventos medida
que objetos Card (Cana) sejam adicionados no objeto Hand (Mo). Voc tambm precisar esta-
belecer um mecanismo para que os estados recebam eventos de Hand (Mo).
Os estados em si so muito simples e tm trs responsabi li dades. Os estados so responsveis por:
Executar todas as atividades.
Receber e responder aos eventos.
Saber para qual estado ir. em resposta a um event o ou condio.
A Fi gura 16.5 iluSlra o diagrama de classe St ate.
Voc notar que cada evento tem um mtodo correspondente no State (Estado). O objeto Hand
(Mo) chamar um desses mtodos, dependendo do estado que Hand (Mo) gostaria de reponar.
O objeto State (Estado) tambm acrescenta um mtodo executeO. Esse mtodo chamado
quando State (Estado) deve execut ar suas aes.
A Figura 16.6 modela os relacionamentos entre os objetos Pl ayer (Jogador), Hand (Mo) e State
(Estado).
FIGURA 16.5
O diagrama de c/asse
de State (&Iado).
FIGURA 16.6
O diagrama
de classe da
eSfrllf/lra
State
(&/(Ido) .
Hend
WlHoIdet" \I: H.ndUsl_,1
ed<lCerd te , card}
IIIEQU.I\h : H.ndl : boole.n
\h : : bool .. "
.1OIa1 0: IM
I.BIKkjKk 1): b<IoIe.n
Dia 16
,
,
H.ndUst.n.,
... h. ndPI.yeble O
... handBleckjack O
+ handBusted II
+ handChanged I)
o\>
PI.yritate
+ elCecute Id: Delaer)
H.naUstene,
h.ndPl..,.bl. n
hendBltdtjtclc II
"-ndBUfled li
"-ndCh'''IIed (I
Pl eyerState


Play.,
._.td: OHwl
, ,
,_bed.
,
ImplCl ass
,
o objeto Pl ayer (Jogador) mantm um objcto 5tate (Estado). Quando for a vez do objeto Pl ayer
(Jogador) fazer algo, ele simplesmente executar o mtodo execute () de 5tate (Estado). Ento,
State (Estado) executar todas as atividades, receber de Hand (Mo) e mudar para o prximo State
(Estado), confonne for apropriado. Uma vez feita a transio, o prximo State (Estado) execu-
tar todas as alividades. receber de Hand (Mo) e mudar, conforme for apropriado. Esse padro
se repeli r at que o jogo termine.
A Figura 16.7 il ustra o diagrama de classes completo do jogo de cartas vi nte-e-um.
FIGURA 16.7
O diagramll de
classes completo
de 61 ackjack,
Iterao 2 do j ogo vinte-e-um: adi cionando reg ras
C nn""
395

Embora a adio de urna estrutura 5 ta te (Estado) seja urna alterao i mportante ocorrida duran-
te essa ilerao, outras interraces e classes roram atual izadas para poder supol1ar o relato e a exi-
bio das novas condies do jogo.
Implementao das regras
Para suportaras novos recursos do jogo, so necessrias mudanas nas classes PI ayer (Jogador),
Dealer (Banca), Bl ackjackOealer (Banca 21) e Hand (Mo). Vri as novas classes e interfaces
tambm preci sam ser acrescentadas. As seesa seguir examinarnocada mudana import ante.
Mudanas na Classe Hand
Para suportaras novos recursos dojogo, a classe Hand (Mo) deve relatar seu estado para um re-
ceptor. A Listagem 16.2 apresenta a nova interface HandUs t ener.
Dia 16
LI STAGEM 16.2 HandListener.java
public interface Handl istener I
public void handPlayabl e();
publiC void handBlackjack() ;
public void handBusted();
public void handChanged();
J
A Listagem 16.3 apresenta a classe Hand (Mo) atuali zada.
LI STAGEM 16.3 Hand . java
i mport java.util.Arraylist

i mport java.ut i 1 .lterator;
publ ic cl ass Hand I
private Arraylist cards = new Arraylis t () ;
private stati c f i nal int BlACKJACK = 21;
private Handlistener hol der;
private int number_aces;
public Hand() I
II configura o portador como um receptor em branco para que ele no
seja nulo. caso
) ;
J
II no seja configurado externamente
setHolder(
J
new Handlistener() I
public void handPlayable() II
publi c voi d handBlackjack() II
publi c voi d handBusted() {I
publ ic voi d handChanged() I}
publiC void setHolder( Handlistener holder ) I
thi s .holder holder;
J
publi C Iterator getCardsO I
Iterao 2 do j ogo vinte-e-um: adicionando regras
LISTAGEM 16.3 Hand.java (continuao)
}
return cards.iterator();
}
publlC void addCard( Ca rd card ) {
cards . add( card };
hol der.handChanged();
i f( card. getRank() Rank.ACE ) {
}
if( bustO} (
holder.handBusted() ;
return ;
}
if( blackjac k() ) (
holder . handBlackjack();
return;
}
if ( cards.size() ~ 2 ) (
holder.handPlayable ();
return:
}
pubhc bool ean isEqual ( Hand hand ) I
H(hand.totalO this.totalO) {
return true;
}
return false;
}
publ iC boolean isGreaterThan( Ha nd hand ) {
return thi s . total () > hand. tota 1 () :
}
publ ic boolean bl ackjackO (
if( cards.size() 2 &&total() BLACKJACK ) {
return true;
}
return fa 1 se ;
}
public vo1d reset() I
397
Dia 16
LISTAGEM 16.3 Hand.java (continuao)
J
J
cards. clearO;
number aces - O;
publlC void turnOver() I
J
Itera tor i - cards.iterator() ;
while( i.hasNext() ) I
J
Card card - (Card) i .nextO;
card.setFaceUp( true ,;
public Stri ng toString() (
Iterator i cards .iterator();
String string "";
while( LhasNext() ) (
Card card - (Card) i . next();
string - string + " " + card.toString();
J
return st r ing;
J
publ ic int total () I
int total - O;
J
Iterator i - cards.iterator() ;
while( i.hasNext() ) I
Card card z(Card) i.next();
total +- card.getRank().getRank() ;
J
int temp_aces - number_aces;
while( total> BLACKJACK && temp_aces > O ) I
total - total w 10;
J
return tota 1 ;
private boolean bust() (
if(total() > BLACKJACK ) {
return true;
J
return false ;
J
Iterao 2 do jogo vinte-e-um: adicionando reg ras 399
Agora, as alteraes no mtodo total () de Hand (Mo) tomam possvel que um s tenha o valor
I ou II . Do mesmo modo, as alteraes no mtodo addCard{} permitem agora que Hand (Mo)
informe ao seu receptor das alteraes no seu contedo, quando elas acontecerem.
Final mente, a adio dos mtodos 1 sEqua I {} e lsGrea terThanO possibilita a comparao fci l e
encapsulada de obj etos Hand ( Mo).
Mudanas na Classe PI ayer
A maior al terao na hierarquia PI ayer (Jogador) gira em tomo do acrsci mo de States (Esta-
dos). A Listagem 16.4 apresenta a nova interface PlayerState.
LI STAGEM 16.4 Player State.java
publi c interface PlayerState extends HandListener 1
publi c voi d execute{ Oealer dealer };
}
PlayerState herda de HandUstener e acrescenta um mtodo executeO. Uma implementao
de PlayerState implementar Player State, responder apropri adamente a qualquer um dos
eventos HandUstener e executar suas ati vi dades dent ro de executeO.
o objeto Player (Jogador) mantm uma referencia para seu estado corrente, atravs da varivel
current s t at e. O mtodo playO foi alterado para si mplesmente executar o estado corrente:
publ1c void play{ Oea l er dealer ) 1
current_state.execute{ dealer };
}
Em vez de definir algum comportamento dentro do mtodo playO, o objeto P1ayer (Jogador)
simplesmente de lega para seu estado. Desse modo, voc pode fomecer comportamento novo
si mplesmente trocando objetos de di ferentes estados. A troca por diferentes estados uma solu-
o muito mais elegant e do que a troca atravs de uma li sta de lgica condicional.
As listagens 16.5 a 16.9 apresentam as impl ementaes padro de PI ayer e PI ayerState. Esses
estados implementam diretamente os modelos de estado da seo anterior.
LI STAGEM 16.5 O estado de espera padro
private class Waiting implements Pl ayerState {
publ ic void handChanged{) I
notifyChanged();
}
public voi d handPlayable () I
setCurrentState( ge tPlayingState() };
/1 t ransio
}
Dia 16
LI STAGEM 16.5 O estado de espera padro (continuao)
J
publiC void handBlackjack() {
setCurrentState( getBlackjackState() );
noti fyBlackjack() ;
II
J
pu bl ic void handBustedO 1
II impossvel no es tado de espera
J
public void execute( Oealer dealer ) {
II no faz nada enquanto espera
J
LISTAGEM 16.6 O est ado de estouro padro
private class Busted impl ements PlayerState (
publ ic void handChanged() (
J
II impossvel no estado de estouro
J
public voi d handPlayable() I
II impossivel no es tado de estouro
J
public voi d handBlackjack() 1
II impossivel no es tado de estouro
J
public void handBusted() 1
II impossvel no estado de estouro
J
public void execute( Oealer dealer ) {
dealer.busted( Player . thi s ) ;
I I termi na
J
LI STAGEM 16.7 O estado vinte-e-um padro
private class Blackjack implements Pl ayerState I
publ ic void handChanged{) I
Il impossvel no estado de vinte-e- um
J
public voi d handPlayable{) I
Il impossvel no estado de vinte-e-um
J
Iterao 2 do j ogo vinte-e-um: adicionando regras
LISTAGEM 16.7 O estado vinte-e- um padro (continuao)
J
publiC vold handBlackjack() {
II lmpossfvel no estado de vinte-e- um
J
publlc void handBustedO {
II impossvel no estado de vinte-e- um
J
public void execute( Oealer dealer ) {
dealer.blackjack( Pl ayer.this );
I I tenni na
J
LI STAGEM 16.8 O estado de parada padro
private class Standing implements PlayerState {
publ ic void handChanged() {
J
II impossfvel no estado de parada
J
publ ic void handPlayable () {
II impossfvel no estado de parada
J
public vold handBlackjackO I
II impossfvel no estado de parada
J
public vold handBusted() {
II imposs 1vel no estado de parada
J
publi c void execute( Oealer dealer ) {
dealer.standlng( Player.this ) ;
I I tenni na
J
LISTAGEM 16.9 O estado de jogo padro
private class Playlng implements PlayerState {
publ ic void handChanged() I
notlfyChanged();
J
public void handPlayable( ) I
II pode ignorar no estado de jogo
J
publi c void handBlackjack () I
401
Dia 16
LISTAGEM 16.9 O estado de jogo padro (continuao)
}
II impossfvel no estado de jogo
}
publ ic voi d handBustedO {
setCurrentState( getBus t edState() );
not i fyBus ted () ;
}
public voi d execute( Oealer deal er ) (
1f( hno } (
}
dealer.hit( Player.this ) ;
} el se {
}
setCu rrentS ta te ( getS tandi ngS t a te O );
noti fyS t anding();
current _state.execute( dealer ) ;
II trans io
Todos esses estados so implementados como classes int ernas de Pl ayer (Jogador) pois, basica-
mente, elas so extenses da classe Pl ayer (Jogador). Como classes internas, esses estados tm
tOlal acesso a todos os mtodos e varivei s da classe PI ayer (Jogador). As classes internas per-
mitem que voc encapsule efi cientemente a lgica de estado dentro de sua prpria classe, sem ler
de danificar o encapsul ament o da classe Player (Jogador).
Subclasses podem fornecer sua prpria implementao de estado, sobrepondo os seguintes m-
todos em Pl ayer (Jogador):
protected Pl ayerState getBustedState() (
return new Busted() ;
}
protected PlayerState getStandingStateO (
return new Standing() ;
}
protected PlayerState getPlayingState() (
return new Playing();
}
protected PlayerState getWai t i ngState() (
return new Waiting{);
}
protec ted PlayerState getBl ackj ackState() {
return new Blackj ac k();
}
protected PlayerState get Ini t i alState() I
return new Wa i tingState();
}
Iterao 2 do jogo vinte-e-um: adic ionando reg ras 403
Desde que os estados usem esses mtodos para recuperar os outros estados, as subclasses podem
introduzir seus prprios estados personalizados. getInitialStateO usado pela classe base
Player (Jogador) para configurar o estado inicial de Pl ayer (Jogador). Se uma subclasse come-
ar em outro estado, ela tambm precisar sobrepor esse mtodo.
Final mente, vri os mtodos de noti licao roram adicionados na classe Pl ayer (Jogador). Os es-
tados usam esses mtodos para inrormar o receptor das alteraes. Esses mtodos correspondem
aos novos mtodos encontrados na interrace PlayerListener. Novos mtodos roram adiciona-
dos no receptor para suportar a nova runcionalidade dojogo. A Listagem 16. 10 apresenta a inter-
face Playerlistener atualizada.
LI STAGEM 16.10 Pl ayerListener. java
publ i C interface PlayerListener {
publi c voi d playerChanged( Player player l :
publ ic voi d playerBusted( Player player )i
publiC void playerBlackj ack( Player pl ayer ) :
publ ic void playerStanding( Player player ):
publiC vo1d playerWon( Player pl ayer );
public void playerLost ( Player player ):
publiC void playerStandoff( Player pl ayer );
J
Como Console um Playerlistener, os mtodos a seguir roram acrescentados em Console:
publi c void playerChanged( Player player ) {
pri ntMessage( player.toSt ring() ):
J
public void playerSusted( Player player ) (
printMessage( player.toStringO + " SUS TED!!" ) :
J
public void playerSlackjack ( Player player ) {
print Message( playe r. toStringO + " SLACKJACK! ! " );
J
Dia 16
public yoid playerStanding( Player player ) (
printMessage( player.toString() + STANDING }i
I
publiC yoid playerWon( Player player ) (
printMessage( player.toStringO + WINNER!!" );
I
public void playerLost( Player player ) (
printMessage( player.toString() + LOSER!! " }i
I
publiC void playerStandoff( Pl ayer player ) {
printMessage( player.toStringO + " STANDOFF " )i
I
Essas alt eraes permitem que Console apresente todos os pri nci pais event os do jogo.
Alguns mtodos novos tambm foram acrescentados em PI ayer (Jogador):
publ i c Yoid winO (
notifyWi nO;
I
publiC yoid lose() I
noti fyLoseO i
I
publiC void standoffO {
notifyStandoff();
I
publi c void blackjack() I
notifyBlackjack() i
I
Esses mtodos permitem que Oeal er(Banca) informe a PI ayer(Jogador) se ganhou, perdeu, em-
patou ou ti nha vinte-e-um.
Mudanas em Dealer e BlackjackDealer
Dealer (Banca) e Bl ackjackOea I er (Banca 21) precisam ser atualizados para se encaixar na nova
estrutura de estado. A Listagem 16. 11 apresenta a interface Dea 1 er (Banca) atua li zada.
LI STAGEM 16.11 Oeal er . java
publ i c interface Oealer I
II usado pelo jogador para interagir com a banca
Iterao 2 do jogo vinte-e-um: adicionando regras
LI STAGEM 16.11 Deal er.java (cont inuao)
}
publiC void hit( Player player };
II usado pelo jogador para se comunicar com a banca
public void blackjack( Player playe r };
public void busted( Player pl ayer };
public void standing( Player player };
405
Pl ayer (Jogador) usa esses novos mtodos para relatar o estado para Deal er (Banca). Assim, por
exemplo, quando Pl ayer (Jogador) tiver vinte-e um, chamar o mtodo bl ackjack () de Dea ler
(Banca). Ento, oeal er (Banca) pode passar a vez para o prximo jogador. Esses mtodos so
parecidos com o mtodo passTurnO anterior. Eles apenas so mai s especficos.
Dea 1 er (Banca) usa chamadas para esses mtodos, para filtrar os objetos Pl ayer (Jogador) em re-
cipientes, baseado em seu estado. Isso torna o cumprimento dojogo muito mai s fcil para Dealer
(Banca).
Por exemplo, aqui est uma implementao de busted() de Bl ackjackDeal er:
public void busted( Player pl ayer ) (
busted pl ayers.add( player ) ;
play( t his );
}
Os out ros mtodos funcionam de manei ra semelhante.
BlackjackDeal er (Banca 21) adi ciona um estado oealerDeal ing. Ela tambm personali za mui
tos dos estados padro de Pl ayer (Jogador). As li stagens 16. 12 a 16. 16 apresentam esses estados
modificados.
LI STAGEM 16.12 O estado de estoura da banca personal izado
private cl ass oealerBusted implement s PlayerState {
pu bl ic void handCha nged() {
II i mpossfvel no estado de estouro
}
publ ic voi d handPlayable() {
I I imposslvel no estado de estouro
}
publ ic voi d handBlackjack() {
II imposslvel no es t ado de estouro
}
publ ic voi d handBustedO {
II imposslvel no es t ado de estouro
}
Dia 16
LISTAGEM 16.12 O estado de estoura da banca personalizado (continuao)
J
publ iC void execute{ Dealer dea ler ) I
Iterator 1 standing_players.iterator {):
while{ i. hasNext() ) I
J
J
Player player = (Pl ayer) i .next();
player .winO:
i blackjack_pl ayers. iterator() ;
while( 1. hasNext() ) I
J
Player player (Player) i .next() :
player.win():
i busted_players.iterator():
while( i.hasNext() ) I
J
Player player lO (Player) i . next() ;
player. l oseO ;
LISTAGEM 16.13 O estado de banca com vinte-e- um personal izado
pr ivate class OealerBlackjack implements PlayerState {
public void handChanged() {
noti fyChangedO:
J
public void handPlayable(} {
II impossvel no estado de vinte-e-um
J
publi c void handBlackjack() {
II impossvel no estado de vinte-e-um
J
public void handBusted () (
II impossvel no estado de vinte-e-um
J
publ iC void execute( Dealer dealer ) I
exposeHand ();
Iterator i players.iterator () :
whl1e( i .hasNext() ) (
Pl ayer pl ayer K (Player)i.next() :
if( player.getHand () . blackjack() } I
player.standoff() :
I else {
player.lose() ;
J
Iterao 2 do j ogo vinte-e-um: adicionando regras 407
LI STAGEM 16.13 O estado de banca com vinte-e- um personalizado (continuao)
}
}
}
LISTAGEM 16.14 O estado de banca parada personalizado
pri vate class OealerStanding implements PlayerState (
publi c v01d handChanged() {
}
II impossfvel no estado de parada
}
public void handPlayable() {
II impossfvel no estado de parada
}
publ ic voi d handBlackjack() {
II impossfvel no estado de parada
}
publ ic voi d handBustedO {
II impossfvel no estado de parada
}
public void execute( Oealer deal er ) I
Iterator i standing_pl ayers.iterator ();
while( i.hasNext() ) I
}
}
Player player = (Pl ayer) i .next();
H( pl ayer.getHand(). isEqual( getHandO ) ) I
player . standoff() ;
I else if( player.getHand() . isGreaterThan( getHand() ) ) {
player.winO;
I e I se {
player.loseO ;
}
i blackjack_players . iterator{) ;
while( i .hasNext() ) {
Player player = (Player) i . next () ;
player.win() ;
}
i = busted_pl aye rs.iterator() ;
while( i.hasNext() ) I
}
Pl ayer pl ayer (Pl ayer) LnextO;
p1ayer.loseO;
Dia 16
LISTAGEM 16.15 O estado da banca esperando personal izado
pr ivate class OealerWai t i ng i mpl ements PlayerState {
public void handChanged() I
}
II i mposs fve l no estado de espera
}
publi C void handPlayable( ) I
II imposs1vel no estado de espera
}
publ ic vo1d handBlackjack() {
II imposs fvel no es tado de espera
}
publi C voi d handBusted() {
II impossfvel no estado de espera
}
publi c voi d execute( Dealer dealer ) {
}
;t( !wa1ting_players . i sEmpty() ) {
Player pl ayer (Player) waiting players.get( O )i
wa i ting_players. remove( player );
player. play( dealer )i
) el se {
}
setCurrentState( getPlayingState () ) ;
exposeHand()i
getCurrentState().execute( dealer );
II faz a transio e executa
LI STAGEM 16.16 O estado da banca distribuindo personal izado
private class DealerDealing implements PlayerState {
pu blic void handChanged() (
notifyChanged();
}
publi C voi d handPl ayabl e() (
set Current State( getWaitingState() );
II transi lio
}
publ iC void handBl ackjack() {
setCurrentState( getBlackjackState() li
noti fyBl ackjack (l;
II transi o
}
public void handBusted() {
II imposs i vel no estado de di stribuiao
Iterao 2 do jogo vinte-e-um: adicionando regras
LI STAGEM 16.16 O estado da banca distribuindo personalizado (continuao)
}
}
public void execute( Oealer dea ler ) {
deal();
}
getCurrentState().execute( dealer ) ;
II faz a transiao e executa
409
Voc pode notar que Bl ackjackOeal er (Banca 21 ) no define seu prprio estado dej ogo. Em vez
disso, ele lisa o estado de jogo padro de PI ayer (Jogador); entretamo, para usar seus estados per-
sanai izados, BI ackj ac kOea I er (Banca 2 I ) precisa sobrepor os receptores de estado encontrados
na classe base PI ayer (Jogador):
protected PlayerStale getBlackjackState() {
return new OealerBlackjack() ;
}
protected PlayerState getBustedState() (
return new OealerBusted();
}
protected PlayerState getStandingState() {
return new OealerStanding();
}
protected PlayerState getWaitingState() I
return new OealerWaiting();
}
Teste
Assim como no cdigo do Captulo 15, "Aprendendo a combinar teoria e processo", uma bateria
completa de testes est disponvel para download no endereo www.samspublishing.com. junto
com o cdigo-fonte deste captul o. Esses lestes consistem em um conjunto de lestes de unidade e
objetos falsifi cados, que testam completamente o sistema do jogo vinte-e-um.
O teste ullla parte i mportante do processo de desenvolvimento; entretanto, o estudo do cdigo
de teste deixado como exerccio para o leitor.
Resumo
Hoje, voc conclui u a segunda iterao do jogo vinte-c-um. Fazendo esse exerccio, voc viu
pela primeira vez como poderia usara processo iterat ivo para conseguir paulatinament e uma so-
luo completa.
Dia 16
Cada iterao anterior atua como base ou fundamento para a segui nte. Em vez de comear uma
nova anli se ou projeto, hoje voc comeou construindo os casos de uso e projeto descobertos
ontem.
Amanh, voc complementar melhor essa base, quando adicionar recursos de aposta no progra-
ma do jogo vinte-e-um.
Perguntas e respostas
I) Se os estados so to importantes, por que voc quis esperar at essa iterao para
inclu-los?
R A iterao inicial era simples. A iterao inicial usava um jogo vinte-e-um bsico que
no detectava mos de vinte-e-um natural, ganhadores ou perdedores (embora detectasse
estouros). No havia motivos para atacar o probl ema com uma soluo complexa. Os re-
qui sitos dessa iterao justi ficam uma soluo mais com plicada, pois ela acrescenta de-
teco de vinte-e-um, assim como cumprimento do jogo.
P Voe poderill ter implementado os estados fora de Pl ayer (Jogador) e 81 ackjackDea-
1 er (Banca 21) ou eles devem ser classes internas?
R Voc pode implementar os estados fora da classe. Mas se voc os definir fora de Pl ayer
(Jogador), talvez precise adicionar alguns mtodos novos para que os estados possam re-
cuperar todos os dados de que precisam.
Gostaramos de desaconselhar tal estratgia, por trs mot ivos:
Primeiro, mover a definio de estado para rara da classe no resolve muito. Na verdade,
isso causa trabalho extra, devido aos mtodos que voc precisar adicionar.
Segundo, a adio de mtodos extras para que os estados possam recuperar dados estraga
o encapsulament o.
Finalmente, mover os estados para fora da classe Pl ayer (J ogador) no modela o relacio-
namento estado/jogador muito bem. Basicamente, os estados so lima extenso de Pl a-
yer (Jogador). Desse modo, os estados aluam como os crebros de Pl ayer (Jogador).
melhor que os crebros fiquem dentro do corpo.
,
E importante nOlar que a implementao de estados como classes internas funci ona per-
feitamente na linguagem Java. Oulras linguagens podem exigi r uma estratgia li geira-
mente diferente.
Workshop
As perguntas e respostas do teste so fornecidas para seu melhor entendimento. Veja as respos-
tas no Apndice A, ' Respostas".
Iterao 2 do j ogo vinte-e-um: adicionando regras 411
Teste
I. Quando as condicionais so perigosas?
2. Liste duas maneiras de remover condicionais.
3. A verso de Hand (Mo) apresenlada hoje melhor encapsulada do que a de ont em.
Como a nova verso de Hand (Mo) se encapsula?
4. Que padro Hand (Mo) e HandListener implementam?
5. Procure na Web mais informaes sobre o padro State.
Exerccios
I. Faa download do cdigo-font e da iterao de hoje. Quando voc tiver o cdigo, compi-
le-o, faa-o funcionar executando o jogo vinte-e-um e, depois, tente entender como ele
funciona. Ter um entendimento total do cdigo exigir algum tempo e pacincia.
2. O cdigo a seguir aparece na definio da classe PI ayer (J ogador):
protected yoid notlfyChanged() (
}
Iterator i listeners .iterator();
while( i .hasNext() ) (
}
PlayerListener pi (PlayerListener) i . next();
pl.playerChanged( this ) ;
protected yoid notify8usted () (
Iterator i listeners. iterator();
while( i.hasNext() ) (
}
}
PlayerListener pl a (PlayerListener) i.next();
pl . player8usted( this ) ;
protected yoi d notify8lackjack() (
Iterator f 11steners.iterator();
wh i le{ i.hasNext() ) (
}
}
Playerlistener pi = (PlayerLi stener) i . next() ;
pl . player81ackjack( this );
protected yoid notifyStanding() (
Iterator i = listeners. iterator();
while( i.hasNext() ) {
}
}
Dia 16
Playerlistener pl (Playerlistener) i.next();
pl.playerStanding( this );
protected yoid notifyStandoff() {
Iterator i listeners.iterator{);
while( i.hasNext() ) {
}
}
Playerlistener pl z (Playerlistener) i.next();
pl. playerStandoff{ this );
protected void notifyWinO {
}
l terator i 1 isteners . iterator{) ;
whi l e( i.hasNext{) ) {
}
PlayerUstener pl (Playerlistener) i.next();
pl.playerWon( thi s );
protected void notifyloseO {
}
Iterator i = l i steners. ite ratorO;
while( i . hasNext() ) {
}
Playerlistener pl ( Pl ayerlistener) i.next();
pl.playerlost{ this );
Os mtodos funcionam. Funcionalmente, no h nada de errado com eles; entretanto, cada mtodo
executa exalamente a mesma ao, at o ponto em que uma chamada feita em Pl ayerli stener.
Como voc poderia usar objetos de modo que precisasse escrever apenas um mtodo de notifica-
o? Projete e implemente uma soluo.
SEMANA 3
DIA
Iterao 3 do jogo vinte-e-um:
adicionando aposta
No captulo de OIlIem, voc viu como pegar lima implementao bastante primit iva do jogo vin-
tc-c-um e fazer sua iterao para obter umjogo mais amadurecido. Hoj e, voc vai complementar
o mesmo j ogo vinte-c-um, adicionando suporte para aposta simpl es.
A lio de hoje dar a voc mai s experincia com o processo iterativo, assim como com ADO e
POO ( Projeto Orientado a Objeto). No final da lio de hoje, voc tambm dever comear a se
senti r mai s vontade com a arquit clura baseada em estado apresentada ontem. Na verdade, um
dos exerccios de hoje pedir para que voc adicione um novo estado no sistema.
Hoj e voc aprender:


Como estender a arquitetura de estado do jogo vinte-c-um para adicionar func ional idade
Sobre as vantagens que lima verdadei ra estratgia 00 pode trazer para um sistema, traba-
lhando em um sistema baseado em 00
Aposta no jogo vinte-e-um
A iterao de ont em produziu um jogo vinte-e-um bastante completo. Quase todos os recursos
no relacionados com aposta agora fazem parte do j ogo. Hoje, voc vai acrescent ar alguns dos
recursos de aposta ausentes.
Dia 17
Assi m como nas outras lies desta semana, segui remos o processo del ineado no Capitulo 9,
" Introduo AOO (Anlise Orientada a Objetos)". Vamos comear explorando os casos de
uso de aposta.
Anlise da aposta
Para ent ender completamente a aposta, voc precisar finalizar os casos de uso Fazer apostas e
Dabrar, identi fi cados durante a anl ise inicial do j ogo vinte-c-um. Voc tambm precisar rever
os outros casos de uso para ter certeza de que eles no precisam de atual iz.."to. Uma vez que ti -
ver terminado os casos de uso, voc precisar atuali zar o modelo de domnio.
Anlise do caso de uso de aposta no jogo vinte-eum
Vamos comear com o novo caso de uso Jogador faz aposta:
Os jogadores comeam o jogo com U$$ 1000 no pote. Ant es que quaisquer cart as sej am distribu-
das, cada jogador deve fazer uma aposta. Comeando com o primei ro jogador, cada um aposta
um valor de USS IO, US$50 ou U$$ IOO.
Jogador faz aposta
I. Jogador faz uma aposta de US$ IO, US$SO ou US$IOO.
2. J)assa para o prximo jogador e repete at que todos os j ogadores tenham feito lima
aposta.
Condies prvias
Novo jogo.
Condies posteri ores
Jogador fez aposta.
O jogo villle-e-um real, como todo j ogo, tem suas prprias regras sobre aposta. Essas regras
incl ui ro uma aposta mini ma, uma aposta mxi ma e o incremento da aposta. Neste jogo vinte-e-um,
um j ogador pode apostar U$$ l 0, US$SO ou U$$ I 00. Por simpl icidade, este jogo oferecer ao
jogador uma linha de crdi to ili mitada. Cada j ogador comear com US$ I 000. Quando o joga-
dor esvaziar seu pote, seu saldo se tornar negativo; entretanto, o jogador pode j ogar, desde que
queira.
O outro novo caso de uso de aposta Jogador dobra:
O jogador decide que no est satisfei to com sua mo inicial. Em vez de simplesmente receber
mais cartas, o j ogador decide dobrar. Isso duplica a aposta do jogador e acrescenta uma carta na
mo. A vez do jogador termina e o jogo passa para o jogador/banca seguinte.
Jogador dobra
I. O jogador decide que no est satisfeito com sua mo inicial.
Iterao 3 do jogo vinte-e-um: adicionando aposta 415
2. O jogador quer dobrar.
3. A aposta do jogador duplicada.
4. A banca acrescenta outra carla em sua mo.
o Condies prvias
o Essa a mo inicial do jogador e ainda no recebeu mais carias nem parou.
o O j ogador no tem vinte-c-um.
o A banca no tem vinte-e-um.
o Condies posteriores
o A mo do jogador tem trs carias.
o A vez do jogador termina.
o Alternativa: Jogador estoura
A nova carta faz a mo do jogador estourar (perde).
o Alternativa: a mo do jogador maior que 21, mas o jogador tem um s.
A nova carta faz a mo do jogador ser maior que 21. O jogador tem um s. O valor do s muda de
II para I, fazendo com que a mo do j ogador seja menor ou igual a 21.
Os nicos casos de uso previamente existentes, afetados pela adio da aposta, so o caso de uso
Distribuir carias e o caso de uso Banca ejeluajogo. Os outros casos de uso permanecem inal te-
rados:
Comeando com o primeiro jogador, a banca distri bui uma cana abena para cada jogador,
terminando consigo mesma. Ento, a banca repete esse processo, mas distribui sua prpria
carta fechada. A distribuio termina e o jogo comea quando a banca tiver dist ri budo para
cada jogador, incluindo ela mesma, duas cartas.
o Distribuir cartas
I. A banca distribui uma carta aberta para cada jogador, incluindo ela mesma.
2. A banca distribui uma segunda carta aberta para todos os jogadores, menos para ela.
3. A banca distribui uma carta fechada para si mesma.
o Condies prvias
o Todos os jogadores fizeram suas apostas.
o Condies posteriores
o Todos os jogadores e a banca tm uma mo com duas cartas.
o Alternativa: a banca tem vinte-c-um
Se a banca ti ver um 21 natural. o j ogo passa para o cumpri mento. Os jogadores no tero
sua vez.
Dia 17
Agora, a distribuio no comear at que cada j ogador tenha feito uma aposta. Vamos ver
como a aposta muda o cumpri mento do jogo:
Aps todo ojogo ser fei to, a banca veri fica cada mo e detennina, para cada jogador, se ele ga
nhou ou perdeu, ou se o j ogo deu empate.
A banca efelua o jogo
I. A banca verifica a mo do primeiro jogador e a compara com a sua prpri a.
2. A mo do jogador maior que a da banca, mas no estourou; o jogador ganha.
3. O valor da aposta adi cionado ao pote do jogador.
4. A banca repete essa comparao para todos os jogadores.
Condies prvias
Cada jogador teve sua vez.
A banca teve sua vez.
Condi es posteriores
Resultado fi nal do jogador foi detenn inado.
Alternativa: o jogador perde
A banca veri fi ca a mo do jogador e a compara com a sua prpri a. A mo do j ogador
menor que a da banca. O jogador perde. A aposta retirada do pote do jogador.
Alternati va: empate
A banca veri fi ca a mo do j ogador e a compara com a sua prpria. A mo do j ogador
igual da banca. O j ogo deu empate. Nada acrescentado ou subtrado do pote do joga
dor.
Alternativa: a banca estoura
Se a banca estourou, todo j ogador que esti ver parado e com vinte e-um ganha. Todos os
outros perdem. Os ganhadores recebem o valor apostado.
Alternativa: os jogadores ganham com vinte-eum
Se o jogador tiver vinte-e um e a banca no, o jogador ganha r e receber na proporo de
3:2 (por exemplo, se o jogador apostasse US$ IOO, receberi a US$ I 50).
J sso conclui as al teraes nos casos de uso. Todos esses casos de uso so relativamente si mples.
Os di agramas de interao provavel mente seriam complicados. Vamos ver como esses casos de
uso atualizados mudaram o modelo de dom nio.
Atualizando O modelo de domnio do jogo vinte-e-um
A anlise da aposta exige que voc atualize o modelo de domni o, mas apenas ligeiramente.
Voc precisar adicionar mais um objelo de domni o: Bank ( Banco). Todo objeto Player (Joga-
dor) no jogo tem seu prprio objeto Bank (Banco) pessoal. A Figura 17. 1 ilustra o modelo de do--
mnio atuali zado.
Iterao 3 do jogo vinte-e-um: adicionando aposta
FIGURA 17.1
O II/Ol/elo de domnio
do jogo l ilfle-e-/lIII.
Projeto da aposta
,
J"" '
,
1 ... 7
,
M'o
Carta
417
Voc deve comeara projeto projetando a nova classe Bank (Banco). Quando Bank (Banco) esti-
ver pronta, voc precisar descobri r como apostar no jogo. Para os propsitos da I io de hoje, o
caso de uso Jogador dobra deixado como exerccio no final da li o.
Projetando a classe 8ank
Ao comear a projetar Bank (Banco),voc deve primeiro identificar suas responsabi lidades. A
Figura 17.2 ilustra o carto CRC resultante para a classe Bank (Banco).
A boa 00 exige a diviso correta das responsabilidades. Desse modo, Bank (Banco) respons-
vel por controlar Iodas as atividades de aposta. Bank (Banco) mantm lodos os detalhes da aposta
internamcnte e d acesso aposta e ao saldo atravs de uma interface bem defi nida. A Fi gura
17.3 ilustra O diagrama da classe Bank (Banco), assim como o relacionamento de Ba nk (Banco)
com PI ayer (Jogador).
o projeto da aposta
Como se v, a aposta deve se encaixar bem na arquitetura de estado que vi mos ont em. O jogador
e a banca precisaro de mais um estado para suportar aposta bsica. A banca precisar de um es-
tado Co 11 cct i ngBcts (Coletar Apostas) e o jogador precisar de um estado Aposta. As figuras 17.4
e 17.5 ilustram os novos diagramas de estado para a banca e para o jogador, respectivamente.
FIGURA 17.2
O ca,.to CRC de Bank
(Banco).
FIGURA 17.3
O diagrama da classe Bank
(Bal/co).
FIGURA 17.4
O diagrama de
estado de Oea 1 er
(Bal1ca).
Dia 17
Banco
~ ~
mio' I
la mio ' boII pa,a iOlla, Imlo < 21J
Banco
.. pl_, OOBetU:
.. pl_SOS.' (I:
.. pl_l08e10:
.. winO:
.. lose(l:
bh,,:kj.ck(l;
.. mndoffll;
(mio> 11 < 221
ijogldo<H esperandoJ
I mio' """ pao-I joglf
Imlo < 111
mio estouro ...
FIGURA 17.5
O diagrama
de estado
de P/(lj'e,.s
(Jogado,.es).
Iterao 3 do jogo vi nte-e-um: adicionando apost a
Apo
aposta
IJogo I.ito)
Esper.
mio' vint. ... um (mo __ 2 I I
Vint.-eum
I! mo boI! parI! jogar (mio .. 21)
jogo
a mio booI ""rI Joglr
[mio ... 211
Jlhi@
I mio estourou
[mio:>2 11
Estoulo
41 9
Confonne voc pode ver, agora o jogador comea no estado Aposta, enquanto a banca comea
no estado Co 11 ec t i ngBets (Coletar Apostas). Quando todas as apostas forem colctadas, a banca
passar para o estado Distribuio. como antes. Quando termi narem as apostas, os jogadores
passaro para o estado Espera.
Refazendo a hierarquia de Player (Jogador)
Neste ponto do projeto, parece que PI ayer (Jogador) e Bl ackjackDea I er (Banca 21) esto diver-
gindo. Embora BlackjackDealer (Banca 21) estenda Player (Jogador), ela no precisa de Bank
(Banco). Isso diferente de HumanPI ayer (Jogador Humano), pois a banca no aposta. Se voc
adicionar suporte para aposta diretamente em Player (Jogador), BlackjackOealer (Banca 21)
herdar lodos os tipos de comportamento int il , que precisar sobrepor (alm de Pl ayer (Joga-
dor) ficar demasiadamente congestionado).
Este um bom momento para refazer a hierarquia de herana PI ayer (Jogador), dividindo os ele-
mentos comuns em subclasses. Na nova hierarquia, nenhum suporte para apostas deve ser adicio-
nado na classe base PI ayer (Jogador). Em vez disso, uma nova classe, Bet t; ngPI ayer, deve herdar
de Pl ayer (Jogador) e, ento, adicionar os estados e mtodos necessrios para o suporte de apostas.
Dia 17
B1ackj ackOealer (Banca 21) pode continuar a herdar de Pl ayer (Jogador); entretanto, Hl.manPlayer
(Jogador Humano) deve agora herdar de Sett i ngP1 ayer. A Figura 17.6 il ustra a hierarquia resultante.
FI GURA 17.6
II hierarquia de
Player ljogadOl).
PllJyer
oodCa,d le ; canil
play (d ; De".,)
,ddlistanar (I; Playerlistane.)
win (J
. 1058 O
+ SIDndoff O
+ blaekjaek O
Dealer
# gel/nlllll lS/lla (J : P I ~ S l l I l e
I hil (I ; boa/fllln
+ hlt (P: PI, ver) ~
+ blaekjeek (p : Plavar)
+ buSled (p ; Plavar)
+ standing (p: Player)
+ doneSaning (p: Piava. )
~
BetfingPllJyer
BlackjackDealer
.. win O
lou ti
, hil O : boolean
+ l tandOtf II
, gM!nilialStata n : PI,y&rStata blacljack CI
-.tdf'I ..... r Ip : Pla ..... 1 , getlnill.tSl"e II: PI ..... rState
newGame O ,li fi
HumanPlayer
... hil () : boolean
... bel ((
o modelo do jogo vintee-um atualizado
Agora que voc terminou o projeto, uma boa idia atuali zar o di agrama da classe B1 ackjack. A
Figura 17.7 ilustra o diagrama da classe.
Agora, voc est pront o para passar para a implementao.
Implementao da aposta
A implement ao da aposta exigir a criao das classes Bank e BettingPlayer, assim como alte-
raes em BlackjackOealer, Oea1er e HumanPlayer. Vamos comear com a classe Bank.
It erao 3 do jogo vinte-e-um: adicio na ndo apost a 421
A implementao de Bank
Confonne voc descobriu, Bank (Banco) responsvel por conler um 10lal, assim como por ge-
rendar as apostas. A Listagem 17. 1 apresenta uma passivei implementao de Bank (Banco).
FIGURA 17.7
O diagrllllla
da classe
Blackj ack.

c .. ,
LISTAGEM 17.1 Bank.java
publ ic class Bank (
private int total;
private int bet;
di.uiblll de
,
publ ic Bank( int amount ) I
tota I amount;
}
public void placelOOBet() {
placeBet( 100 ,;
}
-
,
1 ... 7
re<:,be d' __
,
,
81nk
,
,
Dia 17
LI STAGEM 17.1 Bank.java (continuao)
J
publiC void placeSOBet() {
placeBet( 50 li
J
publi c void placelOBetO {
placeBet( 10 )i
J
public void winO {
J
total +- ( 2 * bet ) i
bet = Oi
publi c voi d lose() (
J
II j extrafdo do total
bet .. Oi
publ ic void blackjack() {
tota 1 +'" ( ( ( 3 * bet ) I 2 ) + bet ) i
bet .. Oi
J
publiC void standoff() {
t otal + .. beti
bet .. O i
J
public String toString() {
return ( "$" + total + ".00" ) i
J
private void placeBet( int amount ) {
bet .. amounti
total . = amounti
J
Quando o jogador prcdsa fazer uma aposta, ele faz isso atravs da interface Bank. Digno de nota
o modo como Bank oculta completament e os detalhes da aposta. Quando o jogador ganha, per-
de, atinge vinte-c-um ou empata, ele si mplesmente informa a Bank. Bank faz o resto.
Iterao 3 do jogo vinte-e-um: adicionando aposta 423
A implementao de BettingPlayer
Bet t i ngPl ayer preci sa herdar de PI ayer, defi nir um estado Apost (Bett ing), garant ir que seu es-
tado inicial seja configurado como o estado Aposta e adicionar suporte para Bank (assim como
atualiz- Io corretament e). A Listagem 17.2 apresenta a nova classe BettingPlayer.
LISTAGEM 17.2 BettingPlayer.java
public abstract class BettingPlayer extends Player {
private Bank banki
public BettingPlayer( String name, Hand hand, Bank bank ) {
supere name, hand )i
this.bank banki
I
// **.* ** *** *.**.* ** *
// comportamento sobreposto
publi c String toString() {
return ( getNameO + M : M + getHandO.toStringO + -\n" +
bank . toString() )i
I
public void win() {
bank .winOi
super.winO i
I
public void lose() I
bank.loseO;
super.lose() j
I
publi c yoid standoffO {
bank.standoff()i
super.standoff()i
I
publ ic yoid blackjack() I
bank.blackjack()i
super.blackjack();
I
protected PlayerState getlnitial State() {
return getBettingState()i
I
Dia 17
LI STAGEM 17.2 BettingPlayer.java (continuao)
J
11**************************************************************************
II adicionado recentemente para BettingPlayer
protected final Bank getBank() (
return bank;
J
protected PlayerState getBettingState() {
return new Betting()j
J
protected abstract void bet() j
private class Betting implement s PlayerSt ate (
public voi d handChanged() (
J
II 1mpossfvel no es t ado de estouro
J
publ ic void handPlayable() (
II impossvel no estado de estouro
J
public vo id handBlackjack() (
II impossvel no estado de estouro
J
public void handBusted() (
II impossvel no estado de es t ouro
J
public voi d execute( Dealer deal er ) {
bel ();
J
setCurrentState( getWaitingState() )j
dealer.doneBett1ng( BettingPlayer.thi s ) j
I I termi na
Voc tambm notar que Betti ngPl ayer acrescenta um novo mtodo abst rato: protected abs-
tract voi d bet (). O mtodo bet () chamado dentro da ativi dadc do estado Betti ng (Aposta).
Cada subclasse deve sobrepor esse mtodo, como achar melhor.
Mudanas em Oealer e HumanPlayer
A parti r do exame do cdigo de BettingPlayer,voc provavel mente notou que um novo mtodo
foi adicionado em Oea l er: public voi d doneBet t i ng( Pl ayer p ).
It erao 3 do jogo vinte-e-um: adici o nando aposta 425
BettingPlayer chama esse mtodo para informar a Dea l er que ele terminou a aposta. Desse
modo, o objeto Dea l er pode saber que o jogador tenninoll e que o prxi mo jogador pode come-
ar a apostar.
As alteraes em HumanPI ayer so muito sem graa. A Listagem 17.3 lista a nova classe HumanP-
I ayer.
LISTAGEM 17.3 HumanPl ayer.java
public class HumanPlayer extends 8ettingPlayer {
private f i na I static String HIT

"H'"

private final statlc St r ing STAND

"S";
private fina I s tatl c St ring PLAY MSG

.. [H] it or [S] tay";
private fina I static St ring BET MSG
-

"Place BeqlO] [50]
private fina I stat i c String 8ET 10

"10";
-
private fi na I statlc String BEl 50

"50";
private final static String BET 100

"100'"

private f i nal static String DEFAUL T

"inval id'"

publ ic HumanPlayer( String name , Hand hand. Bank bank } {
supere name, hand. bank );
}
protected boolean hit() {
while( true ) {
Co nsole . INSTANCE.printMessage( PLAY_MSG };
or [100]";
String response s Console.INSTANCE . readInput( DEFAULT );
lf(response.equals l gnoreCase( HIT ) ) {
}
}
return true ;
J else if( response . equalsIgnoreCase( STAND ) ) {
return fal se ;
}
II se chegarmos at aqul , faz um lao at obtermos entrada
II s i gnifi cativa
protected void bet() (
while( true ) I
Console.INSTANCE.printMessage( BET MSG );
St ring response Consol e.INSTANCE . readInput( OEFAULT ) ;
if( response.equal s( BET_10 ) } {
}
getBank(} . placel0Bet() ;
return;
Dia 17
LI STAGEM 17.3 HumanP1ayer.java (continuao)
J
J
J
J
if( response.equal s ( BET_50 ) ) (
getBank(}.place50Bet();
return ;
if( response.equal s ( BET_IOO } ) {
get Bank(}. placeIOOBe t(};
return;
J
/1 se chegarmos at aqui, faz um lao at obtermos entrada
/1 significativa
Agora, HumanPlayer herda de BettingPlayer, em vez de diretamente de Player. HumanPl ayer
tambm fornece uma implementao de bet (). Quando bet() chamado, ele consul ta a linha de
comando para ver retorno do usurio.
Mudanas em 81ackjackDealer
Bl ackjackOeal er (Banca 21) implementa o novo mtodo doneBett i ng D, definido em Dealer.
Quando esse mtodo chamado, Blackj ackDea ler pega o jogador e o insere em um recipiente de
j ogadores esperando.
B I ackjac kDea 1 er tambm define um novo estado: Dea 1 erCo I I ec t i ngBets. A lm disso, Dea I er-
Co 11 ect ; ngBet s atua como o novo estado ini cial de Bl ackj ackDea I er. A Listagem 17.4 apresen-
ta o novo estado.
LISTAGEM 17.4 O novo estado de DealerCollectingBets
pr;vate cl ass OealerCollectingBets implements PlayerState \
publi c voi d handChanged() i
II i mposs fve l no estado de aposta
J
publ ic void handPlayable () (
II impossfvel no estado de aposta
J
publ ic void handBlackjack () t
/1 impossfve l no estado de aposta
J
public void handBustedO {
II i mposs fve l no es tado de apost a
Iterao 3 do jogo vinte-e-um: adicionando apost a
LI STAGEM 17.4 O novo estado de OealerCollectingBets} (continuao)
J
publiC vold execute{ Dealer dea l er } I
J
if( !betting_pl ayers.isEmpty() ) {
Player player (Pl ayer) betting players.get( O } );
betting pl ayers .rernove( pl ayer )j
player . play( dealer };
I else I
J
setCurrentState( getDealingState() ) j
getCurrentState().execute( dealer ) ;
II faz a trans io e executa
427
o novo estado chega ao fi m e diz a cada jogador para que aposte. Digno de nota que esse estado
no faz lao. Em vez di sso, a atividade executada sempre que um jogador indica que acabou de
apostar. Esse comportamento est defi nido dentro do mtodo doneBettingO:
public void doneBetting( Player player ) {
J
waiting_playe rs.add( player );
play( thls ) j
Lembre-se de que uma chamada a play() executa o estado correntc.
Miscelnea de mudanas
A nica outra alterao digna de nota o falo de que o mtodo getInitialStateO de Player
agora declarado como abstraIo na classe base PI ayer. Tornar o mtodo abstrato funciona como
uma forma de documentao que pennite a qualquer um, que faa subclasses da classe, saber
que deve fornecer sua prpria definio de estado inicial.
A prtica de tornar um mtodo abstrato para que ele funcione como uma forma de document ao
uma maneira eficiente de estabelecer um protocolo de herana.
Um pequeno teste: um objeto falsificado
Como sempre, casos de teste esto disponiveis junto com o cdigo-fonte; entretanto, interes-
sante dar uma olhada em um uso inteligente de objetos fal sificados. A Li stagem 17.5 apresenta
um objeto falsi fi cado Deckpile que garante que a banca recebe um vinte-e-um.
LI STAGEM 17.5 Oeal erBlackjackPi le.java
publ i C class DealerBl ackjackPile extends Deckpile I
pr; vate Card [] cards j
Dia 17
LISTAGEM 17.5 OealerBlackjackPi le.java (continuao)
I
private lnt index -I:
public OealerBlackjackPi l e() {
cards " new Ca rd (4];
cards (OJ new Ca rd ( Suit. HEARTS , Rank.TWO ) ;
cards ( lJ new Card( Suit. HEARTS, Rank.ACE ) ;
cards (2J new Card( Suit. HEARTS, Rank. THREE ):
cards (3J new Card(
I
publi C voi d shuffle() (
II no faz nada
I
publ ic Card dealUp() (
Suit.HEARTS. Rank.KING );
index++;
cards[index].setFaceUp( true ) ;
return cards [index]:
I
publ iC Card dealOown O (
index++;
return cards (index]:
I
public voi d reset() (
I I no faz nada
I
Voc pode usar esse objeto falsificado para testar se o jogo responde corretam ente quando a ban-
ca recebe uma mo de vi nte-e-um. Esse objeto falsificado realmente prepara o baral ho para rou-
bar no jogo.
Resumo
Hoje. voc concl uiu a terceira iterao do projeto do jogo vinte-e-um - resta apenas mais uma!
Neste capt ulo, voc viu como poderia estender a arquitetura de estado para suportar aposta sim-
ples nojogo. Voc tambm viu que s vezes necessri o rever e refazer lima hierarq uia, quando
novos requisitos se apresentam. Refazer pensadamente representa um pouco de trabalho extra
alllecipado; refazer quando apropriado tende a compensar quando voc prosseguir.
Iterao 3 do jogo vinte-e-um: adicionando aposta 429
Como voc refez as hierarquias agora, a base de cdigo ser muito mai s fcil de entender, esten-
der e manter posteriormente.
Amanh, voc colocar uma UI grfica no jogo.
Perguntas e respostas
P I'or que voc no modelou o cumprimento como um estado?
R Voc poderia ter modelado o cumprimento como um estado; entretanto, um estado de
cumpriment o teria signi fi cado rudo no projeto. As atividades dentro dos estados Busled,
B/ackjack e Slanding podem efet uar o jogo adequadamente. Alm disso, esses estados
podem efetuar o jogo muito especificamente.
Se a banca fizesse a transio para um estado de cumprimento, ela perderia suas informa-
es de estado anteriores. Se voc efetuar dentro de um estado especfi co, entretant o, a
banca poder fazer a contagem dojogo facilmente, pois saber em que estado terminou.
Workshop
As perguntas e respostas do teste so fornecidas para seu melhor entendimento. Veja as respos-
tas no Apndice A, ' Respostas".
Teste
I. Como voc pode estabelecer protocolos de herana eficientemente?
2. A lio sobre herana, na Semana I, disse que as hierarquias de herana so freqliente-
mente descobertas e no planejadas desde o incio. Qual hierarquia voc descobriu hoje?
3. Dada a Pergunta 2 do teste, por que voc deve esperar para realizar a abstrao at ter fei-
to algo algumas vezes?
4. Hoje, voc refez a hierarquia Pl ayer. Liste duas vantagens que voc obteve fazendo as
alteraes.
Exerccios
I . Faa download do cdigo-fonte da iterao de hoje. Quando voc tiver o cdigo, compi-
le-o, faa-o funcionar executando o jogo vinte-e-um e, depois, tente entender como ele
funciona. Ter um entendimento talai do cdigo exigir algum tempo e pacincia.
2. Projete e implemente o caso de uso Jogador dobra. Baseie sua soluo no cdigo-fonte
da lio de hoje.
DIA


SEMANA 3
Iterao 4 do jogo vinte-e-um:
adicionando uma GUI
At aqui nesta semana, voc anal isou, projetou e construi u um jogo de cartas vi nt e-c-um. Traba-
lhandoa parti r de uma implementao simples e fazendo iteraes para obter um aplicati vo mais
complexo, voc adicionou regras e recursos de aposta no jogo. Hoje, voc continuar o processo
iterativo e fa r melhorias na camada de apresentao do jogo.
Hoj e voc aprender como:
Aplicar anli se, projeto e implementao ao escrever interfaces com o usurio
Aplicar o padro MVC no jogo vinte-c-um
Apresentao do jogo vinte-e-um
At aqui, a nica interface para ojogo de canas vinte-e-um tcm sido uma rudimentar interface com
o usurio (UI) baseada em li nha de comando. No foi falado muito a respeito dessa UI. Na verda-
de, muito pouco, se que houve, anli se ou projeto aplicado a UI, apenas foi dito que voc usar o
padro MVC. Em vez de fazer a anlise e o projeto da UI de li nha de comando, a UI mais simples
possvel foi criada para pennitir que voc interagisse com o sistema do jogo vinte-e-um.
Durant e o desenvolviment o, voc freqOent emente ver que precisa desenvolver materiais de su-
porte, como objetos stubs ou partes de interao do sistema com o usuri o, como a UI. Freqen-
temente, esses materiais no sero orientados pela anlise. Em vez disso, esses itens so
orientados por necessidades que se apresentam durante a implementao. No caso do j ogo vin-
Dia 18
te-e-um, voc precisa absolutamente de uma maneira para interagir com o sistema; entretanto,
escrever uma UI grfica desde o incio si mplesmente no era prtico. Como a UI de linha de co-
mando no se desti nava a fazer parte do sistema final, no houve necessidade de realizar anlise
adi cional para ela.
Hoje, voc far uma ltima oli mizao na UI de linha de comando ori gi nal e depois passar para
a anlise, projeto e implementao de lima UI grfica (GUI) completa para ojogovinte-e-um.
Otimizaes da linha de comando
Antes de passarmos para o trabalho na GUI do jogo vinte-e-um, interessante fazer uma lt ima
otimizao na UI de linha de comando.
urna inconvenincia ter de reiniciar o jogo cada vez que voc quer j ogar. A Listagem 18. 1
apresenta um novo mtodo principal que permite a voc jogar quantos jogos vinte-c-um quiser,
sem ter de reiniciar.
LISTAGEM 18.1 Blackjack.java
publi c class Blackjack I
public stati c vold ma i n( String [] args ) I
Dec kpil e cards new Deckpile(} i
for{ i nt i = O; i < 4; i ++ ) I
cards .shuffle{) ;
J
Oeck deck new Deck()i
deck.addToStack ( cards )i
cards.shuff1e() ;
Hand dealer hand = new Hand();
BlackjackDealer dealer new BlackjackDealer(
cards );
Bank human_bank new Bank{ 1000 ) ;
Hand human_hand new Hand{);
"Dealer" ,
Pl ayer player new CorrmandLinePl ayer{ "Human" , human_hand, human bank
) ;
dealer.addListener{ Console.INSTANCE );
player. addListener( Console. INSTANCE );
dealer.addPlayer{ player )i
do I
dealer.newGame();
I while( playAgain () };
Iterao 4 do jogo vinte-e-um: adicionando uma GUI 433
LI STAGEM 18.1 Blackjack.j ava {conti nuao}
Consol e. INSTANCE.print Message { MThank you for playing'M };
}
pri vate stat ic boolean pl ayAgai n{} {
Console . INSTANCLpri ntMessage ( "Would you like to pl ay again? [Y) es
[Nl o };
}
}
St ri ng response Consol e.INSTANCE.read I nput{ "i nvalid" };
if( response . equa ls IgnoreCase{ "y" } ) {
return true;
}
return fal se ;
Adicionar essa funciona lidade no mtodo principal do jogo vinte-c-um tem um valor prtico,
pois ela nos ajuda a detectar todos os erros que possam estar ocultos no programa, quando voc
j ogar vrias vezes. Por exemplo, cada mo precisa ser correlamente reconfi gurada, antes do pr--
ximo jogo. Levantando todos os erros agora, voc no ser pego pelo erro posterionncnt e e no
achar. que a nova GUI a culpada.
Anlise da GUI do jogo vinte-e-um
Para completar a anli se da GUI, voc deve realizar a anlise de caso de uso, exatamenle como
fez durante as iteraes anteriores. Ao se realizar a anlise da GUI, tambm fundamental que
voc se sente com seus cl ientes, usuri os e especialistas na util izao, para projetar o layout da
GUI. Na realidade, quanto menos palpite voc der como desenvolvedor no layout da GUI, me-
lhor. Todo mundo tem sua prpria especialidade. Como descnvolvedor, sua especialidade nor-
malmente anal isar probl emas, projetar solues e implementar essas solues. Quando voc se
sentar com seu cliente, vai descobrir como ele quer sua OUI configurada.
I nfeli zmente. os especialistas em uti lizao, clientes e usurios no aparecem na fonna conveni en-
te de um livro; portanto, voc precisar passar sem eles hoje. Em vez disso, trabalharemos em
um esboo da tela, antes de passarmos para o projeto.
Casos de uso da GUI
Ao contrrio dos casos de uso do jogo vinte-e-um que voc anal isou durante as iteraes anteriores.,
os casos de uso da GUl no afetam o domnio do jogo em si. Em vez disso, os casos de li SO da
GUI ajudam a estabelecer como o usurio vai manipular o jogo vinte-e-um atravs da UI.
Dia 18
Desse modo, o primeiro caso de uso que voc precisa invest igar aquele que inicia um novo

Jogo:
Quando o programa est iniciando pela primeira vez ou o jogador acabou de jogar um jogo,
ele pode optar por jogar um novo jogo.
Novo jogo com GUI
I. O jogador clica no boto New Game e um novo jogo comea.
Condies prvias

o jogador deve ter acabado de iniciar o programaOll acabado de tenninar um jogo.
Condies posteriores
Novo jogo iniciado.
Conforme voc pode ver, esse caso de uso no altera o dom nio do j ogo vinte-e-um. Ele simples-
mente configura as regras bsicas da UI. O prximo caso de LISO da UI analisa as apostas:
Os jogadores comeam o jogo com US$ I 000 em seu pote. Antes que qualquer carta seja dis-
tri buda, cada jogador deve fazer uma aposta. Comeando com o primeiro jogador, cadajo-
gador aposta um valor de US$IO, USSSO ou US$ IOO. Se um jogador ficar abaixo de USSO,
ele ainda poder jogar. O valor em seu pote refletido como um nmero negativo.
Jogador faz aposta com GUI
I. O jogador seleciona um dos seguintes nveis de aposta: 10.50 ou 100 e faz a aposta
imediatamente.
2. A aposta passa para o jogador seguinte e se repete at que todos os jogadores tenham
feito uma aposta.
Condies prvias
Novo jogo iniciado.
Condies posteri ores.
O jogador fez uma aposta.
A banca pode comear a dar as cartas
Voc ainda precisa de suporte para dar mais cartas e para parar. O prximo caso de uso
identi fi ca o ato de dar mais cartas:
O jogador decide que no est satisfeito com sua mo. O jogador ainda no estourou; por-
tanto, ele decide receber mais cartas. Se ojogador no estourar, ele pode optar por receber
mais cartas novamente ou parar. Se o jogador estourar, o jogo passa para o jogador sc-
guinte.
Jogador recebe mais cartas com GUI
I. O jogador decide que no est satisfeito com sua mo.
2. O jogador clica no boto Hi t, que solicita outra carta da banca.
Iterao 4 do jogo vinte-e-um: adicionando uma GUI 435
3. O jogador pode optar por receber mais cartas novamente ou parar, caso o total em sua
mo seja menor ou igual a 2 1.
o Condies prvias
o O jogador tem uma mo cujo val or total menor que 2 1.
o O jogador no tem vinte-c-um.
o A banca no tem vinte-e-um.
o Condies posteriores
Uma nova carta acrescentada na mo do jogador.
Alternat iva: Jogador estoura
A nova carta faz com que a mo do jogador seja maior do que 21. O jogador estoura (per-
de). Comea a vez do jogador seguinte/ banca.
Alternat iva: a mo do jogador maior do que 2 1, mas ele tem um s
A nova carta faz com que a mo dojogador seja maior que 21. O jogador tem um s. O va-
lor do s muda de II para I, fazendo a mo do jogador ser menor ou igual a 2 1. O jogador
pode optar por receber mai s cartas novamente ou parar.
Se um jogador no quer receber mai s cartas, ele deve parar. O prximo caso de uso anali sa o uso
da QUI para parar:
O jogador decide que est satisfeito com sua mo e pra.
o Jogador pra.
1. O jogador decide que est cont ente com sua mo e cli ca no boto Stand.
o Condies prvias



O j ogador tem uma mo cujo valor menor ou igual a 21.
O j ogador no tem vinte-e-um.
A banca no tem vinte-e-um.
Condies posteri ores
A vez do j ogador termina.
E, por ltimo, mais no menos importante, voc precisa considerar a sada do j ogo:
O jogador decide que no quer mais jogar e sai.
Jogador sai do j ogo com QUI
I. O jogador clica no boto Quit.
2. O jogo se fecha.
o Condies prvias
O jogo no deve estar em andamento (nenhum jogo foi iniciado ou o jogo foi concludo).
1 436 Dia 18
Condies posteriores
Desligament o do j ogo.
Modelos visuais de GUI
Com base nos casos de uso enumerados na seo anterior, voc precisar projetar o layout da
GUI. A Figura 18. 1 apresenta uma possvel GUI que preenche todos os requisitos descobertos
durante a anli se.
FIGURA 18 .1
li CU! dojogo
\'il1le-e-lIl11.
Dealer (Banca)
Icana llcana l "
Nome do jogador S Banco
El
Icana I ..
I
USS10 I I USSO I I US5100 I
I
Hit
I I
Stand
I
INewG.me I
I
Qui.
I
Existem alguns comportamentos adicionais da GUI com que voc pode trabalhar agora. A Figu-
ra 18.2 ilustra o status dos botes quando o usuri o inicia o jogo pela primeira vez.
FIGURA 18 .2
O stafll.\" inicial
do.\" bales.
US$10 II US$SO II US$l 00 I
I Hit II S!and I lN_Gama i I Quit I
Todos os botes so vi sveis quando o jogo comea; entretanto, apenas New Game e Quit esto
ativos. A Figura 18.3 ilust ra o status dos botes aps um clique em New Game.
FIGURA 18 ,3
O stallls dos bOIOes aps
clicll/" em New Game.
I US$1O II USS50 II US5100 I
I Hit II Stand I I New Gam. 1 I Qui! I
Ite rao 4 do jogo vinte-e-um: adicionando uma GUI 437
o jogador deve fazer uma aposta aps clicar em New Game. Como resultado, apenas os botes
de aposta esto ati vos. A Figura 18.4 ilustra o status dos botes aps ter feito a aposta.
FIGURA 18.4
O SllIfltS dos botes
aps !a=er IIIIIlt
apoS/(I.
I us." II U"",, II uss", I
H't II Stand II New Gamai I Qu' t
Aps fazer uma aposta, um usuri o pode receber mais cartas ou parar. Assim, apenas os botes
Hit e Stand esto ati vos. Todos os outros botes so desativados. Os botes permanecem nesse
estado at que o jogador pare ou estoure, no ponto em que o jogo termina os botes voltam para
o status ilustrado na Figura 18.2.
Aps a concluso de um jogo, as cartas permanecem na te la at que o usurio clique em New
Game. As cartas so ento removidas da tela. Durante o jogo, a mo grfica do jogador atual i-
zada, quando uma carta distribuda para ele.
Esse layout de OUI afetar fortemente os modos de visuali zao que voc vai projetar na prxi-
ma seo.
Projeto da GUI do jogo vinte-e-um
Projetar as classes que compem uma OUI no diferente de projetar qualquer outro tipo de
classe. Voc deve identi fi car as classes individuais e suas responsabilidades.
Usando a Figura 18. 1 como ponto de partida, voc pode gerar uma lista inicial de classes. Voc
precisar de uma classe para a tela principal, uma classe para ver um j ogador e uma classe para
visuali zar as opes do jogador.
Cartes CRC da GUI
Uma sesso de cart o CRC pode ou no ser garantida aqui. Tudo depende de seu nvel prprio de
bem-estar. Para uma GUI maior, voc definitivamente desejar passar por um nmero de ses-
ses, para garantir que tenha fei to um bom trabalho na diviso das responsabilidades.
Para nossos propsitos, a OUI do jogo vinte-e-um suficientemente simples para que se possa
pular uma sesso de CRC completa. Em vez disso, listaremos as responsabilidades aqui.
PlaverView
PI ayerView responsvel por visualizar um objeto Player no jogo vi nte-e-um. O modo de visuali-
zao deve apresentar a mo, o nome e o saldo do pote de Player (se apli cvel). Pl ayerView
si mplesment e um veiculo de visual izao. Desse modo, ele no exige um controlador. Ele preci -
sa simplesmente receber e apresentar seu obj eto PI ayer.
Dia 18
OptionView e OptionViewController
Opt i onVi ew responsvel por visualizar as opes do jogador humano. Opt ionVi ew tambm preci
sa responder interao do llSlk'i rio, de modo que exige um cont rolador: Opt i onVi ewContro 11 er.
CardView
CardVi ew responsvel por visualizar os objetos Card individuai s. CardVi ew no int erativo; as
si m, ele no exige um controlador. PlayerVi ew usar CardVi ew para vi sualizar Hand.
BlackjackGUI
B 1 ackjackGU I responsvel por agregar e apresentar todos os diversos modos de visual izao.
Como BlackjackGUI at ua como um shell simples, ele no exige um controlador.
Miscelnea
CardVi ew precisar de um modo para mapear um objeto Card em uma imagem, para exibio.
Voc pode implementar um longo iflelse ou case para mapear o objeto Card dentro de CardView;
entretanto, tal estratgia horrvel (para no mencionar que lenta).
Em vez de criar uma estrutura condicional, voc deve fazer uma subclasse de Oeck e Cardo Voc
pode chamar as duas classes resullantes de VDeck. e VCard, respct ivamente. VCard receber um
argumento construtor extra, o nome de um arquivo bitmap. VOeck construir objetos VCa rd.
Como voc passa Oeckpi 1 e para Bl ackjackDealer, em vez de permit ir que BlackjackOeal er crie
seu prpri o mao de cartas, pode passar as carias visuais de fonna transparente para a banca.
Voc tambm precisar criar um novo j ogador humano para a OUI. Esse novo objelo GUIPl ayer
pode herdar diretamente de Bet t i ngPl ayer; entretanto, ele precisar fornecer seus prprios esta
dos Aposta e Jogo personal izados.
Em vez de basear uma deciso no mtodo hi t () ou bet(), o objeto GUIPl ayer precisar obter
essa informao da OUI. Como resultado, voc precisar de mtodos que a OUI possa chamar
para apostar, receber mais cartas e parar. Quando esses mtodos forem chamados, eles colocan1o
o jogador nos estados corretos e comunicaro qualquer informao para a banca.
Ao todo, voc precisar adicionar ou sobrepor os seguintes mtodos em GUIPlayer: placel()'-
BetO. place50Bet() , placelOOBet(), takeCard() , stand(), getBettingState() e getPlaying-
State().
Estrutura da GUI

As vezes, ao se trabalhar com uma GUI, aj uda esboar o modo como as panes se encaixaro.
Como a prpria GUI visual, seu esboo pode ser realmente um pouco mais poderoso do que os
diagramas de classe padro. A Figura 18.5 visualiza Pl ayerView.
Iterao 4 do jogo vinte-e-um: adicionando uma GUI
FIGURA 18.5
Vislfoli:olldo Pl ayerVi ew.
439
Voc v que, na Figura 18.5, PI ayerVi ew consti tudo de vrios objetos CardView. PI ayerView
tambm desenha uma borda em torno de si mesmo, com o nome e o saldo do pote (se aplicvel)
de PI ayer, no canto superior esquerdo.
Feli zmente, o pacote Java javax. swing . JPanel fornece toda a funciona lidade que voc precisa
para dispor component es, assi m como para desenhar uma borda rotulada.
Continuando, a Figura 18.6 visual iza OptionView.
FIGURA 18.6
Visl/a!i:olldo OptionView.
Oplion View Controles de aposta
r - - - - - - - - -A.- - - - - - - - --I
: ~ U5$10 II U5$5O II U5$100 1\ :
, ,
: I Hit II Stand I I N8W G.mel I Qui! I :
:_\ ___ ___ ~ f : ___ ~ - - - - ~ ~
Controles do jogador
Controlei do ioga
OptlonView si mplesmente um conjunto de botes. Uma combinao de javax.swing.JPanel
(para aninharas botes) e j avax. swi ng .JButton deve fornecer tudo que voc precisa para imple-
mentar esse modo de visualizao.
A Figura 18.7 rene visualmente todas as partes.
As fi guras anteriores devem ajudar a visualizar como todos os modos de visualizao se encai-
xam. Entendercomo as partes se encaixam pode ajudar durante a implementao de urna GUJ.
Refazendo
Agora que existem dois tipos de jogadores humanos -GUI e CLUJ - provavelmente faz senti-
do renomear HumanPlayer como ConmandUnePlayer. Voc deve fazer essa alterao hoje.
FIGURA 18.7
A j(me/a I>rincifXIl
dividida por 1II0dos de
ris/lali=ac7o.
Modos de
visualizao
do jogador
Modo de
visueli zao
de opo
Dia 18
GUI do jogo vinte-eum
Modo de visualizao
da carta: vislvel
-------------------- -
I Banca I
,
,
,
,
< - - - - - - ~
,
,
,
, ,
~ - - - - - - - - - - - - - - ______ I
---- ---- ----------- --
I Nome do jogador $ Banco
,
,
Icarta Ilcarta I ...
~ - - - - - - - - - - - - - - _ _____ I
Diagrama de classes da GUI
Agora que todas as novas classes esto identificadas, voc pode modelar a estrutura de classes
resultante. Assim como o diagrama de classes do Capitulo 17, lterao 3 do jogo vintee-um:
adicionando aposta", o modelo aprese.uado na Figura 18.8 focaliza a estrutura.
Implementao da GUI do jogo vinte-e-um
Ao se implementar uma OUI, em geral, mais fcil trabalhar de baixo para cima. Nesse sent ido,
voc deve implementar na seguinte ordem: VCard, VDeck, CardView, PlayerVlew, OptlonView,
Opt i onVi ewCont ro 11 er, GU I P1 ayer e B1 ac kjackGU I. Vamos exam inar os destaques de cada clas-
se.
Implementando VCard, VDeck e CardVi ew
VCard tem uma implementao relativamente simples, pois apenas acrescenta mais um atributo
classe Cardo A Listagem 18.2 apresenta a nova definio da classe VCard.
Iterao 4 do jogo vinte-e-um: adicionando uma GUI
FIGURA 18.8
A esrrulllra de
classes da GUI.
BI"CkjlM'k GUI
LI STAGEM 18.2 VCard.java
,
1 comrola
r:-:---:-:-=---'
Option ViewConlro II
..,.nipul, a
r,..,.be dto
"
manipula.
recebe dto
I diciona cartas 1m
publ ic class VCard extends Card {
String image;
2 ... B,=:-=
,
diouibul dto
publi C Vcard( Sui t suit, Rank rank , String image ) (
supere sui t , rank );
t his. image .. image;
}
publ ic Str i ng getl mage() {
i f( i sFa ceUp() ) I
return image;
441
Jt..bel

uibe
,
VCfld
B.ttingPl. "..
QUIPI ..... .
Dia 18
LISTAGEM 18.2 VCard.java (continuao)
} else {
return N/ bltmaps/ empty pile.xbm
N
:
}
}
}
A implementao de VOeck si mples. Para criar obj etos VCa rd. em vez de Card, voc preci sar
sobrepor O mtodo bui l dCards() de Deck. Para sobrepor o mtodo, primeiro voc precisar mu-
dar o mtodo para protegido em Oeck. Originalmente, o mtodo era privado. A Listagem 18.3
moma uma li stagem parcial da implementao de VOeck.
LI STAGEM 18.3 VOeck.java
publ iC class VOeck extends Oeck {
protected void buildCards() {
II Isso horrvel , mas melhor do que a alternativa lao/ if/ else
Ca rd () deck new Card (S2):
setOeck( deck l:
deck [O] new Vcard ( SuH.HEARTS , Rank . TWO , "/ bi tmaps/ h2 " ):
deck [1]
new Vcard( Suit. HEARTS , Rank. THREE, N/ bitmaps / h3
N
) ;
deck [2] new Vca rd ( Suit. HEARTS, Rank . FOUR, ):
deck [3] new Vcard ( Suit. HEARTS, Rank . FIVE , "/bHmaps/ hS- l:
deck [4]
o Vcard( Suit. HEARTS, Rank.S IX, "/ bHmaps/ h6" ,;
deck [5]
new Vcard( Sui t.HEARTS, Rank.SEVEN, "/bitmaps/h7" ) ;
deck [6] new Vcard( Suit.HEARTS, Rank . EIGHT, "/bitmaps/h8" ):
II restante cortado por brevidade
Para a GUI, usaremos um conjunt o de bitmaps que est contido no diretrio bitmaps,j unto com
o download do cdigo-fonte. Os nomes dos bitmaps seguem uma conveno de atribuio de
nomes especl1ca; ponanto, voc tambm pode implementar bui 1 dCards () como um lao.
Embora seja horr vel, simplesmente codificar os valores um pouco mai s fcil de entender (e
manter).
ALERTA
Iterao 4 do jogo vinte-e-um: adicionando uma GUI 443
Codificar a cri ao da carta tambm pode no ser a sol uo mais fci l de man-
ler . O problema que cada estratgia que voc possa adol ar tem uma def icin-
cia. VDeck um exemplo de uma dessas ocasies em que voc deve fazer uma
escol ha entre doi s males e convi ver com ele.
A soluo delineada anterior mente falha. devido aos erros inerentes na digi-
t ao de t odas as chamadas. Alm disso. se o construtor mudar. voc precisa-
r atualizar cada chamada.
Como alternativa. voc poderia fazer um lao pela representao de List de
Ranks. Tal sOluo o obriga a supor uma ordem especfica dos elementos na
li sla (para que voc possa gerar corretamente o nome de arqui vo da imagem).
Se a ordenao mudar. o lao ser desfei to mi steri osamente. Qualquer um
que mantiver o cdigo ter dificuldade para encontrar a fonte do erro. Evi ta-
mos a estrat gi a do lao porque alteraes em uma classe no relacionada po-
deria danificar VOeck.
CardVi ew exibir o bitmap VCa rd. j avax . swi ng. JLabel fornece a funci onalidade necessri a para
exibir um bitmap. A Listagem 18.4 apresenta a implementao de CardVi ew.
LISTAGEM 18.4 Ca rdView.java
i mpor t
i mport
. . *
Javax. SWlng. :
. t *
Java.aw . ;
publiC class Ca rdView extends JLabel {
,
private ImageI con icon;
publi c CardView( VCard card ) I
getImage( card.get Image{) ) ;
setIcon( i con ) ;
setBackground( Color.white ) ;
setOpaque( true );
,
pri vate voi d get Image( String name ) I
,
java.net.URL url thi s.getClass().getResource ( name );
icon new Image Icon( url ) ;
CardVi ew recebe um objeto VCard, extrai o caminho do bitmap, convert e O cami nho em uma url,
cri a um ImageIcon e adiciona o cone em si mesmo. Isso tudo que voc precisa para carregar e
exibi r um bi tmap!
Dia 18
Implementando PI ayerVi ew
PJayerView exibir qualquer subclasse de pj aye r. Ao contrri o de OptionView, que voc ver na
prxima seo, pj ayerVl ew s precisa apresent ar o objeto PI ayer; ele no aceita interao do
usurio. Como resultado, a implement ao muito simples. A Listagem 18.5 apresenta o mto-
do que chamado quando o objeto PI ayer muda.
LISTAGEM 18.5 O cdigo atual izado de PlayerView
publiC void playerChanged( Player player ) (
border . setTitle( player.getName() ) ;
cards . removeAll();
I
Hand ha nd player . getHand() ;
Iterator i hand.getCar ds() ;
while(i . hasNext{) ) (
I
VCard vcard (Vcard) i.next() ;
JLabel card new Ca rdView( vcard l ;
cards.add( card li
reval i dateO;
repai nt () i
Como voc pode ver, o mtodo pl ayerChangedO extrai os objetos VCard de PJayer e cria um
CardView para cada um. Finalment e, ele adiciona o modo de visualizao em si mesmo, para que
o obj eto VCard seja apresentado.
A implementao apresentada aqui no a mais eficiente, pois ela cri a um novo CardVi ew para
cada objeto VCard, sempre que o objeto PI ayer muda. Uma implementao mais eficiente pode-
ria usar alguma cache do modo de visualizao. Como voc est usando objetos, pode mudar a
implementao para outra mais eficiente, a qualquer momento. O desempenho parece estar nor-
mal, de modo que a sobrecarga da adio do uso de cache simplesmente no vale a pena neste
pont o.
Pl ayerVi ew tambm precisa apresentar o resultado do j ogo de Pl aye r. A Listagem 1 8.6 apresenta
dois mtodos que so chamados no fi nal do jogo de Pl ayer.
LISTAGEM 18.6 Um exemplo dos mtodos PJ ayerL i stener de Pl ayerVi ew
public void pl ayerBusted( Player pl ayer ) (
border.setTitle( pl ayer.getNameO + " BUSTEO!! " )i
cards .repai nt()i
I
publ i c void pl ayerBlackjack( Player player ) {
Ite rao 4 do jogo vinte-e-um: adicionando uma GUI 445
LI STAGEM 18.6 Um exempl o dos mtodos Player Listener de Pl ayerVi ew (continuao)
border.setTit le( player.getNameO + " 8lACKJACK!" );
cards.repaf nt( );
,
Esses mtodos configuram a borda do modo de visualizao com o resullado do jogo. PI ayer-
L istener defi ne mais do que dois mtodos, mas assim como os dois li stados aqui, a impl ementa-
o dos mtodos de PI ayerVi ew segue um padro semelhante para todos. Examine o
cdigo- font e, se voc esti ver interessado em ver a lista intei ra de mtodos de atuali zao.
Implementando OptionView e OptionViewController
Opti onView herda de JPanel e acrescenta vrios botes em si mesmo. Opti onView no recebe do
modelo. Em vez di sso, Opt i onViewControll er recebe do modelo e ativa ou desativa os botes
em OptionView, conforme for apropriado.
Nenhuma das duas classes muito interessante do ponto de vista da implementao. Se voc es-
tiver interessado nos detalhes especificas, faa download e leia o cdigo.
Implementando GUIPlayer
GUIPI aye r provavel mente a classe mais interessante dessa iterao. Ao implementar uma GUI,
voc deve lembrar que toda int erao com o usuri o assncrona - ela pode surgir a qualquer
momento.
Escrever um j ogador de linha de comando foi muito fcil . Voc s6 teve que sobrepor hl te) ou
bet() para que ele fosse lido da linha de comando. Como a linha de comando fi ca bloqueada at
receber a entrada do usuri o, o j ogador foi muito fci l de implementar. Um jogador com GUI
um pouco mais dificit de escrever.
Em vez de chamar um mtodo e bloquear at recebermos a entrada, GUIPlayer precisa esperar
at que o usuri o decida cl icar em um boto. Como resultado, todos os estmulos vm de/ora do
jogador.
Em resposta a essa realidade, voc precisa adicionar vrios mtodos que a GUI possa chamar
para GUIPl ayer. A Li stagem 18.7 lista os mtodos de aposta que voc deve adicionar.
LI STAGEM 18.7 Mtodos de aposta de GU I Player
II esses mtodos de aposta sero chamados pelo controlador da GUI
II para cada um: faz a aposta correta, muda o es tado, permite que a
II banca sai ba que o jogador t erminou de apostar
public void pl acel08et() (
get8ank O . pI ace 108et () ;
setCurrentState( getWaitingState() ) ;
Dia 18
LISTAGEM 18.7 Mtodos de aposta de GUIPlayer (continuao)
dealer.doneBetting( this );
,
publiC void place50Bet() I
getBank() . place50Bet();
setCurrentState( getWaitingState() );
dealer.doneBetting( this };
,
pUblic void placelOOBet() {
getBank().placelOOBet();
setCurrentState( getWa i tingState() );
deal er.doneBetting( th1s );
,
Voc notar que esses mtodos precisam fazer apostas e configurar o usurio com o estado cor-
reto. A Listagem 18.8 li sta os mtodos para receber mais cartas e para parar.
LI STAGEM 18.8 Mtodos para receber mais cartas e para parar de GUIPlayer
II takeCard ser chamado pelo control ador da GUI , quando o jogador
II decidi r receber mais cartas
public void takeCardO {
dealer.hit( thi s );
,
II stand ser chamado pelo controlador da GUI . quando o jogador optar
II por parar, quando a parada mudar de estado , deixa o mundo saber, e ento
II diz banca
public void stand{) {
,
setCurrentState( getStand1ngState() l;
notifyStanding();
getCurrentStateO .execute( dealer );
Assim como os mtodos de aposta, os mtodos da Listagem 18.8 devem executar sua ao e atuali-
zar o estado. Como o estado no pode simplesmente chamar hi t () ou bet() para jogar ou apos-
tar, voc precisar fornecer alguns estados Jogo e Aposta personalizados. A Listagem 18.9
apresenta os metodos getPlayingStateO e getBettingStateO sobrepostos.
LISTAGEM 18.9 Mtodos de obteno de estado sobrepostos de GUI Player
protected PlayerState getPlayingState() I
return new Playing();
Iterao 4 do jogo vinte-e-um: adicionando uma GUI 447
LI STAGEM 18.9 Mtodos de obteno de estado sobrepostos de GUIPl ayer (conto)
I
protected PlayerState getBett i ngState() I
return new Betting();
I
Sobrepondo esses mtodos, GUIPlayer pode fornecer seus prpri os estados personalizados. A
Listagem 18. 10 apresenta o estado Jogo personali zado de GUIPl ayer.
NOTA
Mtodos como getPlayingState() e getBettingStateO so mtodos faclory.
LI STAGEM 18.10 Estado de Jogo personalizado de GUIPlayer
private class Playing implements PlayerState I
I
publ iC void handPlayabl e() I
II no faz nada
I
public void handBlackjack() I
setCurrentState( getBl ackjackState() );
notifyBlackjack ();
getCurrentSt ate().execute( deal er );
I
publi c voi d handBusted() (
setCurrentState( getBustedState() );
not ifyBusted () ;
getCurrentState().execute( dealer };
I
public void handChanged() (
notifyChanged();
I
public void execute( Dealer d ) {
I
II no faz nada aqui , as aes viro da GUI, que
II externa ao estado, mas quando eventos chegarem. certifica-se de
II impor a transi o de estado imediatamente
Dia 18
Quando executado, o estado Jogo personalizado no faz nada. Em vez disso, GU IPlayer precisa
esperar pela interao assncrona da GUI. Voc notar que o esradoJogo ainda faz transiesem
resposta aos eventos de Hand.
A Listagem 18.1 1 apresenta o estadoAposla personalizado. Voc notar que esse estado no faz
nada. Em vez disso, GUIPl ayer deve esperar que ojogador pressione algum boto na GUI. Quando
isso acontecer, o boto chamar o mtodo de aposta correto em GUIPlayer.
LISTAGEM 18.11 Estado Aposta personalizado de GUIPlayer
private class Bett1 ng implements P1ayerState {
pub1ic void handChanged() {
II impossvel no estado de estouro
I
public void handPlayab1e () {
II impossvel no estado de estouro
I
publ ic void handBlackjackO {
II impossvel no estado de estouro
I
public void handBusted{) {
II impossvel no estado de estouro
I
public void execute( Oea l er d ) (
II no faz nada aqui , as aes Vl rao da GUI, que
II externa ao estado, pois nenhum evento vem como parte da
II aposta: o estado precisar ser mudado externamente pa ra este estado
I
I
Reunindo tudo com BlackjackGUI
B1 ackjackGU I cria e exibe o sistema de jogo vinte-c-um. A Li stagem 18. 12 deslaca o mtodo
setUpO de Blac kjackGUI.
LISTAGEM 18.12 Mtodo setUpO de BlackjackGUI
private void setUp() {
BlackjackOealer dea1er getOealer():
PlayerView vI getP1ayerView( dealer ) :
GUIPlayer human = getHuman() ;
P1ayerView v2 z getPlayerView( human );
PlayerView [] views { vI , v2 }:
Iterao 4 do jogo vinte-e-um: adicionando uma GUI 449
LI STAGEM 18.12 Mtodo setUp() de BlackjakGUI (continuao)
addPlayers( views )i
dealer.addPlayer( human li
addOpt ionView( human , dealer )i
}
o mtodo setupO cria cada jogador, os modos de visualizao e coloca tudo junto. Os outros
mtodos principalmente constroem os vri os objetos. Se voc estiver interessado no cdi-
go-fonte completo, examine o cdigo. A Figura 18.9 ilustra a tela fina l do jogo.
FI GURA 18.9
;/ GVI dojogo
,ill/e-e-lIl11.
Resumo
Hoje, voc viu o padro MVC aplicado a um programa rea l. s vezes, ajuda ver um exemplo es-
tendido, para poder entender completamente um padro. A lio de hoje tambm apresentou a
questo de que uma GUI no algo a ser pensado posteriormente. A GUI merece o mesmo nvel
de anlise e projeto que qualquer outra parte de um sistema.
A lio de hoje conclui o jogo vinte-e-um. Amanh, voc ver um projeto e implementao al-
ternati vos da GUI do jogo vinle-e-um.
Dia 18
Perguntas e respostas
P Voc mencionou anteriormente que no deve simplesmente anexar a GUI no final.
Bcm, essa foi a ltima iterao e estamos adicionando uma GUI . Isso no vai contra
o que voc disse anteriormente?
R No, absolutamente, no!
Quando dissemos ' anexar', queramos dizer adicionar uma GUI sem realizar qualquer
projeto. Ns planejamos uma GUI desde o in cio. No comeo, dissemos que poderamos
usar MVC. Esse foi todo o projeto que precisamos realizar, at estarmos finalmente
prontos para adicionar a GUI. Uma vez prontos para adicionar a GUI, fizemos mais um
projeto, em uma iterao totalmente dedicada GUI.
Dizer anteriormente que usaramos MVC e adicionar um mecani smo observador era
tudo que precisvamos fazer para saber que pudesscmos suportar uma GUI.
P Onde/quais esto/so as diferentes partes do MVC (encontramos meno de vrios
modos de \'isualizao e de um controlador)? Desenvolva o que so o modelo e o
controlador.
R O modelo o sistema. Neste caso, Bl ackjackOea l er, BettingPl ayers etc., consti tuem a
camada do modelo.
O projeto pedi u apenas um controlador - Opt "i onViewCont rol l er - assim, no havia
muito a dizer sobre controladores.
Workshop
As pergunt as e respostas do teste so fornecidas para seu melhor entendimento. Veja as respos-
tas no Apndice A, " Respostas".
Teste
I. Como voc usou herana e polimorfismo para introduzir uma carta " vi sual"?
2. Na lio sobre herana, foi mencionado que, se um mtodo no necessrio para as clas-
ses externas e no exi stem requisitos para uma subclasse usar o mtodo, ento voc deve
defini-lo como privado. Se uma subclasse precisar dele, voc pode torn-lo protegido
nesse momento, mas no anteri ormente. Encontre um exemplo dessa recomendao no
projeto do jogo vinte-c-um.
Ite rao 4 do jogo vinte-e-um: adicionando uma GUI 451
Exerccios
I. Faa downl oad do cdigo-fonte da iterao de hoje. O cdigo est dividido em dois dire-
lrios separados: mvc_9ui e exercise_2.
mvc_gui contm o cdigo da GUI que foi criada durante a iterao de hoje.
exerci se_2 contm os arquivos que voc precisar para o Exerccio 2, ass im como as so-
lues.
Estude o cdigo cm mvc gui. Tente entender como tudo funciona e depois complete o
Exerccio 2.
2. O Exerccio 2 do Captulo 17 pediu para que voc adicionasse o recurso de apostar em do-
bro no j ogo vi nte-e-um. Voc precisa adicionar esse recurso no jogo novamente. Desta
vez, adicione-o na versao grfica do jogo que voc carregou por downl oad para o Exerc-
cio I. O download inclui lodosos arquivos que voc precisar para comear este exerccio.
SEMANA 3
DIA
Aplicando uma alternativa ao MVC
Ontem, voc anali sou, projetou e implementou uma GUI para o jogo vinte-e-um. Hoje, voc vai
usar uma outra estratgia para o projeto e implementao da OUI.
l-laje voc aprender:
Sobre uma alternativa para o padro de projeto MVC
Como apl icar uma OUI altemat iva no jogo vinte-c-um
Quando basear suas QUIs no MVC e quando no fazer isso
Uma GUI alternativa do jogo vinte-e-um
Ontem, voc criou uma OUI para o jogo viIHe-e-urn baseada no MVC. O MVC apenas uma es-
tratgia para o projeto de GUI. Hoje, voc vai reprojetar e reimplementar a GU[, usando uma es-
tratgia diferente.
A estratgia que voc vai empregar hoje uma especializao do padro de projeto PAC (Pre-
sellfalioll Absfraclion Con/rol). Assim carnoo padro de projeto MVC, o padnl0 de projeto PAC
divide o projeto da GUI em trs camadas separadas:



A camada de apresent ao, que exibe o sistema
A camada de abstrao, que representa o sistema
A camada de controle, que monta todos os componentes da camada de apresent ao
Dia 19
As semel hanas do PAC com o padro de projeto MVC so ilusrias. Na verdade, o PAC segue
uma fi losofia totalmente di ferente daquela seguida pelo padro MVC.
As camadas do PAC
A camada de abstrao do PAC semel hante camada de modelo no padro MVC. A camada de
abstrao abriga a funcionalidade bsica do sistema. essa funcionalidade que a camada de
apresentao exi be e manipula. A camada de abstrao tambm responsvel por dar acesso aos
obj etos do nvel de apresentao.
No PAC, as funcionali dades das camadas de visuali zao e controladora do MVC no so divi-
di das; cm vez disso, essas duas enti dades so combinadas dentro da apresent ao. A camada de
apresentao responsvel por exibir e manipular a camada de abstrao, assim como por res-
ponder interao do usurio.
Corno o comrole e o modo de visualizao MVC so combi nados na camada de apresentao, o
cont role tem um objetivo totalmente diferente no PAC. No PAC, o controle monta todas as dife-
remes apresentaes. Ele no recebe e responde interao do usurio, corno o controlador MVC.
A filosofia do PAC
o MVC faz todo o possvel para desacoplar completameme cada parle de seu projeto. Quando
voc lisa o padro MVC, fcil trocar para novos modos de visual i7..aoem seu sistema, a qual -
quer momento; assim, usaro padro MVC proporciona a voc muita liberdade sobre como exibe
seu sistema. Ent retanto, o Captulo 13, "00 e programao de interface com o usuri o", informa
que a maior liberdade tem o preo do encapsulamento.
A estratgia do PAC diferente. O PAC no desacopla as camadas de apresentao e abstrao.
Em vez disso, as duas camadas so fortemente acopladas. Isso no quer dizer, por exemplo, que
PI ayer estender JComponen t diretamente. Isso quer di zer que a camada de abstrao criar e re-
tornar sua apresent ao. Assim, PI ayer e sua apresentao ai nda so dois objetos separados.
Para obter uma apresentao diferente de uma parte da abslrao, voc precisar al terar a defini -
o da abstrao para que ela relorne um objeto de apresent ao d i ferent e. um pouco mais d i fi-
ei l alterar a apresentao ou fornecer dois ou mais modos de visualizao diferent es do mesmo
sistema.
A construo da GUI mais fci l, entretanto. Quando a camada de controle montar a tela, ela so-
li citar a cada membro da camada de abst rao sua apresentao. Tudo que a camada de controle
precisa fazer adicionar essa apresent ao na tela principal. No h modo de visual izao e con-
trolador para reuni r.
Aplicando uma alte rna ti va ao MVC
Quando usar o padro de projeto PAC
A suposio subjacent e do PAC que voc no precisar fornecer vri os modos de visuali zao
do sistema. Em vez disso, quando usa o PAC, voc precisa cert ifi car-se de que o sistema tenha
apenas uma interface bem definida. Se seu sistema vai ter apenas uma interface, o PAC pode for-
necer uma alternativa muito elegante ao MVC.
O PAC tem vrias vantagens. Como a camada de abstrao pode criar sua apresentao, voc
no precisa destrui r o encapsulamento de seu sistema. Em vez disso, voc pode defini r as classes
de apresentao como classes internas. Como lima classe interna, a apresentao pode ter talai
acesso a sua classe de abstrao progeni tora. Quando ela precisa visualizar a abstrao, pode
acessar e exibir diretamente o estado da abstrao.
O uso de PAC si mpli fi ca a comunicao entre a apresentao e sua abstrao. Quando a abstra-
o mudar, ela pode simplesmente chamar um mtodo de atualizao na apresentao que tiver
criado.
Quando voc usa o padro PAC, pode considerar a apresentao como urna extenso direta da
abstrao. At uando na apresentao, voc atua diretamente no sistema subjacente. De certa for-
ma, a apresentao age de forma muito parecida com um proxy para o sistema. Tal manipulao
direta simplifica mui to o projeto global.
Analisando a GUI PAC do jogo vinte-e-um
Para aplicaro padro de projeto PAC na aUI do jogo vinte-e- um, voc pode simplesmente reuti -
liz.1r a anlise que fez ontem. Nada muda quanto anlise, pois voc decide usar o padrJo PAC
em vez do MVC.
Projetando a GUI PAC do jogo vinte-e-um
Para o jogo vinte-e-um existe apenas uma interface principal: uma aUI. Voc no vai distribuir
esse jogo como um aplicativo HTML da Web (embora voc pudesse transform- lo em um applet
facil ment e) ou como um POA; assim, seguro usar o padro de projeto PAC.
,
E import ante notar que nada o obriga a remover os mecanismos receptores que j construiu no
sistema. Ainda possvel ter uma aUI baseada em linha de comando e uma aUI baseada no
PAC, simultaneamente. Na verdade, atravs do uso cuidadoso de subclasses, voc pode deixar
Iodas asdefinies de classe originais intactas. Quando voc quiser uma aUI, pode si mplesmen-
te instanciar as classes que suportam uma OUI. Quando voc quiser um jogo de linha de coman-
do. pode instanciar as classes ant igas. Escolher MVC ou PAC no o impede necessariamente de
usar o outro.
Assi m como no Capitulo 18, " Iterao 4 do j ogo vinte-e-um: adicionando uma aUI", voc pode
pegar o projeto e implementao completos do Capitulo 17, " Iterao 3 do jogo vinte-e-um: adi-
Dia 19
cionando aposta", como base para a nova GUI. O que voc precisa fazer descobri r qua is dessas
classes precisam de seus prpriosobjetos de apresentao. Quando voc ti ver essas classes iden-
tificadas, precisar projetar a camada de abstrao. Quando isso estiver fei to, voc poder proje-
tar a camada de controle.
Identificando os componentes da camada de apresentao
Para identificar os componentes da camada de apresentao, ajuda fazer alguns esboos da GUI.
Desta vez, voc deve associar partes da tela classe subjacente, em vez de associ-Ias a um
modo de visualizao separado.
A Figura 19.1 isola uma part e da GUI. Dissecando cui dadosament e esse segmento da tela, voc
pode identificar alguns componentes da apresentao.
FI GURA 19. 1
Um .egmelllo
da tela.
Jogador
Carta
M'o
-
.\
,
- -- - - - - - --
Noma
- - - - - - -
- -,
,
__ L
,
,
,
,
,
,
,
,
,
,
,
:8:
D :
r rta r
, ,
- - -
-
,
r ____
- - - - --
-
- -
,
,
,
,
,
,
,
, ,

Dividi ndoo segmento da tela em partes, voc pode ver que Card, Ha nd e Player precisal""ao forne-
cer objetos de apresentao. A Figura 19.2 disseca a parte restante da te la.
FIGURA 19.2
Os botes (/(1 GUI.
Jogador

,
I USS10 II US$50 II US0100 I
,
Hit I I Stand I New Gam, ll Quit
-- ------ -- -----------
Todos OS botes pertencem ao objeto Player humano; portanto, a classe que representa o joga-
dor humano precisar estender a apresentao de PI ayer e adi cionar botes. GUIPl ayer deve ter
um projeto igual quele criado para o Captulo 18. Em vez de repetir esse projeto aqui, volte e
leia a seo " Implementando GUI Player" , no Captulo 18, se voc precisar de um lembrete. A
Aplicando uma alternativa ao MVC
nica diferena entre a GUIPlayer do Captulo 18 e esta que esta tambm fornecer uma apre-
semao de si mesma.
Projetando os componentes da camada de abstrao
Na seo ant erior, voc identificou Card, Hand e as di versas subclasses de PI ayer necessrias
para fornecer uma apresentao delas mesmas.
Para cada uma dessas classes, voc precisa criar uma subclasse de abstrao. Em part icular, voc
precisa ter uma subclasse de BlackjackOealer, BettingPlayer, Hand c Ca rdo Alm di sso, voc
precisa cri ar uma GUIPl aye r, como no Captulo 18. Entretanto, essa GUI Pl ayer tambm precisa
fornecer uma apresentao.
A Figura 19.3 ilustra a hierarquia de herana Player resultante.
FIGURA 19.3
A hierarquia
dI! abslra(io
Pla)'er
(Jogador) .
JPanel
81acJcj acJcOeala
VBlockjackPlayer
1 tria
PlIly9r
BettingPlllyer
V8ettingPlsyer
cria
,
JPanal
BettingView
,
,
,
, tontm
OealerView
GUIPlayer cria GUIVl lJw
~ ~
Voc precisa criar uma subclasse VBlackjackDealer BlackjackDealer. Voc tambm preci sa
criar uma subclasse VBetti ngPl ayer Bett i ngPl ayer. Essas subclasses adicionaro suporte para
criar e retornar objetos de apresentao.
A Figura 19.4 il ust ra as hierarq uias Hand e Car<! resultante.
FIGURA 19.4
A hierarquia de absrra(io
Hand (Meio) e
Card (Ca,.w).
Dia 19
JllI bel
J llIbel
Voc precisar criar lima subclasse YCard Card, assim como uma subclasse VHand Hand. Essas
subclasses visualizaro Card e Hand, respectivamente. Como no projeto de ontem, voc tambm
precisa de um VDeck. O VDeck criar um mao de objetos VCard.
Projetando a camada de controle
O controle uma classe relati vamente simples. Uma instncia do controle recuperar um objeto
VBlackjackOea ler, assim como os vri os j ogadores. De cada um desses objctos, o cont role soli -
citar um objeto de apresentao. O controle pegar esse obj eto de apresentao e o adicionar
na exibio.
Voc precisar projetar um mecanismo que o console possa usar para solicitar camada de abs-
trao a apresentao de seus objetos. A estratgia mais fcil definir uma interface - vamos
cham-la de Di sp' ayab 1 e. Di sp 1 ayab I e tem um mtodo: pub I i c JComponent vi ew (), que recupe-
ra a apresentao de um objeto. Cada classe de abstrao que fornece uma apresentao precisa-
r implementar esse mtodo.
As figuras 19.5 e 19.6 mostram as hierarquias alual izadas. Agora, as classes de abstrao perce-
bem a interface Displayable.
Usando o padro Factory para evitar erros comuns
Existe um pequeno problema na hi erarquia resultante: nada o impede de criar um objeto Deckpi-
1 e de objctos Card que no possam ser exibidos e pass-los para a banca. Os relacionamentos
com capacidade de substi tuio permitem tal substituio. Infelizmente, voc experimentar er-
ros de tempo de execuo, se misturare combi nar as classes GUI e no-GUI incorretamente.
O Capitulo 12, "Padres avanados de projeto", apresentou o padITio de projeto Abstract Fac-
tory. Um moti vo para usar esse padro era para garantir que um conjunto de objetos fossem usa-
dos juntos. Isso o impede de usar obj etos incompatveis juntos.
FI GURA 19 .5
A hierarquia de
absfratio Pl ayer
alllali:ada.
FIGURA 19.6
A hierarquia de
abslrac70 Hand e
Card allfali: ada.
Aplicando uma alternativa ao MVC 459
BllICkjackDealer 8ertingPfayer
Displayable
vi!Wf}:JCompot1enr
VBlackjackPlayer
V8ertingPIByer 8otringViow
,
JPanal
,
cria
,
, ,
conlm
GUIPlayer
, ,
DealerView
Mio
VCard
1 conlm
JLebel
JLlbel
, ,
t.. __ __ HandView
Voc pode usar factory para garanl irque os objelos correiOS sejam usadosjunlos. Voc precisar
criar factory que retome um objeto VBl ackjackOeal er e um objeto GUIPlayer que tenham sido
instanci ados com os tipos corretos de argument os. Quando o controle for recuperar os jogadores
e a banca. ele dever fazer isso apenas atravs de factory. Essa camada extra garantir que todos
os objetos sejam instanciados corretamente.
Dia 19
Implementando a GUI PAC do jogo
vinte-e-um
A lio de ontem mostrou que, ao se implementar uma GUI, freqUentemente mais fcil traba-
lhar de cima para baixo. Segui ndo essa recomendao, voc deve implementar na seguinte or-
dem: VCard, VHand, VBettingPlayer, VBlackjackGUI e GUIPlayer. Vamos examinar cada
implementao.
Implementando VCard e VHand
VCard herda de Card e se representa atravs da classe interna: CardView. A Li stagem 19.1 apre-
senta a implementao de VCard.
LI STAGEM 19.1 VCard. java
public class VCard extends Card implements Oisplayable {
private String image;
private CardView view;
publiC Vcard( Suit suit. Rank rank . String image ) (
supere sui t. rank ) ;
this.image image;
view new CardView( getImageO );
J
publiC void setFaceUp( boolean up ) (
super.setFaceUp( up );
vi ew. changed O;
J
public JComponent view() (
return view;
J
private String getlmage() (
if( isFaceUp() ) (
return image;
) else {
return M/ bitmaps/ empty_pile.xbm-;
J
J
private class CardView extends Jlabel {
Aplicando uma alternativa ao MVC
LI STAGEM 19.1 VCard.java (continuao)
J
J
publiC Ca rdView( String image ) I
setlmage( image )i
setBackground( Co l or.white li
setOpaque( true );
J
public void changed() {
setI mage( get lmage() )j
J
private void set l mage( String image ) {
J
java . net.URL url z this .getClass().getResource(image l i
Imagelcon icon new ImageIcon(url l i
setI con( icon l:
461
Essa implementao de VCard muito parecida com aquela apresentada anlerionnente, com ex-
ceo da classe de apresentao interna. Na criao, VCard cria e contm um modo de apresent a-
o de si mesmo.
Voc tambm notar que o novo atri bul a agora fica completamente encapsul ado dentro de
VCard. Para lima entidade externa exibir a imagem, ela precisa solicitar um modo de visualizao
a VCard. Alm disso, quando a carta virada, VCa rd di z automaticamente ao seu modo de apre-
sentao para que se atualize, chamando changed () no modo de visualizao. Ao contrrio do
padro MVC. todo o controle mantido dentro da prpria abstrao.
VHand semelhant e a VCard. Na cri ao, VHand cria um modo de apresentao de si mesmo. A
Listagem 19.2 apresenta a implementao de VHand.
LI STAGEM 19.2 VHand. java
publ i C cl ass VHand extends Hand implements Displayable {
private HandView view new HandView()i
pub 1 i c JComponent v i ewO {
return view;
J
II voc precisa SOb repor addCa rd e reconfigurar para que quando a ~ mudar, a
II al terao se propague para o modo de visualizao
Dia 19
LISTAGEM 19.2 VHand.java (continuao)
J
public void addCard{ Ca rd card ) I
super.addCard( card );
view.changed();
J
public void reset() (
super . reset () ;
view.changed();
J
private class HandView extends JPanel (
public HandView() (
J
J
super{ new Fl owLayou t(FlowLayout . LEFT ) ,;
setBackground{ new Color{ 35 . 142. 35) ,;
publiC void changed() (
removeAll ();
J
Iterator 1 getCards O;
while{ i.hasNext() ) (
J
VCard card (Vcard) i .next() ;
add( card . view() ,;
revalidateO;
Assim como VCard, VHand diz ao seu modo de visualizao para que se atualize quando VHand
mudar.
Implementando VBetti ngPl ayer
o conceito por trs de VBet ti ngPl ayer o mesmo de VHa nd e VCard. A Li stagem 19.3 apresenta a
implement ao de VBett i ngPl ayer.
LI STAGEM 19.3 VBettingPlayer.java
publi c abstract class VBettingPlayer extends BettingPlayer implement s
Displayabl e (
private BettingV1ew v1ew;
publi C VBettingPlayer( String name, VHand hand, Bank bank ) {
Aplicando uma alternati va ao MVC
LISTAGEM 19.3 VBettingPlayer.java (continuao)
}
supere name. hand. bank )i
}
publi c JComponent view() {
if(view z. null ) I
}
view new BettingView( (VHand)getHand() );
addLi stener( view ) ;
return view;
pri vate class BettingView extends JPanel implements Pl ayerListener I
private TitledBorder border ;
}
public BettingView( VHand hand ) {
}
supere new FlowLayout( Fl owLayout. LEFT ) ) :
buildGUI( hand.view() );
publ ic void playerChanged( Player p ) {
}
St r ing name VBettingPl ayer.this.getName():
border.setTille( name );
repaint()i
publi c void playerBusted( Player p ) {
}
}
String name VBettingPlayer. t his.getName() ;
border . setTitle( name + M BUSTED!!") i
repaint():
II o resto dos mtodos PlayerListener foi cortado por brevidade
II todos eles seguem o mesmo padro : vej a a listagem completa no
II cdigo-fonte
private void bUildGUI( JComponent hand ) {
}
border new TitledBorder{ VBettingPlayer.this.getName() ) ;
setBorder( border ) i
set8ackground( new Color( 35 . 142. 35 ) ) :
border.setTitleCol or( Col or.bl ack ) ;
add( hand ):
Dia 19
VBetti ngPl ayer cri a seu modo de visualizao e o configura como um receptor. Quando o joga-
dor muda, o modo de visuali zao sabe at ualizar-se automaticament e. De interesse o mtodo
bUl l dGUI (). O mtodo bui IdGUI () configura o modo de visualizao.
Voc notar que, em vez de pegar cada carta na mo e construir um modo de visualizao, Bet-
t i ngView simplesmente pega o modo de visualizao de VHand e o insere em si mesmo. VHand ge-
renciar a exibio das cartas. Tudo que Bett i ngView tem de fazer inseri r o modo de
visualizao em si mesmo e manter o status do ttulo atuali zado.
Implementando VBl ackjackDea 1 er
VB I ackjackDeal er funciona exatamente como VBett i ngPI ayer. A Listagem 19.4 apresenta a im-
pl ement ao de VBlackjackDeal er.
LI STAGEM 19.4 VBlackjackOealer . j ava
publ ic class VBlackjackDealer extends BlackjackOealer implements Oispl ayabl e {
private Oeal erView view;
publ iC VBlackjackDealer ( String name , VHand hand , Oeckpile cards ) {
supere name , hand , cards );
J
publi c JComponent view() {
if( view nul l ) (
J
J
view E new Oeal erView( (Vhand) get Hand() }:
addLi stener( view l i
return viewi
private TitledBorder border i
public DealerView( VHand hand ) {
J
supere new FlowLayout( Fl owLayout.LEFT ) ) i
String name VBlackjackOealer.this.get Name() ;
borde r new TitledBorder( name l :
setBorder ( border );
setBackground( new COlor(35. 142. 35 ) );
border.set TitleColor( Color.bl ack ) ;
add( hand.view() li
repaintO:
publ ic void playerChanged( Pl ayer p } {
Aplicando uma a lternativa ao MVC
LI STAGEM 19.4 VBlackjackOeal er . java (continuao)
}
}
String name z VBlackjackDealer.this.getName();
border.setTitle( name ):
repaintO;
public void playerBusted( Player p ) {
}
}
St ring name VBlackjackDeal er.this .getName();
border.setTitle( name + BUSTEO!!" };
repaintO;
II o resto dos mtodos Playerlistener foi cortado por brevi dade
II todos eles seguem o mesmo padrao: veja a listagem completa no
II cdigo- fonte
Dea 1 erVi ew recebe as alteracs cm vaI ackjackDea 1 er. medida que essas alteracs ocorrem,
o modo de visualizao atualiza seu ttulo. VHand cui da de manter o modo de visual izao da car-
Ia aluali zado.
Implementando GUIPlayer
Todos os aspectos no relativos a GUI da classe GUIPlayer so iguais queles apresentados on-
tem. Assim como as outras classes da camada de abstrao, GUIPlayer defi ne urna classe de
apresentao interna.
Essa classe com bina as classes Opt i onVi ew e Opt 1 onV i ewCont ro 11 er do Captulo 18. O cdigo de
apresentao no to diferente das classes de modo de visualizao e controle originais. Para
ver a listagem completa, faa download do cdigo-fonte do dia de hoje, no endereo www.sams-
publishing. com.
Reunindo tudo com o Controle
A ntes de criar o controle, voc precisa criar uma factory de jogador. A Listagem 19.5 apresenta a
implementao de VPl ayerFactory.
LI STAGEM 19.5 VPlayerFactory.java
public class VPlayerFactory I
private VBlackjackDealer dealer;
private GUIPlayer human;
private Deckpile pile:
Dia 19
LISTAGEM 19.5 VPlayerFactory.java (continuao)
}
publiC VBlackjackDealer getDealer() {
II cri a e retorna apenas um
}
;t( dealer null } (
}
VHand dea l er_hand = getHand() ;
Deckpi l e cards z getCards();
dealer new VBlackjackDealer( "0ea l er R. dealer_hand . cards }:
return dealer:
publiC GUIPlayer getHuman() (
II cr ia e retorna apenas um
if( human a. null ) (
}
}
VHand human_hand getHand() ;
Bank bank new Bank( 1000 );
human new GUIPlayer( "Human". human_hand . bank. getDealer()}:
return human;
publ i C Deckpile getCards() {
}
II cria e retorna apenas um
if( pile null } (
}
pile new Oeckpi l e();
for( int i O; i < 4; i ++) (
pil e.shuffleO ;
}
Oeck deck = new VOeck() ;
deck.addToStack( pile ) ;
plle.shuffleO;
re turn pile;
private VHa nd getHand() (
return new VHand():
}
VPlayerFact ory garante que VBlackjackOea ler e GUI PI ayer sejam inslanciados corretamenle. A
Listagem 19.6 apresenta o mtodo setup() de BlackjackGUI: o cont role.
Apli cando uma alternativa ao MVC
LI STAGEM 19.6 O mtodo setUp() do control e BlackjackGUI
public class Blackj ackGUI extends JFrame {
I
II CORTE !! parte do cdigo omitido por brevidade
private JPanel pl ayers z new Jpanel( new Gridlayout( O, 1 ) )i
private void setupO {
I
VBlackjackOealer dealer z factory.getOealer();
GUIPlayer human facto ry.getHuman():
dealer . addPlayer( human );
players.add( dealer.view() );
pl ayers.add( human.view() ) ;
getContentPane().add( players, Borderlayout.CENTER );
467
setUp () simplesmente recupera cada jogador, adiciona seus modos de vi suali zao em si mesmo e
conecta a banca aos jogadores. Compare isso com a Listagem 19.7, o mtodo setup() de ontem.
LISTAGEM 19.7 O mtodo setUp() de MVC BlackjackGUI
priva te voi d setUpO {
I
Blackj ackOeal er dealer getOealer() ;
PlayerView vI getPlayerView( dealer );
GUIPl ayer human getHuman();
PlayerVi ew v2 getPlayerView( human );
PlayerView [] views - { vI, v2 );
addPlayers( views ) ;
deal er.addPlayer( human );
addOptionVi ew( human , dealer li
Parece que simplesmente soli citar um modo de visualizao da abstrao muito mais simples
do que criar e juntar os vrios modos de visualizao da verso MVC.
Dia 19
Resumo
Hoje, voc viu uma alternativa ao MVC. Se seu sistema relat ivamente estvel e tem uma UI
bem definida, a estratgia PAC pode oferecer uma soluo mais elegante do que o MVC.
Mesmo que voc precise suportar vrias interfaces, a lio de hoje mostra como possvel usar
herana para separara camada de abstrao da funcionalidade bsica do sistema. Assim, para su-
portar vrias interfaces, voc precisa apenas criar uma subclasse para cada ti po de apresentao.
Perguntas e respostas
P Se o PAC oferece lima escolha melhor, por que fizemos a implementaio MVC?
R O PAC simpl esmente oferece uma alternati va. Uma no necessariamente melhor que a
outra. Trata-se apenas de uma deciso de proj eto.
O rato que voc encontrara o MVC em muitas implementaes. Voc pode encontrar o
PAC, mas mui to menos provvel. Assim, abordar o MVC pri meiro mai s prtico. Pes
soalmente, tendemos a privilegiar o PAC.
Tenha as duas opes em mente. O que voc nunca quer fazer codificar sua lgica cor-
porativa (classes como BettlngPl ayer) diretamente como um componente da GUI. Por
exemplo, Bett i ngPl ayer nunca deve estender JComponent (ou algum outro componente
da GUI) di retamente. O MVC e o PAC fornecem um mecanismo que evita mi sturar seu
modelo e a GUI. Os padres apenas adotam estratgias diferentes. O que voc escolhe
depende de seu projeto e de sua equi pe de projeto.
Workshop
As perguntas e respostas do teste so fornecidas para seu melhor entendimento. Veja as respos
tas no Apndice A, "Respostas".
Teste
I. Quais so as trs camadas do padro de projeto PAC?
2. D uma breve descrio de cada uma das camadas do PAC.
3. Como voc pode usar herana para desacoplar a OUI das classes de sistema subjacentes?
4. Antes de usar o PAC, quais caractersticas seu projeto deve exibir?
5. Mesmo que voc usasse PAC portada esta lio, como ainda poderi a fornecer uma UI de
linha de comando para o sistema?
6. Como o padro factory foi usado neste captulo?
Aplicando uma a lternati va ao MVC
Exerccios
I. Faa downl oad do cdigofonte da iterao de hoje. Quando voc ti ver a cdigo, com pi
le-o, faa-o funcionar executando 81 ackj ackGUI e, depoi s, tent e entender como ele funci
ona. Ter um entendi mento talai do cdigo exigir algum tempo e pacincia.
2. O Exerccio 2 do Captulo 17 pediu para que voc acrescentasse aposta em dobro no jogo
vi nlecum. Voc precisa adicionar aposta em dobro no j ogo novamentc. Desla vez, adi-
cione-a na verso grfi ca do jogo que voc carregou pordownl oad para o Exerccio 1.
SEMANA 3
DIA
Divertindo-se com o jogo
vinte-e-um
Nos hi mos dias, voc trabalhou em um projeto de POO bastante intenso. Hoje, voc vai dar o
troco e se divertir com o jogo vinte-c-um, usando polimorfismo para adicionar vrios jogadores
no-humanos ao j ogo. Voc tambm ver como a 00 se presta para fazer simuladores.
Hoje voc aprender como pode:
Usar polimorfismo para adicionar jogadores no j ogo vinte-e-um
Usar 00 para criar simuladores
Divertindo-se com o polimorfismo
o jogo vinte-c-um possibi lita que at sete jogadores joguem em determinado momento. At
agora, o j ogo que voc criou inclua apenas um jogador humano e a banca. Fel izmente, O poli-
morfismo permite que voc adicione jogadores no-humanos no jogo.
Criando um jogador
Para cri ar um novo jogador no-humano, basta criar uma nova classe que herde de Betti ngPla-
yer. Tudo que sua nova classe precisa fazer e implementar os dois mtodos abstratos a seguir:
I 472 Dia 20
public bool ean hit()
public void bet()
o componamento que voc fornecer para esses dois mtodos delenni nar como oj ogador joga-
r na sua vez. Voc no presar alterar quaisquer estados ou sobrepor quaisquer outros mto-
dos. Os estados padro sabem corno usar os mtodos que voc implementa.
Quando voc tiver acabado de defi nir a nova classe de j ogador, pode alterar B1 ackjackGUI para
criar o jogador e adicion-lo no jogo.
o jogador seguro
Vamos criar um novo jogador: SafePl ayer. SafePl ayer nunca recebe mai s cartas e sempre apos-
ta a menor quantia permitida. A Listagem 20.1 apresenta a definio de SafeP1 ayer.
LISTAGEM 20.1 SafeP1ayer . java
publi c class SafePlayer extends BettingP1ayer {
}
publ iC SafeP1ayer( String name , Hand ha nd, Bank bank ) {
supere name , ha nd, bank ) ;
}
public boolean hit() {
return false ;
}
publiC void bet() {
getBank().pl acel OBet() ;
}
Voc notam que hi t () sempre retorna fal so; SafePlayer nunca receber mais canas. Do mesmo
modo, SafePlayer sempre chama placel OBet O.
Adicionando SafePlayer na GUI
Adicionar Sa fePl ayer no jogo relativamente si mples. Primeiro, adic ione o seguinte mtodo em
BlackjackGUI:
LI STAGEM 20.2 O mtodo getSafePlayer()
private Player getSafePlayerO {
II retorna o quanto for sol i citado
Ha nd safe_hand new Hand();
Bank safe_bank new Bank( 1000 ) ;
Divertindo-se com o jogo vinte-e-um
LI STAGEM 20.2 O mtodo getSafePlayerO (cont inuao )
return new SafePl ayer ( MSafe", safe_hand , safe bank );
,
getSafePl ayer O um mtodo factory que instanci a objetos Safe Pl ayer. Quando voc ti ver o
mtodo, pode atualizar setUp() para que ele adicione o novo jogador no jogo. A Listagem 20.3
apresenta o mtodo setUpO atuali zado.
LISTAGEM 20.3 O mtodo setUp() atualizado
priva te void setUp() {
,
BlackjackDealer dealer getOea ler( ) ;
PlayerVi ew vI getPlayerView( dealer ) ;
GUIPlayer human getHuman() ;
PlayerView v2 getPlayerView( human ) ;
Player sa fe K getSa fePlayer ();
Pl ayerView v3 getPlayerView( safe );
PlayerVi ew {J views z I vI , v2, v3 };
addPl ayers( views );
dealer.addPlayer( human );
dealer.addPlayer( sa fe );
addOptionView( human, deal er );
Voc tambm desejar alterar o mtodo principal da GUI, para que ele torne ajanela um pouco
maior, a fim de que o novo j ogador possa caber. A Fi gura 20.1 ilustra o novo jogador, conforme
ele aparece na GUI.
Aqui, o j ogador adi cionado corno um segundo jogador que joga aps o ser humano. Nada o im-
pede de deixar que o jogador no-humano jogue primeiro.
Aperfeioamento
Voc pode adicionar qualquer nmero e tipo de objeto Bett ; ngPl ayer no jogo. Quando o nmc-
ro de opes de jogador ficar maior, tal vez voc queira fornecer ao usurio uma caixa de dilogo
que permita configurar a mistura de jogadores. No mnimo, voc desejar tornar o mtodo
setUpO protegido, para que subclasses possam sobrepor o mtodo. Quando protegido, voc
pode escrever subclasses que criem j ogos com diferentes misturas de jogadores.
FIGURA 20.1
A CUI comeI/do Irs
jogadores.
POO e simulaes
Dia 20
Confonne mencionado em uma lio anterior, quando voc escreve um sislema de POO, na ver-
dade est escrevendo um simulador vivo de algum problema real. Nesla semana, voc escreveu
um sistema que simula o jogo vinte-e-um.
Al aqui , o jogo lem sido centrado em um jogador humano. Voc quer uma pessoa com a qual
possa jogar o jogo, embora o sistema no se preocupe se h um ser humano jogando ou no. Para
o sislema, todos os jogadores so objetos Plilyer. O sistema cuida apenas que existam objetos
Player.
Criando di ferentes tipos de jogadores e adicionando-os ao sistema, voc pode ter um jogo vin-
te-c-um que jogue sozinho, sem interao humana: um si mulador do jogo vinte-e-um.
Um simulador do jogo vinte-e-um pode ser til por vrios motivos. Talvez voc qui sesse criar
jogadores que util izassem diferentes estratgias para ver quais delas func ionam melhor.
Talvez voc esteja fazendo pesqui sa de IA e queira escrever uma rede neural que aprenda ajogar
perfeitamente um jogo vinte-e-um. Voc pode usar um simulador do jogo vinte-c-um para atin-
gir todos esses objetivos.
No capt ulo e nos exerccios de hoje, voc vai criar vrios jogadores para sabcrse pode ganhar da
banca com o passar do tempo.
Os jogadores do jogo vinte-e-um
Voc j viu um objeto SafePlayer. Ser interessante ver como ele se desempenha com o passar
do tempo. Alm de SafePl ayer, vamos defi nir:
Divertindo-se com o jogo vinte-e-um
FlipPlayer: um j ogador que alterna entre receber mais cartas e parar.
OneHaplayer: um jogador que sempre recebe mais cartas a cada vez.
SmartPl ayer: um jogador que para com qualquer mo maior do que I I.
NOTA
Voc pode notar a falta de casos de uso para esses jogadores. Como exerclcio,
tal vez voc queira trabalhar nos casos de uso para os jogadores. Entretanto,
um principio deste livro t em sido realizar apenas a quantidade de anlise que
f aa sent ido e valorize seu entendimento do problema. Em nossa opinio, os
casos de uso no ajudariam no seu entendimento neste caso e pareceria mais
com a cri ao de documentao simplesmente.
Implementando FHpPlayer
A implementao de Fl i pPl ayer um pouco mais complicada do que a de SafePl ayer. A li sta-
gem 20.4 apresenta a implementao de Fl i pPl ayer.
liSTAGEM 20.4 FlipPlayer . java
publi c cl ass FlipPlayer extends BettingPlayer (
}
private boolean hit false;
private boolean should_hit_once : false;
publ ic Fl ipPlayer ( String name , Hand hand, 8ank bank ) (
super( name , hand, bank ) ;
}
public boolean h1t() (
}
if( should_hit_once &&l hit ) {
hit .. true;
return true;
}
return false;
publiC yoi d resetO (
super. reset() ;
hit fal se;
should hit once = lshould hit once ;
-
}
publ ic yoid bet() I
getBank().pl acelOBet()i
}
Dia 20
F1 i pPl ayer precisa manter dois fl ags booleanos. Um flag informa ao j ogador se ele deve receber
mais cartas toda vez e o outro controla se o j ogador recebeu mais cartas durante essa rodada. Os
flags garantem que o jogador s receba mais cartas uma vez a cada outro jogo.
Para penniti r que toda a lgica booleana funcione, voc precisar sobrepor O mtodo reset () ,
para alternar o estado booleano shoul d_ hi t_once. Sobrepor reset O dessa maneira garante que
o jogador s receba mais cartas a eada outro j ogo.
Implementando OneHitPl ayer
OneHi tPl ayer semel hante na implementao a Fl i pPl ayer. Ao contrrio de Fl i pPl ayer, One-
Hi tPl ayer receber mais cartas a cada jogo, mas apenas uma cana. A Listagem 20.5 apresenta a
im plementao de OneHi tPl ayer.
LISTAGEM 20.5 OneHitPl ayer. java
publ ic cl ass OneHitPlayer extends BettingPlayer {
}
pr;vate bool ean has_hi t z false ;
publ ic OneHitPlayer( String name , Hand hand , Sank bank ) {
supere name, hand. bank )i
}
publ ic boolean hitO (
if( !has_hit ) {
has_hit true;
return true;
}
return false j
}
public vo1d reset() {
super.reset() j
has hit false;
}
publiC voi d bet() (
getBankO . placelOBet();
}
Novamente, voc precisa sobrepor reset () para que ele li mpe o flag has_ hi t. Esse fl ag garante
que o jogador s receba mais uma carta na rodada.
Divertindo-se com o jogo vinte-e-um
477
Implementando SmartPl ayer
Sma r lPl ayer tcm uma implementao muito si mples. A Listagem 20.6 apresenta a implementao.
LISTAGEM 20.6 SmartPl ayer . java
public cl ass SmartPlayer extends BettingPlayer (
J
publiC SmarlPlayer( String name , Hand hand, Bank bank ) (
supere name , hand , bank ):
J
public boolean hit() (
J
if( get Hand() . total() > II ) (
return false :
J
return true :
publ ic void bet() (
getBank().placeIOBet():
J
SmartPl aye r veri fi ca o total de seu objeto Hand. Se o total for maior que onze, o j ogador pra. Se
for menor, o j ogador recebe mais cartas.
Configurando o simul ator
Para transformar o jogo em um simulador, voc pode simpl esmente alterar o mtodo principal
encontrado na classe Bl ackjack. Aqui , copiaremos e renomearemos a classe como Bl ackjack-
Si m. A Listagem 20. 7 apresenta o novo si mulador.
liSTAGEM 20.7 BlackjackSim. java
publi c class BlackjackSim {
publ ic stat1c void main( Stri ng (] args ) ) (
Console. INSTANCLpr intMessdge( "How many t imes should the simulator
play? " l:
String response Consol e. INSTANCE.readlnput( "invalid" ):
int loops = Integer.parselnt( response ) :
Oeckpile cards new Deckpi l e() ;
Dia 20
LISTAGEM 20.7 8lackjackSim. java (continuao)
for( int i .. O: i < 4: i ++ ) (
cards . shuffle() :
J
Oeck deck .. new Deck{};
deck.addToStack( cards );
cards.shuffle();
II cria uma banca
Hand dealer hand .. new Hand() ;
BlackjackDealer dealer .. new BlackjackDealer( "Oealer", dealer_hand ,
cards ) ;
II cria um OneHit Player
Ba nk one_bank .. new Bank( 1000 ) i
Hand one_hand .. new Hand(l;
Player oplayer " new OneHitPl ayer( "OneHit", one_hand , one_bank l i
II cria um SmartPlayer
Bank smart_bank .. new Bank( 1000 ) ;
Hand smart_hand new Hand() i
Player smpl ayer .. new SmartPlayer{ "Smart" , smart_hand, smart_bank l;
II cria um SafePlayer
Bank safe bank .. new Bank( 1000 l i
Hand safe_hand .. new Hand();
Player splayer .. new SafePl ayer ( Sa fe", safe_hand, safe_bank li
II cria um FlipPlayer
Bank flip_bank .. new Bank( 1000 } i
Hand flip_hand .. new Hand() i
Player fplayer .. new FlipPlayer( "Flip" , flip_ha nd, f l ip_bank li
II rene todos os jogadores
dealer.addLi stener( Console .I NSTANCE l i
oplayer.addListener( Consol e.INSTANCE l i
dealer . addPlayer{ oplayer }i
splayer,addListener( Console . INSTANCE l i
dealer.addPlayer( splayer li
smplayer.addListener( Console . INSTANCE li
dealer.addPl ayer( smplayer li
fplayer.addlistener( Consol e. INSTANCE li
dea ler.addPl ayer( fplayer li
i nt counter .. O;
Divertindo-se com o jogo vinte-e-um
LI STAGEM 20.7 8lackjackSi m. java (continuao)
J
J
whlle( counter < loops ) {
dealer . newGame();
counter ++;
J
o simulador primeiro o consultar quanto ao nmero de vezes a j ogar. Quando ele tiver essa in-
formao, criar um objeto 81 ackj ac kDea 1 er, um OneHitPl ayer, um Sma rtPl ayer e um FI l pPl a-
yer. Ento, ele conectar esses jogadores no Console e os adi cionar na ba nca.
Quando tiver terrn inado a confi gurao, ele jogar o jogo pelo nmero de vezes que voc tiver
especifi cado.
Os resultados
Aps executar o simulador algumas vezes, com 1000 jogos por execuo, torna-se fc il ver
como os j ogadores se comportam. Aqui esto os resultados obt idos, do maior para o menor:
SmartPl ayer
SafePlayer
FhpPlayer
OneHHPlayer
Parece que, desses quatro j ogadores, permanecer com uma mo que ma ior que II a melhor
estratgia. Na verdade, SmartPl ayer foi o unico jogador a ficar com dinhei ro aps os 1000

Jogos.
SafePl ayer vem em um segundo lugar prximo, mas acabou perdendo di nheiro. E, faa o que fi-
zer, no receba mai s cartas. Esses jogadores perderam mais dinheiro do que ti nham em seu pote
inicial.
NOTA
Resumo
Nenhum desses jogadores acabou com mais dinheiro do que comeou. Os j o-
gadores s diferiram na vel ocidade com que perderam seu dinheiro.
Voc aprendeu uma lio importante hoje: no siga nenhuma das estratgias de hoje ao jogar
vinte-c-um. Voc perder todo seu dinheiro!
Dia 20
Voc tambm viu pela primeira vez como o polimorfismo permite escrever software prova do
futuro. Voc pode int roduzi r tipos de jogador no sistema, sem ter de alterar o sistema bsico.
Esses tipos dejogador nem mesmo eram considerados, quando vocconslruiu o sistema inicial.
Perguntas e respostas
P H um motivo pclo qual voc no tcnha usado a CUI como base deseu simulador?
R Poderamos ter usado a GUI, em vez do console. Poderia ter sido interessante ver osjo-
gos ci ntilarem. Nonnalmente, um simulador no tem UI. Em vez disso, o simulador mos-
trar algumas estatsti cas no final.
Tambm existem limites prticos para uma GU!. As GUls demoram alguJ1ltempo para
alUa li zar. Jogar 1000 jogos visuais poderia demorar um pouco ma is do que jog-los na li -
nha de comando.
Vrias verses de Swing tambm sofrem de estouro de memria. Esses estouros poderiam
surgir e atrapalh-lo, caso voc executasse 10.000 jogos visuais.
Para propsitos de teste, entretanto, voc poderi a considerar o uso da GUI como base
para o simul ador.
Workshop
As perguntas e respostas do teste so forneci das para seu melhor entendimento. Veja as respos-
tas no Apndice A, " Respostas".
Teste
I. Como o polimorfi smo permitiu jogar o jogo sem um jogador humano?
2. Qual estratgia de aposta voc nunca simular?
Exerccios
I. Faa download do cdigo-fonte da iterao de hoje, a partir do endereo www,samspu-
bllshing . com. O cdigo est dividido em quatro diretrios separados: gui o simulation,
exerci se 2 e exercise 3.
- -
9U1 contm uma GUI que tem um jogador humano e um SafePl aye rU.
simul ation cont m o cdigo de simulao. s imul ati on tem os seguintes jogadores: One-
Hi tPl ayer, Fl i pP1 ayer, Sa fePl ayer e SmartPl ayer.
exerci se 2 e exerci se 3 cont m os arquivos que voc precisar para os exerccios 2 e 3,
- -
ass im como as solues.
Di vertindo-se com o jog o vinte-e- um
Estude o cdigo de gui e simulat or. Tente entender como tudo funciona. Quando voc
t iver feito isso, complete os exerccios 2 e 3.
2. O download cont m todos os arqui vos iniciais que voc precisar p<1ra completar este
exerccio. Os arqui vos iniciais fazem alteraes no mtodo hi t declarado pela primeira
vez em PI ayer.
As alteraes adicionam Dea ler como um parmetro. O mtodo getUpCard foi adi ciona-
doem Oea l er para que voc possa obter a cart a aberta de Oea I er. Em urnjogo vi nt e-e-um
real , os jogadores podem ver a carta aberta da banca. Voc pode usar essa informao
para tornar alguns movimentos mais inteli gentes.
Para este exerc cio, escreva um ou dois j ogadores novos, que baseiem sua deciso de re-
ceber mais cartas em seu prprio total, assim como na carta aberta da banca. Aqui esto
duas sugestes, mas sinta-se livre para impl ementar seus prpri os j ogadores, adici o-
n- Ias 110 simulador e ver como eles reagem:
KnowledgeablePlayer
Knowl edgeabl ePI ayer deve basear a dec iso de se vai ou no receber mais cartas de acor-
do com as seguintes regras:
Independent ement e de tudo, se o tota l da mo for maior que 15, pra.
Se o total da mo for I I ou menor, recebe mais cartas.
Se a mo for 15 ou menos e maior que 11 , baseia a deciso de receber mais cartas na cart a
da banca. Se a carta da banca for maior que 7, recebe mais cartas; caso contrrio, voc
deve parar.
OptimalPlayer
Opt ima 1 PI ayer est t11 0 prximo da perfei o, que voc pode no consegui r diferenciar
ent re mos fce is e difceis. (A difere nciao deixada como excrccio para o leitor).
Opt i ma I PI ayer deve basear a deciso de se vai a li no receber mais carias nas seguintes
regras:
Se o total da mo for maior ou igual a 17, pra.
Se o tota l da mo for 11 ou menos, recebe mai s cartas.
Se o total da mo for 16, baseia a deciso de receber mais cartas ou parar na carta aberta
da banca. Se a carta aberta for 7, 8 Oll 9, recebe mais cartas; caso contrrio, pra.
Se o total da mo for 13, 14 ou 15, baseia a deciso de receber mais cartas ou parar na car-
ta aberta da banca. Se a carta aberta for 2, 3, 4, 5 ou 6, pra; caso cont rri o, recebe mais
cart as.
Se o tota l da mo for 12, baseia a deciso de receber mais cartas ou parar na carta aberta
da banca. Se a carta aberta for 4, 5 ou 6, pra; caso cont rrio, recebe mai s cartas.
Dia 20
3. O downl oad cont m todos os arquivos iniciais necessri os paravoc complelareste exer-
cicio. Os arquivos iniciais adicionam suporte para dobrar a aposta nas classes. Alm dis-
so, o novo mtodo doubleOown agora aceita um objeto Oealer como argumento.
As alteraes adicionam Dealer como um parmetro em doub 1 eDown. O mtodo getU-
pCard foi adicionado em Dealer para que voc possa obter a carta aberta de Dea 1 er. Em
um jogo vinte-e-um real, oj ogador pode ver a carta aberta da banca. Voc pode usar essa
informao para tornar alguns moviment os mais inteligentes.
Para este exercicio, escreva um ou dois j ogadores novos que baseiem sua deciso de re-
ceber mais cartas ou dobrar em seu prprio lotai, assim como na cart a aberla da banca.
Aqui esto duas sugestes, mas sinta-se I i vre para impl ementar seus prprios jogadores,
adicion-los no simul ador e ver como eles se comportam:
KnowledgeablePlayer
Para receber mai s cartas, siga as regras delineadas no Exerccio 2.
Para dobrar, siga estas regras:
Se o lotai da mo for 10 ou 11, dobra. Em todos os outros casos. no dobra.
OptimalPlayer
Para receber mais cartas, siga as regras delineadas no Exercicio 2.
Para dobrar, siga estas regras:
Se o total da mo for 1 I, sempre dobra.
Se o total da mo for 10, baseia a deciso de dobrar na carta aberta da banca. Se a carla
aberta for 10 ou um s, dobra; caso contrrio, no dobra.
Se o total da mo for 9, baseia a deciso de dobrar na carta aberta da banca. Se a cart a
aberta for 2, 3, 4, 5 ou 6, dobra; caso contrrio, no dobra.
Em lodos os outros casos, no dobra.
SEMANA 3
DIA
o ltimo quilmetro
Parabns! Voc chegou ltima li o deste livro. Voc percorreu um longo caminho. Agora,
voc deve ler a base necessria para ter xito ao continuar seus estudos de POO.
l-laj e, elimi naremos algumas arestas e depois o enviaremos por seu cami nho!
Hoje voc aprender sobre:
Refazer o projeto do jogo vinl e-c-um para reutili zar em outros sistemas
As vantagens que a POO trouxe para O j ogo vinte-c-um
Realidades do selor que podem impedi r sol ues totais 00
Amarrando as pontas
Voc abordou muitos assuntos durante as trs ltimas semanas. Voc comeou considerando a
tcoria bsica da 00 e chegou em um proj eto inteiramente baseado cm POO. Agora, voc j deve
ter uma boa idia do que POO realmente significa.
Antes de concluirmos o livro, ent retanto, restam trs problemas para abordar:



Refazer o projeto do j ogo vinte-e-um para reutil izar em outros sistemas
Um levantament o das vantagens que a roo trouxe para o sistema de j ogo vinte-c-um
Uma palavra sobre as realidades do selar e Poo
Dia 21
Refazendo o projeto do jogo vinte-e-um para reutilizao
em outros sistemas
Existe um pequeno problema relacionado ao projeto dojogo vinte-c-um que precisamos exami -
nar. Esse problema no tm impacto sobre o jogo vinte-c-um, mas poderia ter impacto negativo
em outro sistema 00, se c[c reutilizar o projeto incorretamente.
No Dia [5, voc viu duas solues altemativas. Em uma soluo, a banca faz um lao por seus
jogadores dizendo a cada um para que jogue depoi s que o j ogador anteri or tcnn inar. Ento, voe
viu uma outra estratgia mais baseada em objetos para o lao do jogo.
Em vez da banca percorrer osjogadores um por um e dizer a eles o que fazer, a banca 00 inicia-
va cada jogador c esperava que ele dissesse quando tinha acabado de jogar.
Isso ofereceu uma soluo mais limpa, poi s voc deixava por conta do jogador dizer banca
quando tivesse terminado - somente ento que a banca continuava. Tambm se viu que esse
projeto era absolutamente necessrio para a GUJ funcionar; caso contrri o, um jogador humano
retornaria instantaneamente e, se a banca estivesse fazendo o lao, diria ao prximo jogador para
prosseguir. O jogador humano nunca teria sua vez na estratgia procedural!
o problema do projeto
Existe um pequeno problema na estratgia delineada nas lies. Vamos acompanhar as chama-
das de mtodo em um jogo onde existe um jogador e uma banca. Os dois jogadores param duran-
te sua vez.
A Listagem 21 . 1 representa um acompanhamento de Iodas as chamadas de mtodo no jogo. A
pilha termina quando um mtodo retorna.
LISTAGEM 21. 1 Um acompanhamento da pilha de mtodo
BlackjackSim.main
81ackjackDealer . newGame
PI ayer. pI ay
81ackjackOealerSOealerCollecting8ets . execute
Player.play
8et tingPlayerSBetti ng.execute
8lackjackOealer. done8etting
Player . play
81ackjackDeal erSOealerCol lect i ng8ets.execute
81ackjackDeal erSOeal erOeal ing.execute
81 ackj ackOealerSDealerWaiting.execute
Player .play
PlayerSPlaying. execute
Pl ayerSStanding.execute
Bl ackjackOealer. standing
o ltimo quil metro
LISTAGEM 21 .1 Um acompa nhament o da pilha de m todo (continuao)
Player . play
BlackjackOealer$DealerWaiting.execute
PlayerSPlaying.execute
BlackjackDea ler$DealerStanding
o problema suti!. Nenhum dos mtodos retoma at que a banca termine sua vez! Os mtodos
chamam-se uns aos OUlros rec ursivamente. Assim, por exemplo, o mtodo noti fyChanged da
Listagem 21.2 no ser executado at que o jogo corrente tennine.
LI STAGEM 21 .2 Um mtodo que no ser chamado antes que o jogo corrente termine
publ ic void execute( Dealer dealer ) {
}
if( hit( dealer) ) {
dealer . hit( Player.this ):
I el se (
}
setCurrent State( getStandingSt ate() );
notifyStandingO:
current_state.execute( dealer ) ;
II transio
II no ser chamado at que a pilha se desenrole!! !!
notifyChanged();
No jogo vinte-e-um, isso no problema, pois existe um limite de sete jogadores e a pilha de
chamada de mtodos se desenrola aps cada jogo. Voc tambm pode codificar cuidadosamente
no caso de problemas como o demonstrado na Listagem 21.2.
Entretanto, imagine um si mulador com centenas ou milhares de objetos que seguem o projeto do
jogo vinte-e-um. Se esses objetos chamarem um ao outro recursivamente, mesmo que a pilha fi-
nalmente se desenrole, voc poderia acabar ficando sem memria. De qualquer modo, cada cha-
mada de mtodo alocar mais memria. Se voc seguir esse projeto inalterado, seu sistema no
funcionar ou exigi r muito mais memri a do que o absolutamente necessrio.
Costurando uma soluo com linhas de execuo (threadsl
Felizmente, existe lima soluo: as linhas de execuo (threads). Embora uma di scusso com-
pleta sobre o uso de linhas de execuo esteja bem fora dos objctivos deste livro, voc vai ver
como pode us-Ias para resolver o problema da chamada de mtodos rapi damente.
Dia 21
NOTA
Quase todo sistema no-trivial compartilhar duas caractersticas:
Eles usaro linhas de execuo
Eles tero lgica de estado
O sistema de j ogo vinte-e-um compartilha essas duas caractersticas.
Uma linha de execuo simplesmente um caminho de execuo atravs de seu programa. At
agora, o sistema do jogo vinle-e-um tem uma (mica linha de execuo. A Figura 21. 1 ajuda a vi-
sualizar essa linha de execuo ni ca.
FIGURA 21.1
O sisfema flojogo l'illle-e-ulII
com lI/IIa llica linha de
e.recll(io.
Sistema do jogo vinte e-um
com uma nica linha de execuAo
Uma linha deexe(:uo
Comoo jogo vinte-e-um usa apenas uma linha de execuo (ele tem somente um linha de execu-
o), essa linha de execuo faz tudo.
O uso de linhas de execuo penni te que voc cri e vrias linhas de execuo atravs de seu pro-
grama. Criando vrias linhas de execuo, seu programa pode fazer muitas coisas diferentes, si-
multaneamente. A Figura 2 1.2 ajuda a visuali zar duas linhas de execuo percorrendo o sistema
do jogo vi nte-c-um.
Usar linhas de execuo no sistema do jogo vinte-e- um pode permiti r que um mtodo retorne
imediatamente. Vamos ver um exemplo si mples de linha de execuo da linguagem Java. A Li s-
tagem 21.3 apresenta urna linha de execuo simples que imprime " Hello Wor l d!".
FIGURA 21.2
O sisfema do jogo l'ime-e-IIIII
COIII mlfiplas linhas de
execlIlio.
Sistema do jogo vinte-eum com
mltiplas linhas de eXBCuAo
"-
- ~
/
"- "-
/
,
Duas li nhas de eXlCuAo
o ltimo quil metro
lISTAGEM21.3 "Hell o Worl d!" com mltiplas linhas de execu!o
publ i c class HelloWorld (
J
publ ic void sayHello() I
System.out.println( "Hel lo Worl d!" };
J
public static void main( String [] args ) I
final HelloWorld hw new HelloWorldO ;
J
Runnable runna ble new Runna bl e() I
publ ic yoid run() {
hw. sayHe11 00 ;
J
J ;
Thread t hread new Thread{ runnab1e ) ;
thread. startO;
System.out. pr intln( "A11 Oone! " ) ;
487
He ll oWorld ela prpria uma classe simples que tem um mtodo: sayHell o. sayHel lo imprime
uma mensagem na linha de comando.
,
E no mtodo main que as coisas ficam interessantes. Pri meiro, esse mtodo instancia e l l ~
Wo r1d. Ento. ele cria uma classe Runnabl e annima. Os objetos Runnab1e tm um mtodo: run.
O mtodo run diz li nha de execuo o que fazer quando for iniciada. Neste caso, ele di r ins-
tncia de He 11 oWor 1 d para que imprima sua mensagem.
Aps cria r Runnable, O mtodo principal instancia um Thread Java. Quando voc cria um objeto
Thread, precisa passl-lo para um objeto Runnab1 e. O mtodo run de Runnabl e diz ao objeto Thread
o qu fazer quando voc disser a Thread para que comece (s tart). A ps iniciar o objelo Thread, o
mtodo ma;n imprime sua prpria mensagem.
Voc pode ficar surpreso quando ver o mtodo princi pal ser executado. A Figura 21.3 apresenta
a sada de He 11 oWor 1 d.
Ao executar He11oWorld, voc ver que "Ali Done" impresso antes de "Hel io World !" a cha-
mada de Thread.star t no bloqueia como outras chamadas de melado. Como star t inicia uma
nova linha de execuo, ele reloma aut omaticamente. Aps chamar st art, voc tem duas linhas
de execuo no programa Hel loWorld. Apenas acontece que o mtodo ma i n impri me sua mensa-
gem antes que a nova linha de execuo tenha uma chance de chamar sayHell o.
Dia 21
FIGURA 21 .3
A saida de He 11 oWor 1 d.
Voc pode usar o rato de que start no bloqueia para corrigir a defi cincia do projeto no jogo
vinte-e-um. A Li stagem 21.4 apresenta um novo estado Wa i ti ng para B1 ackjackDeal er, que ini-
cia cada jogador em sua prpria linha de execuo.
LISTAGEM 21 .4 Dea 1 erWai ti n9 com 1 i nha de execuo
private class DealerWaiting implements PlayerState (
publ ic void handCha nged( ) {
II imposs (vel no estado de espera
}
publ ic void handPlayable () {
II 1mpossfvel no es t ado de espera
}
public void handBlackjack() {
II i mposs (vel no es tado de espera
}
public voi d handBusted() 1
II impossvel no estado de espera
}
public voi d execute( fina l Dealer dealer ) {
if( !waiting_players . i sEmptyD ) {
final P1ayer player z (Player) waiting_players .get( O };
wa i ting_players. remove( player };
Runnable runnable : new Runnable() {
} ;
publ ic voi d run() {
player . play( dealer );
}
Thread thread K new Th read( runnable );
thread. s tart () ;
} el se {
setCurrent State( getPlayingState() );
exposeHand () ;
getCurrentState().execute( dealer };
II faz a transi ao e executa
o ltimo quilmetro 489
LISTAGEM 21 .4 OealerWal ting com 1 inha de execuo (continuao)
}
}
}
Iniciando cada jogador em sua prpria linha de execuo, o mlodo de estado execute de Bl ack-
j ackOea 1 er pode retornar imediatamente, desenrolando assim a pilha. Isso int erpe algumas di-
ficuldades, se voc fi zer um lao com as chamadas de newGame, pois agora newGame retornar
antes que o jogo tenha real mente terminado. Se voc fizer o lao, iniciar outro jogo antes que o
ltimo tenha tcrminado e, ento, enrrentar todos os ti pos de problemas desagradveis. Voc
pode resolver esse problema dizendo a 81 ackjackOeal er quantas vezes deve razer o lao. No fi-
nai de cada j ogo, ele pode verificar se precisa jogar novamente.
NeTA
o uso de linhas de execuo apenas uma maneira de resol ver o problema da
recursividade. Apresentamos uma soluo com linhas de execuo aqui para
que voc as visse um pouco.
O problema do lao/ linha de execuo levanta al gumas preocupaes. Voc
tambm pOderia criar um objeto GameTable que iniciasse e parasse as linhas de
execuo. Ento, Oea 1 er poderia receber o est ado da tabela e distribuir cartas,
receber mai s cartas, efetuar o jogo, etc., com base no est ado. Entretanto, tal es-
tratgia um pouco mais complicada do que simplesmente usar linhas de exe-
cuo para os j ogadores quando eles comeam.
Voc t ambm poderi a se desfazer da recursividade atravs de iterao pelos
j ogadores.
A boa nova que, se voc no fizer o lao, como na GUI, pode usar linha de execuo racilmen-
te, simplesmente mudando o estado de Oea 1 erWai ti n9 de Bl ackjackDea ler! O cdigo-ronte car-
regado por download contem verses com linhas de execuo da aul.
fci l usar linhas de execuo no j ogo vinte-e-um, pois apenas uma li nha de
execuo de jogador executada em dado momento. Voc no tem muitas li -
nhas de execuo de jogador sendo executadas concomitantemente.
O uso de linhas de execuo se torna compli cado quando muitas linhas de exe-
cuo so executadas concomitantemente e compart ilham os mesmos dados!
Identificando as vantagens que a POO trouxe para o
sistema do jogo vinte-e-um
A primeira semana mostrou alguns dos objet ivos e vantagens da POO. Para recapitular, a POO
tenta produzir software que :
1. Natural
2. Confivel
Dia 21
3. Reutilizvel
4. Manutenvel
5. Extensvel
6. Oportuno
A POO trouxe cada uma dessas vantagens para o sistema do jogo vinte-e-um. O sistema do jogo
vinte-e-um ati nge cada um dos objetivos da POO:
Natural : o sistema do j ogo vinte-e-um modela naturalmente um jogo vinte-e-um.


O sistema dojogo vinte-e-um existe nos termos de umj ogo vinte-e-um real . O sistema do
jogo vinte-e-um constitudo de objetos P1 ayer, um 81 ackj ac kDea 1 er, obj etos Ca rd, Deck
e um DeckPile. Corno voc v, o jogo vi nte-c-um uma simulao viva do domnio do
j ogo vinte-e-um.
Confi vel: o sistema do j ogo vinte-e-um confivel.
A travs de uma combinao de testes cuidadosos e encapsulamento, voc cri ou um siste-
ma do jogo vinte-c-um confivel. Como voc isolou conheci mentos e responsabilidades e
os colocou no lugar onde pertencem, pode fazer mel horias no sistema sem se preocupar
com um impacto negativo em partes no relacionadas do sistema.
Relll ili zvel: o sistema do jogo vinte-e-um reutilizvel.
Como esse foi o primeiro jogo de cartas que voc escreveu, no houve muita nfase na es-
crita de uma estrutura dej ogo de cartas abstrata. Em vez disso, voc escreveu um jogo vin-
te-e-um. Como resultado, o jogo no completamente reut ili zvel; entretanto, classes como
Card, Deck e Deckpile podem ser reuti lizadas em praticamente qualquer jogo de cartas.
Alm di sso, muitas das idias do projeto so reutilizveis em muitos problemas. medi-
da que voc escrever mais jogos de cartas, poder abstrair mai s e criar uma estrutura total-
mente reut ili zvel.
Manutenvel : o sistema do jogo vinte-e-um manutenvel.

Encapsulando conhecimentos e responsabilidades no lugar onde eles pertencem, fi ca
simples fazer alteraes em lima parte do sistema sem ter um impacto negativo em outras
partes no relacionadas do sistema.
Tais divises tornam possvel fazer melhorias no sistema a qualquer moment o. Voc tam-
bm viu pela primeira vez como a herana e o polimorfismo tornam possvel adicionar
novos j ogadores no sistema, a qualquer momento.
Extensvel: o sistema do j ogo vinte-c-um extensvel.
Voc viu pela primei ra vez como pode adicionar novos jogadores no sislema. Alm disso,
atravs de uma herana cuidadosa. voc pode inlroduzir novos tipos de cartas (como car-
tas visuais) e mos. O processo it erativo mostrou como um sistema de POO pode ser ex-
tensvel.
o ltimo quilmetro 491
Oportuno: o sistema do jogo vinte-e-um oport uno .
Voc produziu um jogo vinte-c-um completo em quatro iteraes - o tempo de uma se-
mana. Veja como ele oport uno!
Realidades do setor e POO
As li es deste livro ti veram como pressuposto o fato de que voc estava iniciando seus projetos
de POO desde o princpio. Quando voc comea desde o principio, no precisa integrar sistemas
de backend legados, no-OO. Voc no precisa reut il izar bibli otecas procedurai s. Voc pode co-
mear do comeo e tudo que usar pode ser 00.
Voc ver que um projeto de POO independente raro. Na maiori a das vezes, voc precisar in-
teragir com componentcs no-OO. Pegue o caso dos bancos de dados relacionais. Os bancos de
dados relacionais no so particularmente ori entados a objetos e os bancos de dados orientados a
objctos ainda so raramente usados fora de al guns nichos do setor.
A prpria linguagem Java no totalmente orientada a objetos. A confi ana cm primitivas
no-OO faz voc rea lizar alguma codificao no-OO, de tempos em tempos.
Ao se deparar com essas reali dades, melhor trabalhar para empacotar esses aspectos no-OO
em um empacotador orient ado a objetos. Por exemplo, ao tratar com bancos de dados relaciona-
is, ajuda escrever uma camada de persistncia de objetos. Em vez de ir diretament e a um banco
de dados e reconstitui r seus objetos atravs de vrias consultas SQL, a camada de persistncia
pode fazer esse trabal ho para voc.
Real mentc no possvel abordar aqui cada ti po de sistema no-OO que voc vai encont rar. Mas
teramos sido negligentes se no apontssemos essas realidades antes de mand-lo apli car POO.
Vai demorar muito tempo, antes que todo sistema legado seja converti do para uma arquitetura
baseada em objetos (se que isso vai acontecer). Voc deve estar preparado para essa eventuali-
dade e pronto para tratar com ela da forma mais elegante possvel.
Resumo
Voc termi nou! Em trs semanas curtas, este livro forneceu a voc uma base slida em POO. O
resto fi ca por sua conta. Agora voc tem conhecimento sufi ciente para comear a aplicar POO
em seus projetos dirios. Boa sort c!
Perguntas e respostas
P Por que voc esperou at agora para nos dizer a respeito de linhas de execuo?
R O problema do projeto no afela o jogo vinte-e-um. Apresentar os possveis problemas
antecipadamente leria confundido a queslo.
Dia 21
importante que voc perceba as deficincias do projeto, assim como uma possvel so-
luo.
O uso de linhas de execuo tambm um assunto avanado. Usar linhas de execuo no
jogo vinte-e-um foi muito fcil. Mas usa-las em outros aplicativos pode no se mostrar
to simples.
P O que pode tornar o uso de linhas de execuo difci l?
R Se voc tiver mllltiplas linhas de execuo compartilhando dados, uma linha de execu-
o poder alterar os dados c danificar outra li nha de execuo. Tais problemas de con-
corrncia so ext remamente difceis de projetar, implementar e depurar.
Workshop
As perguntas e respostas do teste so fornecidas para seu melhor entendiment o. Veja as respos-
tas no Apndice A, ;'Respostas".
Teste
I. Como as li nhas de execuo tratam do problema da chamada de mtodo recursiva?
Exerccios
I. Faa download do cdigo-fonte da iterao de hoje. O cdigo est dividido em quatro di -
ret rios separados: threaded _ he 110_ worl d, threaded _ mvc _gui, threaded _pac _9ui e
threaded_simulador. Estude o cdigo e certifique-se de entender como ele funci ona.
2. Seu estudo de POO no deve terminar com este livro. Gere uma lista de assuntos sobre os
quais voc gostaria de aprender mais. Classifique esses assuntos em ordem de importn-
cia, pesquise a Web para encontrar materiais e comece a estudar!
SEMANA 3
Em reviso
Agora, voc concluui fi terceira e ltima semana deste li vro e nos lJltimos sete dias, aprendeu a
desenvolver seu prprio jogo vinte-c-um 00.
O Dia 15 apresentou as regras bsicas do jogo vinte-c-um. Voc desenvolveu uma li sta de casos
de LISO em potencial e selecionoll alguns deles para desenvolver na pri meira iterao do jogo.
Voc seguiu o processo de projeto, da anlise, de implementao e teste, e no final do dia ti nha
uma verso funcional do jogo vinte-c-um que distribua cartas e o deixava jogar.
No Dia 16, voc completou a segunda iterao do jogo. Voc adicionou mai s funcionalidade,
corno a capaci dade de dctcnninar os resultados do jogo. Ao fazer isso, voc aprendeu a respeito
dos estados e como us- los para melhorar seu projeto.
O Dia 17 mostrou a voc como completar uma outra iterao do jogo vinte-e-um - a aposta. Ao
fazer isso, voc viu como poderi a estender a arquiletura de estado para suport ar apostas simples
no jogo. Voc tambm viu que, s vezes, necessrio revere refazer uma hierarquia, quando no-
vos requisitos se apresentam. Embora o fato de refazer apresente um pouco de trabal ho extra an-
tecipado, refazer quando apropriado tende a valer a pena, quando voc prossegue.
No Dia 18, voc concl ui u ojogo vinte-e-um, adicionando uma OUI. Para isso, voc reviu o pa-
dro MVC discutido em um capitulo anterior.
O Dia 19 forneceu uma OUI al ternativa, usando o padro PAC, quela desenvolvida no Dia 18.
Isso ajudou a refinar scu entendimento de quais padres so apropriados para cenrios especficos.
Durante o Dia 20, voc reviu os conceitos do polimor fi smo que permitem escrever software fi
prova do futuro. Voc se divertiu um pOLlCO, quando adicionou v ri os jogadores no-humanos
ao sistema e transformou o jogo vinte-e-um em um simulador. Mexendo com est ratgias de
vrios jogadores, voc aprendeu o que no deve fazer ao participar de um jogo. Voc tambm
aprendeu que pode introduzir tipos de jogador no sistema sem ter de alterar o sistema bsico.
Esses ti pos de jogador no foram nem mesmo considerados quando voc construiu o sistema
inicial.
Final mente, no Dia 21, voc aprendeu sobre li nhas de execuo. O captulo tambm abordou to-
das as arestas do projeto e apresentou uma discusso sobre a 00 pura, em oposio ao que voc
provavelmente ver no mundo real.
Dia 21
As lies desta semana aprofundaram seu entendimento de 00 e, alm disso, voc acabou com
um divert ido e demorado jogo vinte-e-um 00 para provar isso.
Aps concluir este livro, voc tem a base necessria em 00 para comear a desenvolver softwa-
re 00. Tudo de que voc precisa agora prtica e experi ncia. Boa sorte.
Para mais recursos, o Apndice D. " Bibliografia selecionada", romece um ponto de partida para
mais informaes sobre 00.
Apndices
A Respostas
B Resumo do Java
C Referncia da UML
O Bibliografia selecionada
E Listagens do cdigo do jogo vinte-e-um
ApNDICE
Respostas
Dia 1 Respostas do teste
Respostas do teste
1. Como urna di sciplina de software, a programao procedural decompe um programa
em dados e procedimentos para manipular esses dados. A programao procedural tem
uma natureza seqencial. Li stas de chamadas procedurais que so executadas seqilncial-
mente or ientam O nuxo de um programa procedural. Um programa procedural termi na
aps chamar sua ltima procedure.
2. A programao procedural fornece a um programa uma estrutura global: dados e proce-
dimentos. Os procedimentos tambm o ajudam a ver como deve programar uma tarefa .
Em vez de escrever um nico bloco de processamento grande, voc di vide os procedi-
mentos em subprocedimentos. Os procedi mentos fornecem um nvel de reutil izao.
Voc pode criar bibliotecas de procedimentos reutili zveis.
3. A programao modular acopla dados e procedimentos fortemente, para manipularesses
dados em uni dades conhecidas como mdulos. Os mdulos ocul tam o runcionamento e a
represent ao de dados internos de um programa. Entretanto, a maiori a das linguagens
modulares ainda pennite que voc use esses mdulos cm um ambiente procedural.
Apndice A
4. A programao modular oculta a implementao e, assim, protege os dados de manipula-
o inconsistente ou imprpria. Os mdulos tambm fornecem uma est rut ura de nvel
mais alto para um programa. Em vez de pensar em tennos de dados e procedimentos, os
mdulos pennitcm que voc pense em um nvel comportamental conceituaI.
5. A programao procedural e a programao modular tm suporte limitado para a reutil i-
zao. Embora voc possa reutilizar procedimentos, eles so altamente dependentes de
seus dados. A natureza global dos dados no mundo procedural torna a relltil izao di fici l.
Os procedimentos podem ter dependncias dificeis de quantifi car.
,
Os mdulos em si so prontamente reutilizveis. E possvel pegar um mdulo e us-lo
em qualquer um de seus programas. Entretanto, os mdulos limitam a reutil izao. Seu
programa s pode usar os mdulos diretamente. Voc no pode usar um mdulo existen-
te como base para um novo mdulo.
6. roo uma di sciplina de software que modela o programa em termos de objetos do mun-
do real. A POO divideo programa em vri os objetos inter-reJac ionados. Ela complemen-
ta a programao modular, suportando encapsul amento, assim como eliminando
defici ncias da reut ilizao atravs da herana e deficincias de tipos atravs do poli-
morfi smo.
7. As seis vantagens da roo so programas que so:
Natura is
Confive is
Reutili zveis
Manutenveis
Extensveis
Oportunos
8. A POO natural. Em vez de modelar os problemas em termos de dados ou procedimen-
tos, a roo permite que voc modele seus programas nos termos do problema. Tal estra-
tgia o li bera para pensar nos termos do problema e focalizar o que est tentando fazer.
Isso reti ra o foco dos detalhes da implementao.
9. A classe define todos os atributos e comportament os comuns de um grupo de objetos.
Voc usa essa definio de classe para criar instncias desses objetos.
Um objelo uma instncia de lima classe. Seus programas manipul am esses objetos.
Um objeto executa componamentos. Voc tambem pode chamar os comporta mentos de
um objeto de interface pblica dele. Outros objetos podem exercer qualquer comporta-
mento na int erface de um objelo.
Respostas
10. Os objetos se comunicam atravs do envio de mensagens de uns para os outros. Chamar
um mtodo si nnimo de fazer uma chamada de mtodo Oll procedimento.
11. Um const rutor um mtodo que defi ne como se cri a uma instncia de objeto. O uso do
construtor instanciar um objelo e o tornar disponvel para seu programa.
12. Um acessor um comportamento que d acesso aos dados internos de um objeto.
13. Um mutante um comportamento que pode alterar o estado interno de um objelo.
14. thi s uma reCerncia que cada instncia tem para si mesma. A referncia thi s d ins-
tncia acesso s suas variveis e comportamentos internos.
Dia 2 Respostas do teste e dos exerccios
Respostas do teste
I. o encapsulamento natural. O encapsulamento pennite que voc modele o software em
termos do problema e no nos tennos da implementao.
O encapsulamento leva a um software confivel. O encapsulament o oculta o funci ona-
mento interno de um componente de software e garante que ele seja acessado correta-
mente. O encapsulamento permite que voc isole e vali de a responsabilidade. Quando
voc ver um component e agir corretam ente, pode reutiliz-lo com confi ana.
O encapsulamento proporciona a voc um software reutili zvel. Como cada component e
de software independente, voc pode reutil izarocomponente em muitas si tuaes dife-
rentes.
O encapsulamento leva a um cdigo manutenvel, pois cada componente independente.
Uma alterao em um componente no danificar outro componente. Assim, a manuten-
o e os aprimoramentos so simplificados.
O encapsulamento torna seu software modular. As alteraes em uma parte de um pro-
grama no danificaro O cdigo em outra parte. A modularidade permite que voc faa
correes de erro e melhorias de funcional idade sem danifi car o restante de seu cdigo.
O encapsulamento leva a um desenvolvimento de cdigo oportuno, pois remove acopla-
mento de cdigo desnecessrio. Freqentemente, dependncias ocultas levam a erros
que so dificeis de encont rar e corrigir.
2. Abstrao o processo de simplificar um problema dificil. Quando voc comea a resol-
ver um problema, no se sobrecarrega com cada detalhe que envolve o domnio. Em vez
disso, voc o simplifica, tratando dos detalhes pertinentes formulao de uma soluo.
A rea de trabalho grfica de seu computador um exemplo de abstrao. A rea de tra-
balho oculta completamente os detalhes do sistema de arquivo.
Apndice A
3. Uma implementao defi ne como um componente fornece um servio. A implementa-
o define os detalhes internos do componente.
4. Uma interface defi ne o qu voc pode fazer com um componente. A interface oculta
completament e a implement ao subjacente.
5. Uma interface descreve o que um componente de software faz; a implementao di z
como o componente faz isso.
6. Sem uma diviso clara, as responsabi lidades se misturam. Responsabi I idades misturadas
levam a dois problemas relacionados.
Pri meiro, o cdigo que poderia ser centra l izado se torna descentraI izado. A responsabi I i-
dade descentralizada deve ser repetida ou reimplementada em cada lugar onde ela ne-
cessria. Lembre- se do exempl o BadItem apresentado anteriormente.
fci l ver que cada usurio precisaria reimplementar o cdi go para calcul ar o total ajus-
tado de um item. Sempre que voc reescreve a lgica, abre a possibi li dade de erros. Voc
tambm abre seu cdigo para um li SO incorreto, pois a responsabilidade de manter o esta-
do interno no est mais dentro do componente. Em vez disso, voc coloca essa respon-
sabi lidade nas mil os de outros.
7. Um tipo um elemento da linguagem que representa alguma uni dade de clculo ou com-
portamento. Se as linhas de cdigo so frases, os tipos so as palavras. Normalmente, os
tipos so tratados como unidades independentes e atmicas.
8. Um TAO um conj unt o de dados e um conj unto de operaes sobre esses dados. Os
TAOs nos pennitem defini r novos tipos de linguagem, ocultando dados internos e o esta-
do por trs de uma interface bem definida. Essa interface apresenta o TAO como uma
ni ca unidade atmica.
9. Existem vrias maneiras de obter ocultamento de impl ementao e cdigo fracamente
acoplado. A resposta fci I usar encapsulamento. Entretant o, um encapsul amento eficaz
no acidente. Aqui esto algumas dicas para o encapsul amento e fi caz:
Acesse seu TAO apenas at ravs de uma interface de mtodos; nunca permita que es-
truturas internas se tomem parte da interface pblica.
No fornea acesso s estruturas de dados internas; abst raia todo o acesso.
No fornea acesso i nadvertido s estruturas de dados internas, ret ornando acidental-
mente pont eiros ou re ferncias.
Nunca faa suposies a respeito dos out ros ti pos que voc usa. A no ser que um
comportamento aparea na interface ou na documentao, no conte com ele.
Cuidado ao escrever dois tipos intimamente relacionados. No se permita programar
acidentalmente com base em suposies e dependncias.
10. Voc preci sa conhecer algumas annadilhas da abslrao.
Respostas
No caia na parali sia da abstrao. Resolva os problemas que voc encont rar primeiro.
Resolver problemas sua pri ncipal tarefa. Veja a abstrao como um bnus e no como o
objetivo final. Caso contrrio, voc vai se deparar com a possibi li dade de prazos fi nais
perdidos e abstrao incorreta. Existem momentos para abstrair e momentos em que a
abstrao no apropriada.
A abstrao pode ser perigosa. Mesmo que voc tenha abstrado algum elemento, isso
pode no funcionar em todos os casos. muito difi cil escrever uma classe que sati sfaa
as necessidades de todos os usurios.
No coloque em uma classe mais detalhes do que so necessrios para resolvero problema.
No queira resolver todos os problemas. Resolva o problema que est a sua frente e depois
procure maneiras de abstrair o que voc fez.
Respostas dos exerccios
I. Um possvel TAD de pil ha:
publie interface Stack {
}
publlc void push( Obj ect obj ) ;
publi c Obj ect pop ();
publ i c boolean isEmpty() ;
publ i c Object peek();
2. A pil ha mel hor implementada como uma lista encadeada isoladamente, com um ponteiro
de frente. Quando coloca ou ret ira um elemento, voc usa o ponte iro de frente para en-
contrar o primeiro elemento.
3. Examinando a resposta do Exerccio I e a implementao do Exerccio 2, voc v que a
interface era adequada. A interface nos proporciona as vantagens que qua lquer interface
bem definida oferece. Aqui est uma lista breve das vantagens:
A interface define a pi lha como um ti po. Est udando a int erface, voc sabe exatamente
o que a pilha fur.
A interface oculta completamente a representao interna da pilha.
A interface define c laramente as responsabilidades da pilha.
Dia 3 Respostas do teste e dos exerccios
Respostas do teste
I. Aeeount tem dois mutant es: depositFunds() e wi thdrawFunds( ).
Aceount tem um aeessor: getBalaneeO.
Apndice A
2. Existem dois tipos de construtores: aqueles que tm argumentos e aqueles que no tm
(noargs).
Account. do Laboratri o 2, tem os dois tipos de construtores.
3. (Opcional) Publ i c aceitvel no caso de Boolean, pois as variveis so constantes. Ter
acesso pbl ico s constantes no estraga o encapsulamento, pois isso no est expondo a
implementao para liSO externo.
Alm disso, O uso de valores Bool ean constantes para verdadeiro e fa lso economi za me-
mria. No h necess idade de instanciar suas prprias cpias de Bool ean. Voc pode sim-
plesmente compartilhar essas constantes de instncias gl obai s.
4. As instncias de Card so imutveis. Seria mais eficiente definir 52 constantes Card -
uma para cada carta. No h necess idade de instanciar vrias representaes da mesma
,
carta, mesmo quando existem vrias instncias de Deck. E perfeit ament e seguro compar-
tilhar as mesmas instncias de Card entre os maos de carta.
5. Ao projetar suas classes, voc deve perguntar-se o que torna ' isso' uma classe? Especifi-
camente, lembre-se da di scusso sobre como as classes classificam obj etos rel acionados.
Como as cartas so rel acionadas? Todas as cartas cont m um nmero, um naipe e como
exibi -Ias.
o nmero ou o naipe no torna uma carta um tipo di ferent e de carta. Ela ai nda uma car-
ta de pquer. As cartas de pquer simplesmente poderiam ter valores diferentes. Assim
como um mamfero marrom ainda um mamfero, um l O de copas ai nda apenas uma
carta.
,
As vezes, pode ser extremamente dificil decidiroque devec o que no deve ser uma clas-
se. Contudo, existe uma regra geral que voc pode seguir.
Se voc ver que o comport amento de um objeto muda fundament almente quando o valor
de um atributo muda, as chances so de que voc deva criar classes separadas: uma para
cada va lor possvel desse at ributo. Claramente, o valor da carta no muda seu comporta-
mento de nenhuma manei ra fundamental.
6. A diviso correta de responsabilidades toma o projeto de Deck, Dea l er e Card mais modu-
lar. Em vez de urna nica classe grande, as cartas de pquer se dividem perfeitamente em
trs classes. Cada classe responsvel por fazer seu lrabalho e ocultar essa implementa-
o das outras classes. Como resultado, essas classes podem mudar sua implementao
facilmente, a qual quer momento, sem prejudicar qualquer um de seus usurios.
Com classes separadas, voc tambm tem a vant agem de que pode reutili zar a classe
Car d separada das classes Deck e Dea l er.
Respostas
Respostas dos exerccios
I. Aqui est uma possvel soluo para o Exerccio I:
public class DoubleKey {
private Object keyl. key2;
II um construtor noargs
public DoubleKeyO {
keyl z "keyl ";
key2 '" "key2";
}
II um construtor com argumentos
II deve procurar e ma nipular caso nulo
public DoubleKey( Object keyl. Object key2 ) {
th is .keyl .. keyl;
th1s.key2 = key2;
}
II acessor
publi c Object getKeyl() {
return keyl ;
}
II mutante
II deve procurar e manipular caso nulo
publi c void setKeyl( Object keyl ) {
th1s.keyl = keyl;
}
II acessor
publ i c Object getKey2() {
return key2;
}
II mutante
II deve procurar e manipular caso nulo
public void setKey2( Object key2 ) {
thi s . key2 = key2;
}
II os doi s mtodos a seguir so exigidos para
. . .. 11 trabalhar cor retamente como um keyif passado para HashMap ou
Hashtable
publi c boolean equals( Object obj ) {
}
}
Apndice A
il( Ih is obj ) (
return true;
}
if( thi s . getCl ass O "" obj. getCl ass () ) {
DoubleKey dk " ( Doubl eKey )obj;
}
if( dk . getKeyl().equals ( getKeyl() ) &&
dk . gelKey2 () . equa 1 s ( gelKey2 () ) ) {
return true;
}
return false;
public int hashCode () {
return keyl.hashCode{) + key2.hashCode();
}
2. Aqui est lima possvel soluo para o Exerccio 2:
publi c class Deck (
private java.util.Li nkedlist deck ;
publi c Deck() {
bui l dCardsO ;
}
public String display() (
}
int num_cards " deck . size() ;
String display .. "";
i nt counter '" O;
for( int i ,. O; i < num_cards; i ++ ) {
Card card " (Card ) deck.get( i );
display " display + card . display()+ " ";
counter++;
}
if( counter "" 13 ) {
counter .. O;
display " display + "\ n";
}
return display;
publi c Card get( int index) (
if( index < deck . size() ) {
return (Card) deck.get( index };
}
}
Respostas
return nul1;
}
pub l i c void replace( int index. Card card ) {
deck.set( index. card )i
}
public int sizeO {
return deck.size() i
}
publ ic Card removeFromFront() {
if( deck.sizeO > O } (
Card card (Card) deck .removeFirst()i
return cardi
}
return nul1;
}
public void returnToBack( Card card ) {
deck. add( card l ;
}
pr ivate void bu i l dCards() {
}
deck "'new j ava.util.linkedlist();
deck.add( new Card( Card . CLUBS. Ca rd.TWO ) ) i
deck.add( new Card( Card. CLUBS . Ca r d.THREE ) l;
deck.add( new Card( Ca rd. CLUBS . Card .FOUR ) ) i
deck.add( new Card( Card . CLUBS. Card . FIVE ) );
II definio compl eta cortada por brevidade
II veja a listagem compl eta no cdigo- fonte
Dia 4 Respostas do teste e dos exerccios
Respostas do teste
I. A reutilizao simples no fornece nenhum mecanismo para reut il izao alm da instan-
ciao. Para reutil izar cdigo diretamente, voc precisa reconar e colar o cdigo que de-
seja reuti lizar. Tal prtica resulta em vrias bases de cdigo que diferem apenas em um
pequeno nmero de maneiras. Um cdigo que no possui herana esttico. Ele no
pode serestendido. Alm disso. um cdigo esttico limi tado quanto ao ti po. Um cdigo
Apndice A
estti co no pode compart ilhar tipo. Assim, voc perde as vantagens da capacidade de
conexo de tipo.
2. A herana um mecanismo interno para a reutil izao segura e a extenso de definies
de classes preexistentes. A herana pennite que voc estabelea relacionamentos ' um'
entre as classes.
3. As trs formas de herana so:
Herana para reutili zao de implementao
Herana por diferena
Herana para substituio de tipo
4. A impl ementao da herana pode cegar um desenvolvedor. A reuti lizao da imple-
mentao nunca devc ser o nico objeti vo da herana. A substit ui o de tipo sempre deve
ser sua primeira prioridade. A herana para reutili zao cega leva a hi erarquias de clas-
ses que simplesmente no fazem sentido.
5. A programao por diferena uma das formas de herana. Isso signi fica que, quando
voc herda, programa apenas os recursos que diferenciam a nova classe da antiga. Tal
prti ca leva a classes menores e incrementais. As classes menores so mais fce is de ge-

renc.ar.
6. Os trs t ipos de mtodos e at ri but os so:
Sobrepostos
Novos
Recursivos
Um atributo ou mtodo sobreposto um atri buto ou mtodo declarado na progeni tora (ou
ancestral ) e reimplementado na filha. A filha altera o comportamento do mtodo ou a de-
fin io do atributo.
Um mtodo ou at ribut o novo um mtodo ou atributo que aparece na filha, mas no na
progenitora ou ancestral.
Um atributo ou mtodo recursivo defin ido na progenitora ou na ancestral, mas no re-
definido pela filha. A filha simplesmente herda o mtodo ou atributo. Quando feita uma
chamada para esse mtodo ou atribulo na filha, a chamada sobe na hierarquia at que seja
encontrado algum que saiba como manipul-la.
7. A programao pela diferena fornece as menores classes que definem um nmero me-
nor de comportamemos. Classes menores devem conter menos erros, ser mais fceis de
depurar, mais fceis de manter e mais fceis de ent ender.
Respostas
A programao pela diferena permite que voc programe de forma incremental. Como
resultado, um projeto pode evoluir com o passar do tempo.
8. A 11 Permi ss ion, Bas i cPermi ss i on e Un reso 1 vedPermi ss i on so todas fi lhas de Penni ss i -
on. SecurityPennissi on descendente de Permission.
Penn ission a classe-raiz. Al I Permi 5S i on, Unreso 1 vedPenni ss; on e Securi tyPermi ss i on
so todas classes folhas, pois elas no tm fi lhas.
Sim, Penni ss10n ancestral de SecurityPennission.
9. Herana por substituio de tipo o processo de definir relacionament os com capacidade
de substituio. A capacidade de substituio permite que voc subst itua uma descen-
dente por uma ancestral , desde que no precise lIsar quaisquer novos mtodos defi nidos
pela descendente.
10. A herana pode destruir o encapsulamento, dando a uma subclasse acesso inadvert ido
representao interna de uma superclasse.
A destruio inadverti da do encapsulamento uma anlladi lha que pode apanh-lo sorra-
teiramente. A herana fornece sil enciosamente a uma classe filha acesso mais liberal
progenitora. Como resul tado, se os passos corretos no forem dados, uma fi lha poderi a
ter acesso direto implementao da progenitora. O acesso direto implementao to
peri goso entre progenitora e fil ha quanto entre dois objetos. Muitas das mesmas armadi-
lhas ainda se aplicam.
Evite a destruio do encapsulamento tomando a implement ao interna pri vada. Faa
implementao interna privada apenas dos mtodos absolutamente necessri os para
uma subclasse.
Na maioria das vezes, as filhas devem exercitar apenas a interface pblica da progeni tora.
Respostas dos exerccios
I. Toda subclasse ler acesso direto representao interna de Point. Tal acesso irrestrito
destri o encapsulamento c abre a classe para os problemas tratados na pergunta 10.
Remediar a si tuao to fci l quanto tornar x e y privados. Note que essa classe Pai nt
modelada de acordo com java.awt.Point.
Apndice A
Dia 5 Respostas do teste
Respostas do teste
lo Em CheekingAeeount, publie double withdrawFunds( double amount ) um exemplo
de mtodo redefinido. CheckingAeeount sobrepe withdrawFunds() para que ele possa
cont"rOlar O nmero de transaes.
Em BankAeeount, publ i e double getBal anee() um exemplo de mtodo recursivo. O
mtodo aparece na progenitora, mas nenhuma das subclasses o redefine.
Entretanto, as subclasses o chamam.
Finalmente, o mtodo publ ie double getlnterestRate() de SavingsAeeount um exem-
plo de mtodo novo. O mtodo aparece apenas na classe Savi ngsAeeount e no na progeni-
tora.
2. Voc usaria uma classe abstrata para herana planejada. Uma classe abstraIa fornece s
suas subclasses um indcio do que ela precisar redefinir. As classes abstratas garantem
que suas subclasses usem a classe base corretamente.
3. O Laboratri o 3 mostra 'tem um'. Deck tem objelos Cardo DoubleKey, do Laboratri o 2,
tambm tcm duas St rings.
4. Os laboratrios preservaram o encapsulamento ocultando lodos os membros de dados.
Se voc exami naras solues, ver que todos os dados so pri vados. Por exemplo, a clas-
se BankAeeount declara o saldo (balance) como privado. Em vez disso, cada classe d
acesso representao dos dados atravs de uma interface bem definida.
5. SavingsAeeount um exemplo de especializao. Ela se especializa em relao sua
progenitora, BankAeeount, adicionando mtodos para configurar, consultar e aplicar ju-
ros na conta.
6. O Laboratrio 3 usa herana para reut ilizar o comportamento bsico defi nido pela classe
BankAccount. BankAccount defi ne uma implementao comum para sacar fundos, deposi-
tar fundos e consultar o saldo. Atravs da herana, as subclasses de conta obtm essa im-
plementao.
O Laboratrio 4 comea apresentando um caso de herana para reuti liz.1o da implemen-
tao, mas tennina usando composio, para obter uma forma dc reutili zao mais limpa.
Dia 6 Respostas do teste e dos exerccios
Respostas do teste
I. Incluso
Paramtri co
Sobreposio
Sobrecarga
Respostas
2. O polimorfismo de incl uso permite que voc trate um objelo como se fosse um tipo di -
ferent e de objeto. Como resultado, um objeto pode demonstrar muitos tipos diferentes de
comportamento.
3. Os polimorfi smos de sobrecarga c paramtrico permitem que voc modele algo em nvel
conceituaI. Em vez de se preocupar com os ti pos de parmetros que algo processa, voc
pode escrever seu cdigo de forma mais genrica. Em vez di sso, voc modela seus mto-
dos e tipos em nvel conceituai do que eles fazem e no para que fazem.
4. Uma int erface pode ter qualquer nmero de implementaes. Programando para uma in-
terface, voc no fica vinculado a nenhuma implementao espectica. Como resultado,
seu programa pode usar automaticamente qualquer implementao que aparea. Essa I i-
berdade de implementao permite que voc troque entre diferent es implementaes
para mudar o comport amento de seu programa.
5. Quando voc sobrepe um mtodo, o polimorfismo garante que a verso correta do m-
todo seja chamada.
6. Polimorfi smo ad-Iroc outro nome para sobrecarga.
7. A sobrecarga permite a voc definir um nome de mtodo vrias vezes. Cada definio di-
fere simplesmente no nmero e nos tipos de argumentos. A sobrecarga expressa um
comportamento diferente porque voc simplesmente chama o mtodo. Voc no precisa
fazer nada para garantir que a verso correta do mtodo sej a cha mada.
A sobrecarga permite a voc modelar um mtodo em nvel conceituai do que ele faz. A
natureza polimrfi ca da sobrecarga cuida dos argumentos especfi cos.
8. O polimorfi smo paramtrico pcnnite a voc escrever tipos e mtodos verdadeiramente
genricos, adiando as definies de tipo at o momento da execuo. Esse tipo de poli -
morfi smo permi te que voc escreva cdigo realmente natural, pois pode programar tipos
e mtodos muito genricos e conceituais. Voc escreve esses tipos e mtodos a partir da
viso conceituai do que eles fazem e no do que especificamente fazem com ela. Por
exempl o, se voc programar um mtodo compare ( [T] a, [T] b) . pensar em lermos do
conceito mai s alto da comparao de dois objetos de tipo [T] . Os argumentos de tipo [TJ
simplesmente precisari am compart ilhar uma estrutura comum, como < ou um mlodo
compare( ). O pont o importante que voc escreve si mplesmente um mtodo e ele pode
comparar muitos ti pos diferentes de objetos.
9. O polimorfi smo nomlal mente incorrer em um custo na eficincia. Algumas fonnas e
implementaes de polimorfi smo exigem verificaes e pesquisas em tempo de execu-
o. Essas verifi caes so dispendiosas, quando comparadas com as linguagens estati-
camente tipadas.
Apndice A
o polimorfis mo tenta fazer o desenvolvedor quebrar a hierarquia de herana. Voc nun-
ca deve mover funcionalidade para cima na hierarquia, si mplesmente para aument ar as
oport unidades para comportament o polimrfi co.
Quando trata um subtipo como se ele fosse o tipo base, voc perde o acesso a todos os
comportamentos adicionados pelo subtipo. Assim, quando voc cri ar um novo subti po,
precisar garantir que a interface do ti po base seja adequada para a interao com seu
novo subtipo, em mtodos que trabalham com o tipo base.
10. A herana efi cnz tem um impacto direto no polimorfi smo de incluso. Pnra nproveilar a
capacidade de conexo oferecida pelo poli morfismo de subtipo, voc deve ter li ma hie-
rarquia de objetos correta.
O encapsul ament o evita que um objeto fique vinculado a uma implementao especifica.
Sem encapsulamento, um obj eto poderia se tornar facilmente dependente da implemen-
tao interna de outro objeto. Tal acoplamento fone toma a substi tuio difcil, se no
impossvel.
Respostas dos exerccos
1. Imagine um programa que escreva seu status na linha de comando ao ser executado. Na
linguagem Java, voc poderi a si mplesmente usar Sys tem. write. pr i nt l n D. para escre-
ver essas mensagens na tela. E se voc quisesse que essas mensagens fossem gravadas
cm um arquivo? E se voc quisesse que essas mensagens fossem enviadas para uma GUI
de alarme em outro computador? Obviamente, voc precisaria alterar seu cdigo, con-
forme os requis it os mudassem.
E se seus requisitos exigissem que voc oferecesse suporte para ambos ao mesmo tem-
po? Em vez de um ou outro, voc quer permit ir que o usurio escol hn onde vai escrever,
atravs de um argumento de linha de comando. Sem pol imorfismo, voc precisari a pro-
gramar casos para cada tipo de escri ta. Com o polimorfi smo, entretant o, voc pode sim-
plesmente declarar uma clnsse chamada 1 og, que tenha um mtodo de escrita. Subclasses
podem especificar onde as mensagens so gravadas. Voc pode adicionar novos subtipos
em seu programa a qualquer momento. O programa sabera automati camente como usar
os novos subtipos, desde que voc programe para a interface 109. Assim, voc pode tro-
car para o novo comportament o de log a qualquer moment o.
2. int i = 2 + 3. 0
Dependendo da definio de +, essa instruo pode ser coerciva. Aqui , a instruo tenta
somar um nmero inteiro e um nmero real. Ela pega o resultado e o coloca em uma va-
rivel 1 nt. Dependendo da linguagem, o compil ador pode converter o inteiro 2 em um
nmlero real, efetuar a operao aritmtica e. em seguida. convener o resultado nova-
mente para um inte iro.
Respostas
Essa instruo interessante, pois e la tambm pode demonst rar uma instncia de sobre-
carga. + pode sobrecarregar as seguintes operaes:
+(real ,real)
+(integer . integer)
+(integer . real)
Em qualquer caso, voc tem pol imorfi smo ad-floc, pois, em vez de um mtodo pol imr-
fico, voc tem vrios mtodos polimrfi cos ou converso.
3. Sobrecarga:
Considere java . util . SimpleTimeZone. SimpleTimeZone define os doi s mtodos sobre-
carregados a seguir: setEndRu 1 e e setS tartRu 1 e. Como resultado, esses mtodos respon-
dem diferentemente, dependendo do nmero e dos tipos de entrada.
Polimorfi smo de incluso:
Cons idere java. iO.Writer. A classe abst rat a Wri ter define vrios mtodos para gravar
dados. Correntemente, a linguagem Java define vrias subclasses de Wri ter: BufferedW-
ri ter, CharArrayWriter, Fi 1 terWriter, OutputStreamWriter, PipedWriter, PrintWriter
e StringWriter . Cada subclasse define o comportamenlo dos mtodos el ose, f lush e
write (um mtodo sobrecarregado, a propsito).
Ao programar, voc deve escrever seus objetos e mtodos para agirem em instncias de
Wri te. Desse modo, voc pode trocar para diferentes subclasses, dependendo de como
deseja que os dados sej am gravados. Se voc programar dessa maneira, Wri ter expressa-
r vrios comportamentos di ferentes, dependendo da implementao subjacente que es-
teja sendo usada.
Dia 7 Respostas do teste
Respostas do teste
I. o mtodo observeO de PsychiatristObject um exemplo de sobrecarga de mtodo.
2. O mtodo observe () i I ustra muito bem o problema da sobrecarga. Sempre que voc adi-
cionar um novo subtipo, precisar adicionar outro mtodo sobrecarregado. medida que
o nmero de mlodos aumentar, voc desejar encont rar uma manei ra de adicionar uma
funo comum em seus objelos, para que possa trat-los genericamente e remover os m-
todos sobrepostos.
3. So dois passos para adicionar novo comportamento em uma hierarquia poli mrfica.
Pri meiro, crie o novo ti po. Segundo, al tere seu programa de modo que ele possa eriar ins-
tncias do novo tipo. Voc no deve ter de mudar nada mais, a no ser que precise ti rar
proveito de algum recurso especial da nova classe.
Apndice A
4. O mtodo exami ne() de Psychi at ri stObject um exempl o de polimorfismo de inclu-
so. Ele pode trabalhar com qualquer subtipo de MoodyObject.
5. Voc pode eliminar as condicionais atacando os dados que fazem parte das condiciona-
is. Se os dados no so um objeto, transforme-os em um objeto. Se os dados so um obje-
to, adicione um mtodo que fornea o comportamento necessri o. Uma vez feito isso,
pea ao objeto para que faa a lgo, no faa algo nos dados.
6. O polimorfismo de incluso permitir que um mtodo funcione para o tipo de argumento
e qua lquer subtipo. Voc no precisa de um metodo diferent e para cada subtipo. Ter ape-
nas um mtodo diminui o nmero de mtodos que, de out ra forma, voc precisaria. Isso
tambm simplilica a adio de novos recursos.
7. Na 00, voc no deve pedir os dados de um objelo. Em vez disso, voc deve pedir a um
objeto para quc faa algo com scus dados.
8. As condicionais o obrigam a quebrar o relacionamento deli neado no Exerccio 7. Que-
brar o relacionamento o obriga a misturar responsabilidades, pois todo usurio precisar
saber o qu os dados representam e como manipul-los.
9. Se voc se encont raratuali zando vrias condi cionais, semprc que adiciona um novo t ipo,
ento a condicional um problema. Se voc se encontrar escrevendo a mesma condicio-
naI em vrios lugares (ou chamando um mtodo que tenha a condicional), ent o a condi-
cional um problema.
10. O polimorfismo permite que voc trate um subtipo como se ele fosse o supertipo. Entre-
tanto, o poli morfismo permite que voc use o comportamento do tipo subjacente real. O
pol imorfismo faz parecer que osupertipo manifesta mui tos comportamentos diferentes.
Dia 8 Respostas do teste e dos exerccios
Respostas do teste
I. A UML a Unified Model ing Language. A UML uma linguagcm de modelagem pa-
dro do setor.
2. Uma metodologia descreve como projetar software. Uma linguagem de modelagem aju-
da a capturar esse projeto graficamente. Uma metodologia freqentcmente conter sua
prpria linguagem de modelagem.
3. O laboratrio demonstra um relacionamento de dependncia.
4. Voc pode fazer duas afirmativas sobre MoodyObject. MoodyObject tem um mtodo cha-
mado queryMood (). MoodyObject tambm uma classe abstrata. O nome em itlico indica
que a classe abstrata.
Respostas
5. O relacionamento Employee, do Laboratri o I, um exemplo de dependncia. O mtodo
payEmployeesO de Payroll depende da interface pbl ica de Employee.
6. Cada um desses smbolos transmite informaes de visibi lidade. + pbl ico, # prote
gido, e - pri vado.
7. Um objcto Queue e seus elementos so um exemplo de agregao.
8. O obj eto Deck tem muitas cartas. Ent retanto, se voc destruir O baralho, dever dest rui r as
cartas. O objeto Deck um exemplo de relacionamento de composio.
9. Basta deixar um nome de classe ou mtodo em itlico para most rar que ele abst rato.
10. O objet ivo tinal da modelagem transmitir seu projeto. Conseqentemente, voc no
deve se preocupar com o uso de toda notao de modelagem disponvel. Em vez disso,
voc deve usar a notao mnima que ainda transmit a sua mc nsagem com xi to.
I I. Uma associao modela relacionamentos estruturais entre objetos. A agregao e a com-
posio so subt ipos da associao que modela relacionamentos ' todo/ parte'. Uma agre-
gao um relacionament o estrutural entre pares. A composio um relacionamento
estrutural onde a parte no independente do todo. A parte no pode existi r separada-
mente do todo.
12. Modele uma associao quando o objetivo de seu modelo for modelar os papis entre os
objetos. Use agregao ou composio quando voc esti ver tentando transmi ti r o projeto
est rut ural.
Respostas dos exerccos
I.
FIGURA A.1
Uma fila.
2.
FI GURA A.2
Um relaciollamemo de
composit1o
A belllalCol",ia.
Fir.
+ enqullulI (obj' ObjOClI: yold
+ dequllua ( I' ObjllCt
+ ,sEmpty (I' boolean
+ pook (I: ObjOCl
COJrT\6i.
1

Abalha
3.
FIGURA A .3
VIII ndaciollalllelllo de
agrega(io
Banco/Collfa Bal/cria.
4.
FIGURA A .4
A associa(io
COlllpradorlCOIl lel""iol1re.
5.
FIGURA A .5
A hieml"qllia Employee.
Apndice A
~
1

ConuEru:n.
comprador compra de

vendedor
Comprador
Comercianle

vende para ~ comprador vendedor
Comp-rador Comercianle

EmploYH
- tifSl...name : Slring
-Iasename: Slrlng
- wage : double
+ getWage ( ) : double
+ gelFirslName ( ) : String
+ getLastName ( ) : String
+ calculatePay (): double
+ printPaychllCk ( ) : String
+ calculate80nuli ( ): double
7
Comml"lonedEmployee
I
- oommission : double haure : inl
- unidades: inl
+ addHour. (hou,..: inl) : void
+ addSalfl'S (unilli inl) : void
+ resetHours ( ): void
+ resetSales ( ) : void
+ calculataPay ( ) : double
+ calculatePav () : double
+ calculateBonus ( ) : double
+ calculateBonu$ (I: double
FIGURA A .6
A hierarquia
Persona l ; tyObject.
Respostas
OptimlsticObJec:t
+ speak ( I: String
P'fson. lityObject
spelk ( I : String
Introv.rtedObJec:t PeulmllllcOb}ed
spellk ( I : t r i n ~ spellk ( I : String
Dia 9 Respostas do teste e dos exerccios
Respostas do teste
I. Um processo de software dispe os vrios estgios do desenvolvimento do software.
2. Um processo iterativo um processo que permite a voc voltar e refazer ou melhorar
continuamente o produto de iteraes anteriores. Um processo iterativo adota uma estra-
tgia iterat iva e incrementa l para o desenvolvimento de software.
Incremental significa que cada iterao acrescenta um pequeno aumento na funcionali-
dade. No to pequena para passar desapercebida, mas no to grande para ser deixada
de lado por ser demasiadamente dispendiosa.
3. No final da AOO voc deve ter um bom entendi mento dos requisitos do sistema, assim
como do vocabulri o do dom nio do sistema.
4. Os requi si tos informam o que os usurios querem fazer com o sistema e quais t ipos de
respostas eles esperam receber.
Os requisitos so aqueles recursos que o sistema deve ter para resolver deterrn i nado pro-
blema.
5. Um caso de LI SO descreve a interao entre o usuri o do sistema e o sistema. O caso de
uso descreve como o usurio uti lizar o sistema a partir de seu pont o de vista.
6. Voc deve dar os seguintes passos para defi nir seus casos de uso:
I. Identi fi car os alores
2. Criar uma lista preliminar de casos de uso
3. Refinar e nomear os casos de uso
4. Definir a seqncia de event os de cada caso de uso
5. Modelar seus casos de uso
7. Um ator algo que interage com o sistema.
Apndi ce A
8. Voc pode fazer as segui ntes perguntas para ajudar a encont rar atares:
Quem principal mente vai usar o sistema?

Exi stem out ros sistemas que usaro o sistema? Por exemplo. existem usuri os
no-humanos?
O sistema vai se comunicar com qualquer outro sistema? Por exemplo, j existe um
banco de dados que voc precisa integrar?
O sistema responde a estmulos no gerados pelo usurio? Por exemplo, o sistema pre-
cisa fazer algo em dctcnninado diade cada ms? Um estmulo pode serprovenicnte dc
fontes normalmente no consideradas ao se pensar do ponto de vista puramente do
usurio.
9. Um caso de uso pode conter e ut ili zar outro caso de LI SO, ou estender out ro caso de uso.
Um caso de uso tambm pode ser uma variante de outro caso de li SO.
10. Uma variante de caso de uso um caso especial de um caso de uso mais gera l.
I I. Um cenrio uma seqUncia ou fluxo de event os entre o usu rio e o sistema.
12. Voc pode modelar seus casos de uso atravs de diagramas de intcrao e diagramas de
atividade. Existem dois tipos de diagramas de interao: diagramas de seqUncia e de co-
laborao.
13. Os diagramas de seqi.i ncia modelam a seqncia de eventos com o passar do tempo. Um
diagrama de colaborao modela as interaes entre os atares de um caso de uso. Os dois
tipos de diagramas so diagramas de interao. Entretant o, cada um adota um pont o de
vi sta diferente em relao ao sistema. Use diagramas de seqncia quando quiser cont ro-
lar eventos e di agramas de colaborao, quando quiser destacar relacionament os.
Os diagramas de at ividade o ajudam a modelar processos paralelos. Use diagramas dc
at ividade quando qui ser transmiti r o fato de que um processo pode ser executado em pa-
ralelo com outros processos, durante um cenri o de caso de uso.
14. Um modelo de domnio apresenta vrias vantagens. O modelo de domnio pode servir
como base ou esqueleto de seu modelo de objetos. Voc pode usar essa base como um
incio e construir a part ir dela.
Os modelos de dom ni o tambm fornecem um vocabulrio comum e um entendimento
do problema.
15. Os casos de uso o ajudam a entender o sistema, seus requi sitos e seus usos.
Os casos de uso podem aj ud-lo a planejar as iteraes de seu projeto.
Final mente, os casos de uso o aj udam a definir seu modelo de domnio.
Respostas
Respostas dos exerccios
1. Alguns outros casos de uso:


Remover lIem: um usurio pode remover um item do carrinho.
Exclui r Usurio: um administrador pode remover contas inativas.
517
Premiar Usurio: o sistema pode recompensar cl ientes freqentes, oferecendo des-
cont os dinamicamente.
2. O usurioseleciona um item do carrinho de compras. O usuri o remove O item seleciona-
do do carrinho de compras.
Remover Item.
I. O usuri o convidado seleciona um item do carrinho de compras.
2. O usuri o convidado pede ao carrinho para que remova o item:
Condies prvias.
O carrinho contm um item para remover.
Condies posteriores.
O item no aparece mais no carrinho.
Alternati va: Operao Cancelada.
O usuri o pode optar por cancelar a transao aps o passo I.
3. Os dois casos de LISO a segui r so variantes do caso de uso Pesquisar o Catlogo de Pro-
dutos:
Os usurios convidados podem pesquisar o catlogo de produtos.
Os usurios convidados podem procurar um item especfico.
Os doi s casos de LISO a seguir so variantes do caso de uso Assinar Not ilicaes:
Os usurios registrados podem assinar notifi caes.
Os usurios regi strados podem assi nar vrias li stas de mensagens.
4. Existem muitos outros obj etos de domnio. Aqui esto alguns: Administrador, Li sta de
Produtos Destacados e Lista de Pedidos.
Dia 10 Respostas do teste e dos exerccios
Respostas do teste
I. Existem trs vantagens em um projeto fonnal. Um proj eto formal o aj uda a descobri r
quais objetos aparecero em seu programa e como eles vo interagir ou se encaixar.
Apndice A
Um proj eto o ajuda a prever muitos dos problemas de projeto que apareceriam durante a
implementao. muito mais fcil corrigir um projeto antes que seja codificado.
Finalmente, um projeto ajuda a garanti r que todos os desenvolvedores estejam na mesma
pgina; caso contrrio, voc corre o risco de que cada desenvolvedor desenvolva partes
incompatveis.
2. POO o processo de construir o modelo de objetos de uma sol uo. Di lo de outra manei -
ra, POO o processo de decompor uma soluo em vrios objelos constitui ntes.
3. O modelo de objetos o projeto dos objetos que aparecem na soluo de um problema. O
modelo de objelos final pode conter muitos objelos no encont rados no domnio. O //10-
dela de objelos descrever as responsabil idades, relacionamentos e estrutura dos vrios
objetos.
4. Si mpl esmente no possivel prever cada deciso de projeto, antes que voc a tome, e
isso nem sempre vale a pena. Algum projeto pode ser deixado at a construo. Alm
disso, voc no quer ser pego tentando criar o projeto perfeito. Voc precisa comear a
codificar, algum dia.
5. As partes signi ficativas so aqueles aspectos do sistema que alteram completamente sua
estrutura ou seu comportamento. Essas so as partes que realmente importam, quando
voc codifica a soluo. Uma mudana em uma part e arquitetnica importante mudar a
estrutura da soluo.
6. Os cinco passos bsicos do POO so:
I. Gerar a lista inicial de objetos.
2. Refinar as responsabilidades de seus objetos atravs de cart es CRC.
3. Desenvolver os pontos de interao.
4. Detalhar os relacionamentos entre os objetos.
5. Construir seu modelo.
7. Comear com o domnio para gerar sua lista inicial de objetos. Cada objeto e cada atar do
domnio deve se tornar uma classe em seu model o de objetos.
Sistemas de tercei ros, interfaces de hardware, relatrios, telas e dispos itivos tambm de-
vem se tornar classes.
8. Um projeto completo capturar as responsabilidades de cada objeto, assim como a estru-
tura e os relacionamentos do objeto. Um projeto mostrar como tudo se encaixa.
9. Os cartes CRC oaj udam a identi ficar responsabil idades e colaboracsde cada classe.
10. Colaborao o relacionamento de delegao entre dois objetos. Voc pode considerar
uma colaborao como um relacionamento client e/servidor enlre dois obj ctos.
Respostas
I I. Prati camente, as responsabilidades se traduziro em mtodos. Os relacionamentos se tra-
duziro em uma estrutura; entretant o, um entendimento global das responsabi lidades o
aj udar a di vi dir as responsabil idades eficientement e entre os objetos. Voc precisa evi-
tar ter um conjunto pcqueno de objetos muito grandes. Atravs do projeto, voc garanti r
a disperso das responsabilidades.
12. Um carto CRC uma fi cha de arquivo 4x6 que o ajuda a descobri r as responsabi lidades
e colaboraes de um objeto, explorando casos de uso.
13. Voc est intencionalmente limitado pelo tamanho de um carto CRC. Se voc verificar
que est ficando sem espao, so boas as chances de que sua classe esteja fazendo coisas
demai s.
14. Voc deve usar cartes CRC durante os estgios iniciais do desenvolvi ment o, especial-
mente quando voc ainda for iniciante no desenvolvimento 00. Os cart es CRC sc pres-
tam para pequenos projetas ou para uma pequena seo de um projeto maior.
Voc s deve usar cartes CRC para descobrir responsabilidades e colaboraes. No
tente descrevcr relacionamentos complexos atravs de cartes CRe.
15. Os cartcs CRC no funcionam bem para projetos grandes ou para grupos de desenvolvi-
mento. Um grande nmero de classes pode atrapalhar uma sesso de cartes CRC. De-
senvolvedores demais tambm podem danificar uma sesso de cart es CRC.
16. Um ponto de interao qualquer lugar onde um objeto use outro.
17. Em um pont o de interao, voc deve considerar transformao de dados, alterao fut u-
ra, interfaces c o uso de agentes.
18. Um agente um objeto que faz a intennediao entre dois ou mai s objetos para cumprir
algum objetivo.
19. Voc vai definir as dependncias, associaes e general izaes. Detalhar esses relacio-
namentos um passo importante, pois isso define como os objetos se encaixam. Isso
tambm dcfine a est rutura interna dos vrios objetos.
20. Voc poderia cri ar diagramas dc classe, diagramas de atividade e diagramas de interao
para modelar seu projeto. A UML tambm define diagramas de objeto e diagramas de es-
tado.
Respostas dos exerccios
I. As instncias de Shoppi ngCart tero a responsabil idade global de conter itens. Especifi-
camente, um objeto Shoppi ngCart pode adicionar um item em si mesmo, remover um
item de si mesmo e permitir que um obj eto externo selecione um item, sem remov-lo.
Apndice A
Dia 11 Respostas do teste e dos exerccios
Respostas do teste
I. Uma classe adaptadora transforma a interface de um objeto naquela esperada por seu
programa. Um adaptador contm um objeto e delega mensagens da nova interface para a
interface do objeto contido.
2. O padro Iterator descreve um mecanismo para fazer lao pelos elementos de uma colc-
o.
3. Voc usaria o padro Iter ator para conter lgica de navegao em um local, fornecer
um modo padro de percorrer colees e ocultar do usuri o a implementao da colco.
4. O padro Adapter descreve um mecanismo que permi te transformar uma interface de ob-
jetos.
5. Voc usaria o padro Adapter quando precisasse utilizar um objeto que tivesse uma in-
terface incompatvel. Voc tambm pode usar empacotadores preventivamente, para
isolar seu cdigo das mudanas de APL
6. O padro Proxy intennedia de fonna transparente o acesso a um objelo. Os proxies adicio-
nam um procedimento indireto no uso do objeto.
7. Voc usaria o padro Proxy sempre que quisesse intennediar o acesso a um objetode ma-
neira que uma si mples referncia no pennite. Exemplos comuns incluem recursos re-
motos, otimi zaes e limpeza geral de objeto, como contagem de referncia ou reunio
de estatsti cas de util izao.
8. Nessa situao, voc pode usar o padro Adapter para criar uma interface independente
daquela fornec ida pela Sun, IBM ou Apache. Criando sua prpria interface, voc pode
permanecer independente da APl ligeiramente diferente de cada fornecedor. Empaco-
tando a bibl ioteca, voc est li vre para trocarde bibl ioteca a qualquer momento, seja para
migrar para uma nova verso ou para trocar de fornecedor, pois voc cont rola a interface
do adaptador.
9. Nessa situao, voc pode usar o padro Proxy para ocultar a identidade do objeto que ar-
mazena os dados dos objetos que o chamam. Dependendo da localizao do cliente,
voc pode instanciar um proxy interligado em rede ou um proxy local. De qualquer
modo, O restante do programa no notar a diferena; portanto, todos os seus objetos po-
dem usar uma interface proxy sem ter de se preocupar com a implementao subjacente.
10. O padro Proxy no muda uma interface, no sentido de que ele no retira nada dela.
Entretanto, um proxy est livre para adicionar mais mtodos e atributos na interface.
Respostas
Respostas dos exerccios
I.
LISTAGEM 11 .13 ShoppingCart . java
public class ShoppingCart 1
I
java.util.linkedlist items : new java.uti l .linkedlist() ;
r
* adiciona um item no carrinho
* @param item o item a ser ad i cionado
./
pu bl ic void add ltem( Item item ) {
items . add ( item);
I
r
* remove o item dado do carrinho
* @param item o item a ser removido
. /
publ ic void removeItem( Item item) (
items. remove( item )i
I
r
* @return int o nmero de it ens no carrinho
. /
public int getNumberltems() (
return items.size()i
I
r
* recupera o item indexado
* @param i ndex o lndice do item
* @ret urn Item o item no lndi ce
./
public Item get ltem( int index) {
return (Item) items.get( index )i
I
publ ic I terator iterator() (
I
II Arraylist tem um mtodo iterator() que retorna um iterator
/1 ent retanto, pa ra propS itos de demonstrao , ajuda ver um iterator
/1 simples
return new Cart l terator( items )i
521
Apndice A
LI STAGEM 11.14 CartIterator.java.
public class Cartlterator implements lterator {
}
private Object [] items;
private int index;
public Cartlterator( java . util.linkedlist items ) (
this.items items.toArray() ;
}
public bool ean isOone() {
}
if( index >z items.length ) {
return true ;
}
ret urn false;
publ iC Object currentItemO (
if( lisOone() ) I
return items [index];
}
return null;
}
publiC void next() {
index++;
}
publiC void f irst() {
index O;
}
2. Tornando o adaptador mutante, voc pode usar o mesmo empacotador para empacotar
muitos objetos diferentes e no precisa instanciar um empacotador para cada objeto que
precise ser empacotado. A reutilizao de empacotadores faz melhor uso da memria e
I ibera seu programa de ter de pagar o preo da instanciao de muitos empacotadores.
LI STAGEM 11.15 MutableAdapter.java
publ ic class MutableAdapter extends MoodyObject I
private Pet pet;
publi C Mu tableAdapter( Pet pet ) {
Respostas
LI STAGEM 11.15 MutableAdapter.java (continuao)
}
setPet( pet );
}
protec ted S t ri ng getMood () I
}
II implementando apenas porque exi gido
II por MoodyObject, pOis tambm sobrepe queryMood
II no precisamos disso
return pet.speak();
publi C yoid queryMoodO I
System. out.println( getMoodO );
}
public yold setPet( Pet pet ) I
this.pet pet;
}
Dia 12 Respostas do teste e dos exerccios
Respostas do teste
1. Uma classe empacotadora transfonna a interface de um objeto naquela esperada por seu
programa. Um empacotador contm um objeto e delega mensagens da nova interface
para a interface do objeto contido.
2. O padro Abstract Factory fornece um mecanismo que instancia instncias de classe des-
cendentes especficas, sem revelar qual descendente real mente criada. Isso permite co-
nectar, de forma transparente, diferentes descendentes em seu sistema.
3. Voc li sa o padro A bstract Factory para ocultar os detalhes da instanciao, para ocultar
a classe de objetos que instanciada e quando quer que um conjunto de objetos seja usa-
do junto.
4. O padro Singleton garante que um objeto seja instanciado apenas uma vez.
5. Voc usa o padro Singleton quando quer que um objeto seja instaneiado apenas uma
vez.
6. Usar constantes primitivas no uma estratgia de 00 para programao, pois voc tem
de aplicar um significado externo constante. Voc viu quantos problemas o desdobra-
mento da responsabilidade poderia causar!
Apndice A
o padro Typesafe Enum resolve esse problema, transformando a constante em um objeto de ni-
vel mais alto. Usando um objeto de nvel mais alto, voc pode encapsular melhor a responsabil i-
dade dentro do objeto constante.
7. Voc deve usar o padro Typesafe Enum quando se encont rar declarando constantes p-
blicas que devem ser objetos propriamente di tos.
8. No, os padres no garantem um projeto perfeito, pois voc poderia acabar usando um
padro incorretamente. Alm disso, usar um padro corretament e no significa que o res-
tante de seu projeto seja vl ido. Muitos projetos vlidos nem mesmo contm um padro.
Respostas dos exerccios
I.
LI STAGEM 12.19 Bank.java
publi c class Bank {
private java.util.Hashtable accounts = new java.uti l . HashtableO;
private statlc Bank ins tance;
protected Ba nkO {)
publi c stati c Ba nk getlnstance(){
i f( ins t ance nul l ) I
instance new Bank();
}
re t urn instance;
}
public voi d addAccoun t( String name , BankAccount ac count ) {
aceounts .put( name , aeeount ) ;
}
pu bl ic double total Ho l dings( ) {
doubl e total = 0.0;
}
java.ut il .Enurnerati on enum" accounts.elemen t sO ;
wh il e( enum.hasMoreElernents() ) I
}
BankAceount aeeount E (BankAccount) enum. nextEl ement();
t otal +- aecount.getBalance();
return total;
Respostas
LISTAGEM 12. 19 Bank.java (continuao)
J
publiC int totalAccounts() (
return accounts . size():
J
publi C void deposite Str i ng name , double ammount ) (
BankAeeount aeeount retrieveAeeount( name ):
if( aeeount ! - null ) (
aeeount .deposi tFunds( ammount ):
J
J
publie double balanee( String name ) {
J
BankAeeount aeeount ret r ieveAeeount( name ):
if( aeeount ! - null ) (
return aceount.getBalance{):
J
return 0.0:
private BankAecount retrieveAccount( String name ) (
return (BankAecount) accounts .get{ name );
J
2.
LISTAGEM 12.20 Level . java
publie fina l elass Level {
public fi nal
public fi nal
publie fi na 1
public fi na 1
statie Level NO ISE
stat1e Level INFO
slatie Level WARNING
statie Level ERROR
private int level:
private St ring name ;
new Level (
new Level (
new Leve 1 (
new Level (
private level( int level, String name ) {
this.level level :
thiS.name name :
J
publlc int getlevelO {
O, "NOISE" ):
1 , "INFO" ):
2, "WARNING" ):
3, "ERROR" ):
Apndice A
LISTAGEM 12.20 level. j ava (continuao)
}
return level;
}
public String getName() I
return name ;
}
LI STAGEM 12.21 Error . java
publ ic class Error 1
}
pr;vate Level level ;
public Error( Level level ) {
this.level level ;
}
publ iC Level getLevel() 1
return level;
}
publiC String toString() {
return level.getName ();
}
3. A soluo consiste em uma factory abst rata de conta bancria (escrit a como uma inter-
face; entretanto, ela tambm pode ser uma classe abstrata) e em uma Factory concreta de
conta bancria. A factory tem um mtodo para criar cada tipo de conta bancria.
Essa factory oculta os deta lhes da instanciao e no necessariamente o subtipo do objeto.
LI STAGEM 12.22 AbstractAccountFactory.java
publi c interface AbstractAccountFactory {
publ iC CheckingAccount createCheckingAccount( double i nitDeposit . int trans.
doubl e fee ) ;
publ ic OverdraftAccount createOverdraftAccount( double ini tOeposit. double
rate );
public RewardsAccount createRewardsAccount( double i nitDepos;t. double
interest . double min };
Respostas 527
LI STAGEM 12.22 AbstractAccountFactory . java (continuao)
publiC SavingsAccount createSavingsAccount( double initBalance. double
interestRate );
public TimedMaturityAccount createTimedMaturityAccount( double initBalance.
double interestRate. double feeRate );
I
LI STAGEM 12.23 ConcreteAccountFactory,java
public class ConcreteAccountFactory implements AbstractAccountFactory (
publiC CheckingAccount createCheckingAccount( double initOeposit . int trans .
double fee ) {
return new Checki ngAccount ( i ni tDepos i t . trans . fee ) ;
I
publ i c OverdraftAccount createOverdraftAccount( double initDeposi t . double
rate) (
return new OverdraftAccount( initOeposit . rate );
I
public RewardsAccount createRewardsAccount( double initOeposit. double
interest. double min } I
return new RewardsAccount( initOeposit. interest. min };
I
publi c SavlngsAccount createSavingsAccount( double initBalance. double
interestRate ) I
return new SavingsAccount{ i nitBalance . interest Rate );
I
publi C TimedMaturityAccount createTimedMaturi tyAccount( double i nit8alance.
double interestRate . double feeRate ) 1
return new TimedMatur ityAccount( ini t Balance. interestRate. feeRate ) ;
I
I
Apndice A
Dia 13 Respostas do teste e dos exerccios
Respostas do teste
I. A anlise, projeto e implementao de uma UI no so diferent es do restante do sistema.
A UI deve ter considerao igual durante todas as fases do desenvolvimento. Antes de
tudo, voc deve certificar-se de no ignorar as consideraes sobre a UI.
2. Voc deve desacoplar as Uls para que o sistema e a UI no se tomem entrelaados. difi-
cil fazer alteraes na UI, quando entrelaada com a funci onal idade bsica do sistema.
Tambm imposs vel compartil haro sistema com outras Uls ou tipos de UI, quando a UI
e o sistema esto entrelaados.
3. Os trs componentes so o modelo, o modo de visuali zao e O controlador.
4. O padro PAC e o Document/View Model so duas alternativas para o padro MVC.
5. O modelo a camada da trade MVC que gerencia o comport ament o bsico e o estado do
sistema. O controlador usa o modelo para instigar o comportamento do sistema. O modo
de visualizao usa o modelo para recuperar informaes de estado para exi bio.
O modelo tambm fomece um mecanismo de notificao de alterao. O modo de visua-
lizao e o controlador podem usar esse mecanismo para estar a par das mudanas de es-
tado no modelo.
6. O modo de visuali zao o membro da trade MVC responsvel por apresentar o modelo
para o usurio.
7. O cont rolador responsvel por interpretar os eventos gerados pelo usuri o. O cont rola-
dor insti ga o comportamento no modelo ou no modo de visual izao, em resposta a esses
eventos.
8. Um sistema pode ter muitos modelos. Um modelo pode ter muitos modos de vi sualiza-
o diferentes. Um modo de vi suali zao pode ter um controlador e um controlador pode
cont rolar apenas um modo de visualizao.
9. Ineficcias podem ser encontradas no modelo do modo de visuali7.ao c do controlador.
Um modelo deve evit ar notificaes de alterao de estado desnecessrias. Os modos de
visualizai'lo e controladores devem colocar os dados cm cache, quando possvel.
10. O padro MVC supe um modelo estvel e uma apresentai'lo varivel.
11 . Um resumo muito detal hado da histria e da moti vao por trs do padnl0 MVC est em
"Appl ical ions Programmi ng in Smal ltalk-80(TM): I-I ow to use Model- View-Conlroller
(MVC)", de Steve Burbeck, Ph.D. Voc pode encont rar uma cpia no endereo
http: //st-www.cs. ui uc.edu/users/smarch/ st-docs/ mvc.html
Respostas
Ento, qual o obj etivo dessa pergunta? Bem, a resposta proporciona a voc uma pers-
pecti va importante da moti vao por trs do padro MVC. Lendo a histria, voc tam-
bm notar que o padro MVC foi desenvolvido inicialmente como parte da Smalltalk.
Agora seu uso encontrado em quase qualquer li nguagem. Isso traz um ponto importan-
te: os padres no so ut ilizaes de linguagem - eles so padres que funcionam em
qualquer linguagem com os recursos requisitados.
A MVC no est relacionada com Java ou Smalltalk. Est relacionada a um projeto que
transcende a linguagem de implementao.
Respostas dos exerccios
I. A listagem 13.1 1 apresent a a nova classe Employee.
LI STAGEM 13.11 Employee. j ava
import java.util . ArrayLi st :
1 mport java. ut 11 . Itera tor :
publi C abstract c1ass Emp10yee {
private String firs t _name :
private String l ast_name ;
private double wage:
private ArrayList 11steners new Arrayli st() :
publi C Employee(Str ing first_name,St ring last _name,doubl e wage) {
thi s . first_name first_name :
this.last_name a last_name :
t hi s .wage wage;
}
pu bl iC double getWageO {
return wage:
}
publ ic voi d setWage( double wage ) {
this.wage wage ;
updateObservers() ;
}
publ ic String getFirstName() {
r eturn first_name ;
}
publi c St ring getLastName() I
Apndi ce A
LI STAGEM 13.11 Empl oyee.java (continuao)
}
return last_name ;
}
publiC abstract double calculatePay() ;
public abstract doubl e calcul ateBonus() ;
publ i c vold prlntPaycheck(l (
}
Stri ng full_name last_name + ", " + first_name;
System.out.print l n( "Pay: " + fu ll name + " $ " + calculatePay() );
public vold reglster( Observe r o ) {
listeners . add( o l ;
o.update() ;
}
publ ic void deregister( Observer o ) (
listeners.remove( o ) ;
}
private void updateObservers() (
Iterator i l isteners . iterator() ;
while( i.hasNext() ) (
}
2.
}
Observer o (Observer) i.next ();
o.update();
A Listagem 13. 12 apresenta a nova implementao de BankAccountController.
LISTAGEM 13.12 BankAccountControl 1er .java
publ ic class BankAccountController implements Ba nkActivityl istener {
I
}
private BankAccountView view;
private BankAccountMode l mode' ;
public BankAccountCont roller( BankAccountView view, BankAccountModel model )
this.view
this .modelo
view;
'" mode];
Respostas 531
LI STAGEM 13.12 BankAccount Controll er. java} (continuao)
}
publiC vold wlthdrawPerformed( BankAct l vityEvent e ) (
double amount e.getAmount();
model.wit hdrawFunds( amount );
}
public void deposltPerfonmed( BankAc ti vityEvent e ) (
doubl e amoun t a e.getAmount() ;
model . depositFunds( amount );
}
ESIa verso de BankAccountControl l er muito mai s fcil de ler do que a ori gi nal; entretanto, o
modo de visualizao agora muito mai s complexo.
Dia 14 Respostas do teste e dos exerccios
Respostas do teste
I. Erros de digitao, erros na lgica ou enganos bobos cometidos durante a codificao
podem surgir. Os erros tambm podem resultar da interao incorreta entre objetos ou de
falhas no projeto ou na anl ise.
2. Um caso de teste o bloco de construo dos testes. Cada forma de teste const ituda de
casos de teste e cada caso de teste testa um aspecto do sistema.
3. Voc pode basear seus casos de teste em teste de caixa preta ou cai xa branca.
4. Os testes de caixa branca so baseados na estrutura do cdigo- fonte subjacente. Os testes
de caixa branca so projetados para atingir 100% de cobertura do cdigo testado.
Os testes de caixa preta so baseados na especifi cao. Os lestes de caixa preta veri fi cam
se o sistema se comporta conforme o esperado.
5. As quatro formas de teste so: teste de unidade, leste de inlegrao, {este de e
teste de regresso.
6. Um teste de uni dade o dispositivo de teste de nvel mais baixo. Um teste de unidade en-
via uma mensagem para um objeto e verifi ca se recebe o resultado esperado. Um teste de
unidade s deve verificar um recurso por vez.
7. O leste de integrao confirma se os objetos interagem corretamente. O teste de sistema
verifi ca se o sistema se comporta conforme definido nos casos de uso e se ele pode mani-
pular uso imprevisto nonnal mente.
Apndice A
8. Voc no deve deixar as testes para o fim. Testarenquant o voc desenvolve o aj uda a en-
contrar erros imediatamente. Se voc deixar os testes para o final , haver mais erros e
eles sero mais difceis de rastrear e corrigir.
Testar enquanto voc desenvolve tambm toma mais faci l alterar seu cdigo e pode me-
lhorar seu projeto.
9. A validao manual ou visual propensa a erros. Voc deve evit-Ia o mxi mo possvel.
Em vez disso, voc deve contar com um mecanismo automtico para validao dos testes
de unidade.
10. Uma estrutura define um modelo de domnio reut ilizvel. Voc pode usar as classes des-
se modelo corno base para seu apli cativo espec fi co.
I I . Um objeto falsificado um substituto simplista de um objelo real , que o ajuda a fazer o
teste de unidade de seus objetos.
12. Os objctos fal sificados permitem que voc faa o teste de unidade de suas classes isola-
damente. Eles tambm abrem possibilidades de teste que, de outra forma, seriam di ficei s
ou impossveis de fazer.
13. Um erro surge de uma falha ou de um defeito no sistema. Uma condio de erro, por ou-
tro lado, no um erro, mas sim uma condio para a qual seu sistema deve estar prepara-
do e deve manipular normalmente.
14. Ao escrever seu cdigo, voc pode garantir a qualidade atravs dos testes de unidade, do
tratamento correto de excees e atravs de documentao correta.
Respostas dos exerccos
I. Cookstour dar idias sobre o projeto e as noes por trs de JUnil.
2. A Li stagem 14.12 apresenta um possvel teste de unidade.
LI STAGEM 14.12 HourlyEmpl oyeeTesLjava
import juni t. framework .TestCase :
i mport junit.framework.Assert ;
public cl ass HourlyEmployeeTest extends TestCase {
private HourlyEmployee emp:
private
private
private
static
static
statlc
f i na l
fi nal
fi nal
St r ing FI RST NAME
String LAST NAME
double WAGE
protected void setUp() {
= -FNAME"

= -LNAME"

= 500 . 00;
Respostas
LI STAGEM 14.12 HourlyEmpl oyeeTest . java (cont inuao)
}
emp new Hourl yEmp loyee( FIRST_NAME. l AST NAME . WAGE );
}
publiC yoid test_calculatePay() (
emp . addHours( 10 );
doubl e expected WAGE * 10;
assertTrue( "incorrect pay calculation" . emp.calculatePay() expected );
}
publi C HourlyEmployeeTest( String name ) (
supere name );
}
Dia 15 Respostas do teste e dos exerccios
Respostas do teste
I. PlayerListener um exemplo do padro observvel.
Consol e singlcton. Ele implementa o padro si ngleton.
Rank e Sui t implementam o padro Typesa fe Enum.
2. 81 ackjackDea 1 er trata de HumanPlayer de forma polimrfica como um P1 ayer. Voc p0-
deri a criar jogadores no humanos e B1 ackjackDea1 er saberia como jogar viruee um
com eles.
3. Pl ayer!B1ackjackDealer/HumanP1ayer um exemplo de hierarquia de herana.
4. Deck encapsul a completament e os objelos Card que contm. Ele no fornece quai squer
mtodos de obteno ou configurao. Em vez disso, Deck adiciona seus objetos Card em
objetos Deckpile.
5. B1 ackjackDea 1 er e HumanP1 ayer atuam de fonna polimrfi ca., fornecendo suas prprias ver
5eS personal izadas do mtodo hi t(). Quando o mtodo p1 ay() chamar hi t() , o comporta
mento do mtodo p1ay() variar de acordo com a implementao subjacente de hi te).
Respostas dos exerccios
I. Sem resposta.
2. Sem resposta.
Apndice A
Dia 16 Respostas do teste e dos exerccios
Respostas do teste
I. As est ruturas condicionais so peri gosas quando reti ram responsabilidade de um objeto e
a colocam em outro lugar. O comportamento pertence ao objeto e no distribudo por
todo o programa. Uma lgica distri buda o obriga a repeti r lgica por todo o seu progra-
ma, em vez de t- la em apenas um lugar.
As est ruturas condicionais tambm so perigosas porque tornam mais difcil testar um
objeto e cobrir todas as combinaes de caminhos atravs do objeto.
2. Antcrionncnte, voc viu que podia usar polimorfismo para remover estruturas condicionais.
Hoje, voc vi u que pode usar uma combinao de polimorfi smo e estado para remover
estruturas condicionai s. O estado um modo excelente de implementar regras.
3. A verso anterior de Hand exigia que voc mesmo comparasse os objetos Card de Hand
para veri ficar se dois objetos Hand so iguais ou se um objeto Hand maior do que out ro.
Agora, Hand faz essa verificao para voc, sem comprometer seu estado interno.
Hand faz out ra coisa para se encapsular. Agora, Hand infonna aos receptores de mudanas
de estado. Como Hand coloca prontamente suas infornl aes de estado nos receptores,
no h moti vo para que um objeto interessado faa uma consulta em Hand para conhecer
seu estado.
4. Hand e Handlistener implementam padro observador.
5. Sem resposta.
Respostas dos exerccios
I. Sem resposta.
2. O segredo desse problema perceber que todos os mtodos levam as mesmas aes para
cima, at o ponto onde uma chamada feita em Pl ayerl i s t encr. A soluo empacotar
essa chamada em um objeto.
Considere o mtodo noti fyl i stener() a seguir:
protected void notifylisteners( Not"ifyHelper helper ) {
I terator i = listeners. i terator() ;
}
while( LhasNext() ) {
}
Playerl istener pl = ( Player listener )i.next() ;
helper.notifylistener( pl l;
Respostas
Note que esse mtodo exalamenle igual ao ant igo not i fyChangedO ou not i fyBusted() ,
exceto quanto a uma diferena. Em vez de chamar um mtodo diretamente em PI ayerl i s-
tener, o mtodo noti fyl i steners() delega a chamada para um objeto fiot i fyHel per.
A Listagem 16.17 apresenta NotifyHel per.
LISTAGEM 16.17 O estado de espera da banca personalizado
protected i nterface Not i fyHelper I
J
publ ic void not ifylistener( Playerlistener pI )i
A interface NotifyHelper define um mtodo: notifylistenerO. Os implementadores
decidiro qual mtodo vo chamar em Playerlistener.
Ao todo, voc precisar defini r sete implementadores de Not 1 fyHe I per, uma implemen-
tao para cada mtodo na interface PI ayerl i stener. A Listagem 16.18 apresenta essas
sete implementaes.
LISTAGEM 16.18 As impl ement aes de Not HyHe lper .
protected cl ass NotifyBusted impleme nts Not ifyHe l pe r {
public void notifyl i stener( Pl ayerl istener pI ) {
pl . playerBusted( Pl ayer. this l i )
J
protected class NotifyBlackj ack impl ements NotifyHe lper I
publi c void notifyl i stener( Playerlistener pI ) {
pl .playerBlackj ack( Player . this )i }
J
protected cl ass Noti fyWon implements Not i fyHelper (
publ ic voi d notifylistener( Playerl istener pI ) (
pl.playerWon( Pl ayer. thi s ) i )
J
protected cl ass Not1fylost implements NotifyHelper (
publi c voi d notify l i stener( PlayerListener pI ) I
pl.playerlost( Player.thi s )i )
J
protected class NotifyCh anged implements NotifyHelper I
publ ic voi d notifylistener( Playerlistener pI ) I
pl . playerChanged( Player.this ) ; )
J
protected class NotifyStanding implements NotifyHelper I
public void not ifyli stener( Player listener pI ) (
pl.playerStandi ng( Playe r. thi s ); )
J
protect ed cl ass NotifyStandoff implements Noti fyHe l per I
Apndice A
LI STAGEM 16.18 As implementaes de NotifyHe1per . (continuoo)
pub1iC vold notifyListener( PlayerListener pI ) (
p1.playerStandoff( P1ayer . this ); I
,
Agora, em vez de chamar not i fyChanged () ou not i fyB1 ac kj ac k (), voc chamaria not i fy-
listeners( new NotifyChanged() ) ou notifyListeners( new NotifyBlackjack() ).
Se voc acha que essa uma boa soluo ou no, uma questo de gosto pessoal. Emre-
tanto, e la remove os mtodos notifyXXX redundantes.
Dia 17 Respostas do teste e dos exerccios
Respostas do teste
1. Tomar abstrato um mtodo protegido uma boa maneira de estabelecer um protocolo de
herana.
2. Aps a anlise e o projeto de hoje, uma nova hierarquia PI ayer foi descoberta. Como os
requisitos se apresentaram atravs dos casos de uso, a necessidade de uma nova hierar-
qui a de herana se apresentou.
3. A programao por especulao rarament e funciona. As hierarquias que voc precisar
para modelar corretamente um domnioabslralo se apresentaro aps voc ter traba lhado
com um domnio por algum tempo. Se voc lentar abstrair um domnio sem trabalhar
com esse domnio, estar supondo uma soluo.
4. Refazendo a hierarquia, voc ficou com um modelo que representa mais detalhadamente
o j ogo vi nte-e-um. O cdigo tambm mais fc il de entender. Colocar responsabi li dade
ext ra na classe base Player teria resultado em um cdigo difici l de entender.
Respostas dos exerccios
I. Sem resposta.
2. Dobro apenas outro estado de Betti ngPI ayer. Voc sabe que ele precisa ser um estado
separado, porque Pl ayer deve reagir de uma fonna diferente ao evento handPlayable.
Em vez de permanecer no estado Jogo, PI ayer deve fazer a transio para o estado Para-
do.
A Figura A. 7 ilustra o novo diagrama de estado para um objeto Bett ingPl aye r que pode dobrar.
FIGURA A.7
O diagrama
de estadQ de
BettiogPlayer
(lluali: lIdo.
mio 6 ,,1!>!&+Um
I
CClm' 11'110

Respostas
(mio Inld.1
dobto(
/' d' )011"
com.m'"

mto Iourou
(mio>21(
537
mio .1t01lroU
(11'160>21)
Voc tambm precisa alterar o estado Jogo para que ele possa fazer a transio para o estado Do-
bro. A Listagem 17.6 apresenta os novos estados de Bett i ngPl ayer.
LISTAGEM 17.6 Ooub 1 i ngDown e Jogo
pri vate class OoublingOown implements PlayerState {
publlc void handChanged() {
notifyChanged() ;
I
public voi d handPlayable() {
setCurrentState( getStandingSt at e() ) ;
notifyStand1 ng() ;
I
public voi d handBlackjack( ) {
II imposs ivel no estado de dobro
I
publ i c voi d handBusted() {
setCurrentState( getBustedState() ) ;
not ifyBus ted () ;
I
publ ic void execute( Dealer deal er ) {
bank .doubl eOown();
I
deal er.hit( BettingPlayer . t hi s ) ;
getCurrentState().execute( deal er );
I 538 Apndice A
LI STAGEM 17.6 DoubllngDown e Jogo (continuao)
I
private class Be tterPl ayi ng i mplements PlayerState (
public voi d handChanged{) (
I
not ifyChanged();
I
public void handPlayable(} (
II pode ignorar no estado de jogo
I
public v01d handBlackjack() (
II imposs fvel no estado de jogo
I
publi C void handBusted() {
I
setCurrent S t ate ( getBus tedS ta te () ) ;
not ifyBusted () ;
publ ic void execute( De aler dealer ) (
I
if{ getHand().canDoubleDown() &&doubleDown() ) (
set Current State( getDoublingDownState() );
getCurrentState().execute( dealer );
return;
if( hit() I (
dealer.hit{ Bett i ngPlayer.this ) ;
I else (
I
setCurrentState ( getStandingState() );
notifyStanding() ;
getCurrentState().execute( dealer );
II transio
I
Voc tambm precisar atualizar HumanPl ayer para que oferea a opo de dobrar. A Lis-
tagem 17.7 apresenta a classe HumanPlayer atualizada.
LI STAGEM 17.7 Huma nPlayer . java
publiC class HumanPlayer extends BettingPlayer {
private f inal static String HIT
= MH"

private fi na 1 static St r ing STAND
- S"
- .
private fi na 1 static St r i ng PlAY_HSG '" "[H]it or (S]tay" ;
pri vate fi nal stat ic St r i ng BET_MSG = MPlace Bet: [10] [50] or [100]" ;
private fi nal stat i c String OD_MSG = MDouble Down? [V] es [N]o";
Respostas
LI STAGEM 17.7 HumanPlayer.java (continuao)
private fi na 1 static String BEl_lO = MIO";
priva te final static String BEl_50 = MSO";
private f i nal stati c String BEI_I00 = MIOO
M
;
private fi na I statlc String NO " "NN;
pri vate fi na I static Str i ng YES = "Y";
pr ivate fi nal stati c Str ; ng OEFAULI = "invalid";
publ ic HumanPlayer( String name , Hand hand. Bank bank ) {
supere name , hand. bank };
I
protected boolean hit() (
I
while( true ) (
I
Console.INSIANCE . printMessage( PLAY_MSG ) :
String response Consol e.INSTANCE.readInput( DEFAUlI );
if( response . equals IgnoreCase( HII ) ) {
return true:
lelse if( response.equalsIgnoreCase( SIAND ) ) I
return fal se ;
I
II se chegarmos at aqui . faz um lao at obtermos entrada
II significativa
protected boolean doubleOown() I
I
while( true ) I
Console.lNSIANCE.printMessage( OO_MSG ) ;
I
String response Console.INSIANCE.readInput( OEFAULI ,;
if( response .equal sI gnoreCase( NO) ) {
return fal se;
} el se if( response.equalsIgnoreCase( YES ) ) I
return true ;
I
II se chegarmos at aqui, faz um lao at obtermos entrada
II significativa
protected void betO (
while( true ) (
Console . INSTANCE.printMessage( BET_MSG ):
Str i ng response " Console. INSTANCE . read Input( DEFAULT l:
if( response.equals( BEl_lO) ) I
getBank().placelOBet():
I 540 Apndice A
LI STAGEM 17.7 HumanPlayer.java (continuao)
I
I
I
return ;
I
if( response.equal s ( BEl_50) ) (
getBank().place50Bet() ;
return;
I
if( response,equals( 8EI_IOO) ) {
getBank ( ).placel OOSet() :
return ;
I
/1 se chegarmos at aqui, faz um l ao at obtermos entrada
/1 s i gnificativa
Dia 18 Respostas do teste e dos exerccios
Respostas do teste
1. Para introduzir um Vcard, voc pode si mplesmente fazer lima subclasse de Cardo Para co-
loc- Ia no jogo, voc pode fazer uma subclasse de Oeck e, em seguida, sobrepor bui 1 d-
Cards para que a subclasse crie objetos VCa rd, em vez de objetos Cardo
2. Originalmente, o mtodo bui 1 dCa rds de Deck era privado. Quando veri ficamos que uma
subclasse precisava sobrepor o comportament o de bui 1 dCards, o tornamos protegido.
Respostas dos exerccios
I. Sem resposta.
2. O projeto e implement ao inici ais que fizemos para o Exerccio 2 do Captulo 17 ainda
so vl idos. Dobrar ape nas outro estado em Sett i ngPl ayer. Voc deve comear escre-
vendo o cdigo para este exerccio, adicionando o novo estado Ooubl i ngOown em Bet -
tlngPlayer. Voc tambm precisar fazer as mesmas alteraes fe itas no Captulo 17,
nas classes Bank e Hand. Quando fi zer essas alteraes, voc precisar atualizar GUI Pl a-
yer, assim corno Opt i onView e Opt ionViewCont roll er .
Antes de fazer as alteraes exigidas nas classes de modo de visualizao e de controla-
dor, examinaremoS as alteraes exigidas em SettingPlayer, Hand e Bank.
A Listagem 18.13 destaca as alteraes que foram feitas na classe Hand.
Respostas 541
LI STAGEM 18.13 Destaques das alteraes feitas em Hand
publ i c boolean canDoubleOown() {
return ( cards. slze() 2 );
,
o novo mtodo canOoubleDown pennite que Be tt i ngPl ayer veri fi que o objeto Hand para
ver se o jogador pode dobrar.
Voc tambm precisa adicionar um novo mtodo doubl eDown na classc Bank. A Listagem
18. 14 apresenta esse novo mtodo.
LI STAGEM 18.14 O novo mtodo doubleDown
publ ic void doubl eDownO (
placeBet( bet ) ;
,
bet bet .. 2;
o mtodo doubleOown dobra a aposta corrent e.
Para poder adicionar a funo de dobrar, voc precisa adici onar um novo estado em Bet -
tingPl ayer. Voc sabe que precisa de um novo estado porque Bett 1 ngPl ayer tem de tra-
tar do evento handPlayable, especial mente ao se dobrar. Normalmente, um evento
handPl ayable significa que o j ogador pode receber mai s canas novamente, se quiser. Ao
dobrar, O jogador deve parar imediatamente, aps a operao (caso ele no estoure). A
Listagem 18.15 apresenta o novo estado de DoubleDown.
LISTAGEM 18.15 The New Doubl eDown Stat e
private class DoubllngDown implements PlayerState (
public void handChanged() {
noti fyChanged( );
,
publ ic voi d handPlayable () {
setCurrentState( getStandingStat e() ) ;
notifyStandi ng();
,
publ ic void handBlac kjack() {
II i mpossfvel no estado de dobro
,
publ ic void handBust ed() {
setCurrentState( get Bust edStat e() };
not i fyBusted();
,
publi c void execute( Dea l er deal er ) {
Apndice A
LISTAGEM 18.15 lhe New OoubleOown State (continuao)
J
J
bank.doubleOown();
dealer.hit( BettingPlayer.this );
getCurrentState().execute( dealer ) i
Quando executado, esse novo estado dir ao objelo Bank para que duplique a aposta, pe-
di r banca para que distribua mais cartas para o jogador e, ento, far a transio para o
prximo estado. O estado seguinte ser parado ou estouro, dependendo do evento envia-
do para o estado por Hand.
Para obter o estado Doubl i ngDown (Dobro), voc precisar fazer algumas alteraes no
estado Jogo. A Li stagem 18.16 apresenta o novo estado BetterPlaying.
LI STAGEM 18.16 O novo estado BetterPl ayi ng
private class BetterPlaylng implements PlayerState (
public void handChanged() I
J
notifyChanged();
J
publi C vold handPlayable() I
II pode ignorar no estado de jogo
J
publi c vold handBlackjack() (
II impossfvel no es tado de jogo
J
public voi d hand8usted() I
setCurrentState( getBustedState() ) ;
notHyBustedO;
J
public void execute( Dealer dealer ) (
J
if( getHand() . canDoubleDown() &&doubl eDown() ) (
setCurrentState( getDoublingDownState() );
getCurrentState().execute( dealer );
returni
J
if( hit() J (
dealer.hit( BettlngPlayer.this ,;
) else I
J
setCurrentState( getStandingState() ) i
notifyStanding();
getCurrenlState().execute( dealer ) ;
II transio
Respostas
Quando executado, o estado BetterPl aying pri meiro verifica se o jogador pode dobrar.
Se assim for, o estado chamar o mtodo doubl eOown de Betti ngPl ayer (voc precisar
adicionar um mtodo abstrato doubleOown em Betti ngPl ayer). Seo mtodo indicar que o
jogador gostaria de dobrar, o estado BetterPl ayi ng configurar o estado corrente como
Ooub 1 i ngDown e far a transio para ele.
Se o jogador no quiser dobrar, O estado continuar ejogar nonnalmente. Veja todas as
alteracs no cdigo-fonte. Existem algumas outras pequenas alteraes, como a adio
de um mtodo getOoubl eDownState em BettingPl ayer. Esse mtodo efetivamente adicio-
na a possibilidade de dobro no sistema.
Agora, voc precisa al ualizar GUI PI ayer, Opt i onView e Opti onVi ewControll er.
A boa nova que voc no precisa fazer quaisquer alteraes nos estados de GU I PI ayer.
Esses estados no devem fazer nada, pois eles precisam esperar at que o jogador huma-
no cl ique em um boto. Voc precisa implementar o mtodo doubleOown. A Li stagem
18.17 apresenta o mtodo.
LI STAGEM 18.17 O mtodo doubleDown
protected boolean doubleOown() I
setCurrentState( getOoubl i ngOownState() ):
getCurrentState().execute( dealer ):
return true;
}
o boio da G U I pode chamar esse mtodo, caso o usurio decida dobrar. O mtodo con-
figura o estado corrente como o dobro e, em seguida, faz a transio para ele. O estado
manipula o restante.
Todas as alt eraes restantes precisam entrar em Opt i onVi ew c Opt i onVi ewControll er.
Voc precisa principalmente adicionar um boto de dobro no modo de visualizao e ga-
rantir que ele seja ativado pelo controlador imediatamente aps a aposta e desativado as-
sim que o jogador pressionar esse boto, o balo de parada ou o de receber mai s cart as.
No se preocupe mui to, se voc no entender totalmente o cdigo da GU!. O importante
que voc entenda como a operao de dobro adicionada no sistema e as idias bsicas
por trs do modo de visualizao e do controlador.
Dia 19 Respostas do teste e dos exerccios
Respostas do teste
1. As trs camadas so: aprese,,/ao, abstrao e eDil/role.
Apndice A
2. A apresentao responsvel por exibir a abstrao, assim como por responder intera-
o do usurio.
A abslraoesemelhante ao modelo na MVC. A abstrao representa o sistema bsico.
O controle responsvel por pegar as diversas apresentaes ecombin-Ias em um modo
de visuali zao.
3. Voc pode usar herana para fazer uma subclasse de cada uma das classes de sistema que
exigiro uma apresentao. Desse modo, voc no enxerta uma classe de apresentao
diretamente na c lasse de sistema. Em vez disso, voc pode adicionar a classe de apresen-
tao na subc lasse.
Usa ndo herana dessa maneira, voc pode fornecer vrios modos de visuali zao do
mesmo sistema. Sempre que voc precisar de um modo de visuali zao diferente, bastar
fazer uma subclasse das classes que preci sa exibir e faz- Ias criar uma nova apresenta-
o. Quando voc precisar reunir todas as classes como um apl icat ivo, bastar garant ir a
instanciao das subclasses corretas.
,
4. E melhor usaro PAC em um sistema estvel com requisitos de int erface bem definidos.
,
As vezes, a est ratgia da herana pode fa lhar para projetas mai s complicados. Quando a
herana fa lhar, voc ter de enxertar a apresentaodiretamente na classe de sistema. Tal
eventualidade lorna dincil servir muitos modos de visualizao diferentes.
5. Voc conseguiu manter duas Uls porque de ixou a estrutura de observador intacta. Nada
o obri ga a remover a estrut ura, apenas porque voc utiliza PAC. Na verdade, Sett ingVi-
ew e Oea l erView usam o mecanismo Pl ayerl i stener para fi car a par das alteraes no jo-
gador e na banca.
6. O padro factory foi usado para garant ir que as instnc ias de classe corretas fossem usa-
das juntas. Em particular, voc deve tomar ocuidado de usar um objeto VOeck quando uti-
lizar as classes que criam uma apresent ao.
Respostas dos exerccios
I. Sem resposta.
2. O projeto e a implementao ini ciais que voc reali zou para o Exerccio 2 do Capitulo 17
ainda so vlidos. Dobro apenas outro estado em Sett i ngPl ayer. Voc deve comear a
escrever o cdigo deste exercici o, adicionando o novo estado Ooubl i ngOown em Bett ing-
Pl ayer. Voc tambm precisar fazer as mesmas alteracs que fez no Capitulo 17, nas
classes Bank e Hand. Quando voc fizer essas alteraes, precisar alualizar GUIPlayer e
sua classe de apresentao.
Ant es de fazer as alteraes exigidas nas classes da GUI, vamos examinar as alteraes
exigidas em BettingPl ayer, Hand e Bank.
Respostas
A Listagem 19.8 destaca as alteraes que foram feitas na classe Hand.
LISTAGEM 19.8 Destaques das alteraes feitas em Hand
publlc boolean canDoubleDownO {
return ( cards.size() ZE 2 };
I
o novo mtodo canDoubleDown permite que Bett; ngPl ayer verifique o objeto Hand para ver se o
jogador pode dobrar.
Voc tambm precisa adicionar um novo mtodo doubleDown na classe Bank. A Listagem 19.9
apresenta esse novo mtodo.
LI STAGEM 19.9 O novo mtodo doubl eOown
publ ic void doubl eDown() (
placeBet( bet );
I
bet bet ... 2;
o mtodo doubleDown dobra a aposta corrente.
Para adicionar a aposta em dobro, voc precisa adicionar um novo estado em Bett ; ng-
PI ayer. Voc sabe que precisa de um novo estado, porque Bett; ngPlayer tem de tratar do
event o handPI ayabl e de uma maneira especial quando se dobra. Nonnalmente, um even
to handPlayable significa que o jogador pode receber mais cartas novament e, se quiser.
Ao dobrar, O jogador deve parar imediatamente aps t-lo fei to (caso ele no estoure). A
Listagem 19.10 apresenta o novo estado Doub 1 eOown.
LI STAGEM 19. 10 O novo estado DoubleDown
private class DoubllngDown 1mplements PlayerState {
public void handChanged() {
notifyChanged();
I
public void handPlayable() {
setCurrentState( getStandingState() ) ;
notlfyStanding();
I
public void handBlackjack() {
II 1mpossfvel no estado de dobro
I
publ ic void handBustedO {
setCurrentState( getBustedState() l ;
Apndice A
LISTAGEM 19.10 O novo estado OoubleOown (continuao )
}
not1 fyBustedO i
}
public voi d execute ( Dea l er dealer ) {
bank .doubleDown()i
}
dealer.hit( BettingPlayer.this ) i
getCurrentState() . execute( dealer )i
Quando executado, esse novo estado diz a Bank para que duplique a aposta, pede banca
para que di stribua mai s cartas para o jogador e, em seguida, faz a transio para o prxi-
mo estado. O estado seguinte ser parado ou vai estourar, dependendo do event o que for
envi ado para o estado por Hand.
Para obter o estado Doub 1 i ngDown, voc precisar fazer algumas alteraes no estado
Jogo. A Li stagem 19. 11 apresenta o novo estado BetterPlayi ng.
LISTAGEM 19.11 O novo estado Jogo
private class BetterPlaying implements PlayerState (
publi c void handChanged{) {
noti fyChanged()i
}
public voi d handPlayable( ) {
II pode ignorar no estado de jogo
}
public voi d handBl ackjack() I
II impossfvel no estado de j ogo
}
publi c voi d handBusted() {
setCurrent State( getBustedStateO };
not ifyBusted () i
}
publi c yoi d executeI De aler dealer ) {
if( getHand (), canDoubleDown() && doubleDown() ) (
setCurrentState( getDoubl i ngDownState() )i
getCurrentState().execute( dealer l i
returni
}
if( hitO } I
dealer .hit( Betti ngPl aye r . thi s li
) else (
set Current State( getStandingState () ) i
notifyStanding() ;
Respostas 547
LI STAGEM 19.11 O novo estado Jogo (continuao)
}
}
}
getCurrentState().execute( dealer );
II trans io
Quando executado, o estado BetterPl aying primeiro verifica se o jogador pode dobrar.
Se assim for, o estado chamar o mtodo doub 1 eDown de Betti ngPlayer (voc precisar
adicionar um mtodo abst rato doubl eDown em Bett i ngPl ayer). Se o mtodo indicar que o
jogador gostaria de dobrar, o estado BetterPl ayi n9 configurar o estado corrente como
Doub 1 i ngDown e depoi s far a transio para ele.
Se o jogador no quiser dobrar, o estado continuar e jogar normalmente. Veja todas as
alteraes no cdigo- fontc; cxistem algumas outras pequenas alteraes, como a adio
de um mtodo getooubleOownState em BettingPl ayer.
Voc efeti vamente adicionou a capaci dade de dobrar no sistema. Agora, voc precisa
atuali zarGUIPl ayer e sua classe de apresentao, para que possa suportar a aposta em do-
bro.
A boa nova que voc no precisa fazer quaisquer alteraes nos estados de GUIPl ayer.
Esses estados no fazem nada, pois eles precisam esperar at que o jogador humano cli-
que em um boto. Voc precisa implement ar o mtodo doub 1 eOown. A Listagem 19.12
apresenta o metodo.
LISTAGEM 19.12 O mtodo doub 1 eOown
protected boolean doubleDown() f
setCurrentState( getOoublingOownState() ) ;
getCurrentState() .execute( dealer ) ;
return true;
}
o boto da GUI pode chamar esse mtodo, caso o usurio decida dobrar. O mtodo con-
fi gura o estado corrente como dobro e, em seguida, faz a transio para ele. O estado trata
do resto.
Todas as alteraes restantes precisam entrar na classe de apresentao: GUIView. Voc
precisa adicionar um boto de dobro, cert ificar-se de que ele seja ativado aps a aposta e
desalivado assim que o jogador pressionar esse boto, o boto de parar ou de receber
mais cartas.
Apndice A
No se preocupe muito, caso voc no entenda 100almente o cdigo da GUI. O importan-
te que voc entenda como a capacidade de dobrar adicionada no sistema.
Dia 20 Respostas do teste e dos exerccios
Respostas do teste
I. Atravs dos relacionamentos com capacidade de substitui o e do pol imorfismo, voc
pode criar qualquer subclasse de Bett i ngPl ayer que queira e adicion-la ao jogo.
O jogo no sabe a diferena entre um jogador humano e um jogador automtico
no-humano. Como res ultado, voc pode configurar o jogo sem nenhum jogador huma-
no.lmplementando o mtodo hi t nas subclasses de Pl ayer, elas podero j ogar sem int er-
veno humana.
2. Voc nunca deve seguir a estratgia de OneHHPlayer.
Respostas dos exerccios
I. Sem resposta.
2. Suas solues podem variar. As listagens 20.8 e 20.9 apresentam a implementao de
Knowl edgeablePlayer e OptimalPlayer, respecti vamente.
LISTAGEM 20.8 Knowl edgeab 1 ePl ayer .java
publ i c class KnowledgeablePlayer extends BettingPl ayer I
publiC KnowledgeablePlayer(Stri ng name,Hand ha nd ,Bank bank} I
super( name , hand , ba nk };
I
publi c boolean hit ( Dealer dealer ) {
i nt total get Hand O . tota 1 () ;
Card card dealer.getUpCard();
II nunca recebe mais cartas , no importa qual, se total> 15
if( total> 15 ) {
return fal se ;
I
II sempre recebe mais ca rtas para 11 e menos
if( tolal <z 11 ) I
return l r ue ;
I
Respostas
LISTAGEM 20.8 Knowl edgeab 1 ePl ayer . java (continuao)
J
J
II 1sso deixa ll. 12. 13. 14
II baseia a d e i s ~ o na banca
i f( card.getRank().getRank() > 7 ) (
return true;
J
return false;
publi C yoi d bet() 1
getBankO .placel OBet();
J
LI STAGEM 20.9 OptimalPlayer.java
publiC class Op timalPlayer extends BettingPlayer (
publ ic Opt imalPlaye r( Stri ng name, Hand hand , Bank bank ) (
supere name , hand, bank );
J
publi c boolean hit ( Oeal er dealer ) {
i nt total getHandO.totalO;
Card card dealer.getUpCard(};
i f( total >- 17 ) {
return fal se;
J
;t( total 16 ) {
J
if( card.getRank(} Rank.SEVEN I I
card.getRankO == Rank.EIGHT II
card . getRank() Rank.NINE ) {
return true;
I else (
return fa 1 se;
J
; f( t otal 13 II total == 14 I I total == 15 ) (
if( card. getRank( ) Rank.TWO II
card.getRank() Rank.THREE I I
I 550 Apndice A
LI STAGEM 20.9 Opt imal Player . java (continuao)
}
card.getRank ()
card . getRank()
card . getRank{)
return false;
} else {
return true;
}
}
if( total 12 ) (
if( card. getRank()
card.get Rank(}
card.getRank{)
return false ;
} el se {
return truei
}
}
return true;
}
publiC void bet() I
getBank().placel0Bet{);
}
==
Rank.FOUR II
Rank.FIVE I I
Rank.S IX ) {

'ao'. 'OU, II
==
Rank . FIVE I I
Rank . SIX ) {
Ento, corno esses jogadores se companam?
Em nossos lestes, Knowl edgeablePlayer e OptimalPlayer executam melhor do que
SmartPl ayer, apresentado no capt ulo. Comparando um com outro, Opt lmal PI ayer exe-
cuta melhor.
Contudo, com o passar do tempo, ambos ainda perdem dinheiro, apenas que muito lenta-
mente.
3. Suas solues podem variar. As listagens 20.10 e 20.1 1 apresentam a implementao de
Knowl edgeabl ePl ayer e Optima 1 PI ayer, respectivamente.
LI STAGEM 20.10 Knowl edgeab 1 ePl ayer .java
public class KnowledgeablePlayer extends BettingPlayer I
public KnowledgeablePlayer(String name , Hand hand, Bank bank) (
super( name . hand. bank );
}
Respostas
LI STAGEM 20.10 Knowl edgeab 1 ePl ayer . java (continuao)
J
publiC boolean doubl eDown( Oealer d ) {
i nt total getHand (). to ta 1 ():
if( total 10 Il total .... 11 ) (
return t rue:
J
return false :
J
public boolean hit( Oealer d ) (
J
int total " getHand() . total () ;
Card c " d.getUpCard():
II nunca recebe mais cartas , no importa qual , se total> 15
if( total> 15 ) {
return fal se :
J
II sempre recebe mais cart as para 11 e menos
if( total <" II ) {
return t rue:
J
II isso deixa 11, 12. 13. 14
II baseia a decisao na banca
if( c.getRankO .getRank() > 7 ) (
return true;
J
return fal se :
publi C yoid bet() {
getBank() . place10Bet():
J
LI STAGEM 20.11 OptimalPlayer. java
publ i C class Opt imalPlayer extends BettingPl aye r (
public OptimalPlayer ( String name , Hand hand. Bank bank ) {
super ( name, hand, bank ) ;
551
Apndi ce A
LISTAGEM 20.11 OptimalPlayer . java (continuao)
}
publ i c boolean doubleOown( Oealer d ) I
int total = getHandO.total O;
}
Card c d.getUpCard();
if( total 11 ) I
return true:
}
if( total 10 ) {
if( c.getRankO.getRankO != Ra nk.TEN.getRankO &&
c.getRank() ! = Rank.ACE ) I
return true;
}
retur n fa I se:
}
if( total --9 ) I
if ( c. getRank O ,... Rank. TWO
I I
c.getRankO Rank . THREE
I I
c.getRankO Rank.FOUR
I I
c. getRank O Rank . FIVE
I I
c. getRank O Rank . SIX ) {
return true:
}
return fa l se;
}
return false :
public boolean hit( Dealer d ) {
}
i nt to ta 1 .. getHand () . tota I O;
Card c .. d.getUpCard() :
if( total >= 17 ) {
return ta I se :
if( total .. 16 ) {
if( c.getRank() .... Rank.SEVEN J J
c.getRank() == Rank.EIGHT II
c .getRank() == Rank.NINE ) {
return t rue :
} el se {
return fa l se;
}
Respostas
LISTAGEM 20.11 Opt imal Player . java (continuao)
}
}
}
if( total 13 Il total " 14 II total
}
if( c. get Rank () Rank.TWO
I I
c.getRankO
==
c.getRank() ==
c .getRank O
c .getRank O
return false;
} else {
return true;
}
Rank. THREE
I I
Rank.FOUR
I I
Rank.FIVE
I I
Rank.SIX ) {
if( total" 12 ) {
}
if ( c. getRank O u Rank . FOUR II
c.getRankO Rank.FIVE I I
c.getRank() Rank.SIX ) {
false; return
}
else I
return true;
}
return true;
== 15 ) {
public voi d betO I
get8ank().placeI08et();
}
Em nossos testes, Knowl edgeabl ePI ayer e Opt imal PI ayer executam melhor do que as
verses do Exerccio 2.
Contudo, com o passar do tempo, ambos ainda perdem dinheiro - apenas muito lenta-
mente.
Dia 21 Respostas do teste e dos exerccios
Respostas do teste
I. Voc pode cuidar do problema da chamada de mtodo recursiva colocando cada jogador
em li ma linha de execuo. Quando voc chamar Thread.s t art, a chamada retornar
imediatamente, ao contrrio de um mtodo normal. Como o mtodo reloma imediata-
mente, a pilha de chamada de mtodos pode desenrolar e retomar.
Apndi ce A
Respostas dos exerccios
1. Sem resposta.
2. As respostas dependero dos interesses pessoais. O Apndi ce D, "Bibliografia selecio-
nada", apresent a unta lista de recursos excelente, na qual voc pode basear a cont inuao
de seus estudos.
ApNDICE


Resumo do Java
o Java Developer's Kit: J2SE 1.3 SDK
o JDK (Java Developcr's Kit) da Sun Microsystems fornece o ambiente para todo o desenvolvi-
mento Java. Com o passar dos anos, a Sun mudou o nome do ki t de desenvolvimento de JDK
para Java 2 Standard Edition (J2SE) Software Developmenl Kil (SDK; entretanto, os objetivosdas
ferramentas e das bibliotecas permanecem os mesmos - aj udar os desenvolvedores em seus es-
foros para escrever soRware de qual idade, independente da plataforma, c orientado a objetos).
Muitos ambientes de desenvolvimento integrados (IDEs) populares incorporam o SDK, alm de
um editor e depurador poderoso. O Forte da Sun e o J Builder da Borland fornecem gratuitamente
verses mais simples do IDE; entretanto, para o objetivo desta a abrangncia ser li-
mitada ao uso do SDK com um editor de textos como o TextPad, NOlepad ou vi.
A Sun fornece o J2SE SDK para vrias plataformas:
Windows NT, 2000, 95, 98, ME
Sun Solaris
Linux
Voc pode obter o SDK para outras platafonnas, como HP ou AIX, com o fornecedor da plata-
forma apropriada. O J2SE SDK para Windows ser utilizado como exemplo. A instalao e con-
fi gurao em outras platafonnas vai variar pouco em relao aos procedimentos di scut idos a

segUI r.
Apndice B
Os desenvolvedores podem fazer download do J2SE SDK no si te Web J2SE da Java50ft, no en-
dereo javI . sun.comj j2sej 1.3. Siga os links apropri ados para fazer download do J2SE 1.3
SDK. Alm do J2SE SDK, voc deve fazer download da documentao da APl J2SE. Embora
no seja exigida. a documentao da APl tremendamente til. A documentao da APl J2$E
fornece documentao detal hada de atributo, mtodo e classe que at os desenvolvedores de
Java altamente experientes consideraro teis.
Configurao do ambiente de desenvolvimento
A JavaSoft empacota o Windows J25E 1.3 SDK em um pacote InstallShield. Quando voc fizer
download do arquivo, execute-o e percorra as caixas de dilogo para instalar o SDK no diretrio
de destino apropriado. (O diretrio de destino padro C: \jdkl. 3.) Instale todos os componen-
tes, quando solicitado. Isso exigir cerca de 54MB de espao no disco r gido. Quando terminar,
voc dever ver a seguinte estrutura de di retrio em seu diretrio de destino de instalao:
C,\jdk1.3
\bi n
\demo
\include
\include-old
\j re
\ll b
o pacote de instalao apenas distribui O SDK nos diretrios apropriados. Para iniciar o desen-
volvi mento, voc deve confi gurar as seguintes variveis de ambiente.
JAVA HOME
PATH
CLASSPATH
Primeiro, confi gure JAVA HOME com o diretrio instalado apropriado. Por exemplo, voc execu-
taria o seguinte na linha de comando:
set JAVA_HOME
z
c:\jdkl .3
Em seguida, configure o PATH:
set PATH=%PATH%; %JAVA_HOME%\bin
Finalmente, configure o CLASSPATH. O ClASSPATH infornlar o compilador e a mquina vi rtual
onde deve procurar os arquivos de classe compilados.
Em geral, esse caminho o mesmo da raiz da rvore-fonte. Escolha c: \projects\src\java\
classes. Assim, voc configurar o CLASSPATH:
set ClASSPATH-c: \ projects \s rc \java\classes
A Figura B. I demonstra as configuraes de ambiente que acabamos de descrever.
FIGURA B.1
COI/figural/do
o ambiellfe.
Aesumo do Java 557
A maior parte dos out ros fornecedores empacotar suas bibliotecas na forma de arquivos jar ou
zip. Para usar essas bi bliotecas, voc deve anexar a localizao do arquivo jar no CLASSPATH. Por
exemplo, para usar c: \projects\ 1 i b\mycl asses . jar, voc deve execut ar o seguinte:
set
Voc deve anexar cada arquivo jar em CLASSPATH, antes de usar.
Panorama das ferramentas do SDK
Alm de forne<:er as bibliote<:as Java, o Java SDK fornece vrias ferramentas necessri as para o
desenvolvimento. As ferrament as mais usadas so:
javac
j ava

Jar
javadoc
Voc precisar das outras ferramentas para recursos adicionais, como chamadas de mtodos re-
motos e interface Java nativa.
Compilador Java: javac
j avac , o compi lador Java, compila cdigo-fonte Java em byte code. Quando voc digitar j avac
FirstProgram.java, o compilador gerar um arquivo FirstProgram.class no diretri o corrente
- supondo que o compilador no detecte nenhum erro dentro de seu cdigo Java.
Se um programa Java utilizar bibl iotecas de terceiros, o compilador tent ar local izar essas bibliote-
cas a part ir do CLASSPATH especificado; entretanto, voc pode optar por modi fi car a CLASSPATH ao
compilar. A opo -C 1 asspath <cominho> permite aos desenvolvedores substituir o
ClASSPATH.
Voc tambm pode especi fi car diferentes diretrios de ori gem e destino. atravs de -sourcepath
<cominho> e -d <cominho>, respectivament e. A opo -sourcepat h especi fi ca uma nova locali-
zao para arquivos-font e de entrada. Assim, voc pode optar por compilar arq uivos-fonte loca-
Apndice B
lizados em um lugar diferent e do diretrio corrente. A opo -d infonna o compi lador para que
deposite os arqui vos .c1ass no caminho especificado, em vezde faz-lo no di retrio corrente.
Voc no precisar das opes -c1asspath, -sourcepath ou-d para os exerccios deste li vro.
Interpretador Java: java
j ava, o interpretador Java, fornece o ambiente de tempo de execuo. Ele int erpretar e executa-
r os arquivos de classe compi lados. Para executar um programa Java, digite:
Java FirstProgram
Note que o comando omite a extenso . c1 ass o O interpretador anexa, c1 ass automaticamente
no nome da classe.
Assim como no compi lador, voc pode especificar opes de linha de comando para o interpre-
tador. Algumas das opes usadas mais freqentemente so:
- classpath, para especificar um caminho de classe diferent e daquele defini do no
ClASSPATH
-OpropName"' propValue . para especificar propriedades de sistema
Essas e outras opes do interpretador, entretanto, esto fora dos objet ivos desta di scusso.
Utilitrio de compactao de arquivos Java: j ar
o ut ilitrio jar gera arquivos compactados java (jar). Os arquivos jar s."Io equivalentes aos ar-
quivos zip, compactando arquivos para um tamanho menor e fornecendo uma mane ira conveni -
ente de distribuir classes java compil adas.
Para criar um arqui vo compactado, basta chamar:
jar cvf <nomedoorquivojar> <arqui vos_o_compactar>
Voc tambm pode especi ficar todos os arqui vos jar e subdiretrios de determinado diretrio,
atravs de:
jar cvf <nomedoarquivojar> <diret6rio>
Note que todos os arquivos jar devem ler sufixo ,j ar.
Se voc quiser ver o contedo de um arquivo jar, chame:
jar tvf <arquivojar>
O comando jar tvf exibir o tamanho, adala de inseroe o nome de arquivo que est no arqui-
vo compactado.
Mais opes esto descritas na documentao do SDK Java.
Aesumo do Java
Documentao Java e o gerador de documentao:
javadoc
Todos os desenvolvedores j ouviram o mant ra da documentao de cdigo. A JavaSoft facilita
o processo de documentao, fornecendo uma ferramenta para gerar documentao HTML ami-
gvel para o usurio. O desenvolvedor precisa uti li zar apenas tags padro, ao escrever coment-
ri os de atributos, mtodos e classes, e depois chamar a ferramenta javadoc com as opes
apropriadas para gerar documentao de APl . A documentao do SDK Java fornece infonna-
es elaboradas sobre a ferramenta e o processo j avadoc; entretanto, vamos abordar alguns re-
cursos bsicos para comear.
Os desenvolvcdorcs devem primeiro documentar seu cdigo com os comentrios e tags apropria-
dos. Seria t imo se a ferramenta de documentao pudesse adentrar nosso cdi go e decifrar exa-
tamente o que estvamos pensando quando escrevemos aquele mtodo cm part icular; ent retanto,
a ferramenta javadoc no sufi cienlemenle avanada para ler a mente.
Em Java, existem trs nveis principais de documentao: classe, mtodo e atribulo. A ferra-
menta javadoc reconhecer comentrios que comeam com j ** como um coment ri o javadoc.
Os comentri os terminam com * j .
Para comentri os de classe, normalmente voc ver:
<nome autor> especifica o autor da classe. Voc pode ter mais de um autor; en-
tretanto, cada autor deve comear com a tag @author.
<nmero verso> especifica a verso da classe. Alguns soft wares de controle
de verso fornecem tags que geraro o nmero automaticamente.
<nomedaclasse> fornece links para outras classes, para mai s informaes. Voc
pode ter mais de uma referncia; ent retanto, cada referncia deve comear com a tag@see.
Uma documentao de classe seria semelhante a:
r'
* <Comentrios e descrio da classe>

* @author Mi chael C. Han
* @author Tony Slnt es
* @version 1. 0
* @see SecondJavaClass
. /
Os comenlri os de mtodo usam as tags anteriores, alm de:
@param <lIomeyarmelro> <comentrios > descreve os parmetros do metodo.
<comentrios> descreve o valor de retorno do metodo.
<NomeExceo> <comentrios> descreve todas asexcecs lanadas pelo m-
todo corrente.
Apndice B
Uma documentao de mtodo seri a semelhante a:
/ H
* <descrio e do m t odo>

* @param valuel parSmetro obtido pel o mtodo de teste
* @param value2 segundo parmetro obtido pelo m todo de tes t e
* @return ve rdadei ro se valuel :: va l ue2
* @except i on NumberFormatException lanado se valuel ou val ue2 forem
i ntei ros
./
Os comentrios javadoc de atri buto tendem a no ter tags especiais. Em vez disso, voc deve de-
notara bloco de comentrio corno um comentrio javadoc. A seguirest um exempl o de comen-
trio de atributo javadoc:
/H
* Atributo de classe para conter o estado da operao de comparao anterior
. /
Cercadinho Java: seu primeiro programa
Java
Para ajudar a confi rmar sua instalao do SDK e praticar com as ferramentas descritas at aqui,
voc vai escrever o infame exemplo He ll oWorld. Pri mei ro, cri e um arquivo chamado Hello-
Wor 1 d. java, na rai z da ori gem. Se estiver usando a rai z da origem sugeri da (\projects \s rc \java
\classes), crie o arquivo sob c:\projects\src\ java\classes.
Aps criar o arqui vo, voc pode comear a escrever seu pri mei ro programa Java. A Li stagem
8.1 contm o exemplo HelloWorld em Java.
LISTAGEM B.l HelloWorld.java
/H
* Um programa hell o world pa ra confirmar que o SDK foi conf igurado corretamente.
* Tambm utilizado para ajudar a demonstrar as ferramentas bsicas do SDK

*@ aut hor Michael C. Han
*@ version 1.0
. /
publi c class HelloWorld {
/ H
* Mt odo principal do programa. Todas as classes Java execut ve i s devem
* conter esse mtodo .

* @param argument os passados da linha de comando
Aesumo do Java
LI STAGEM 8 .1 HelloWorld.java (continuao)
}
' 1
public static void main(String [] args) I
HelloWorld helloTest : new HelloWorld();
System.out.pri ntln(hel loTest . sayHel l o(;
System.out.pri ntln(M");
System. out . pri nt ln(helloTest.sayHi( ;
}
;-.
... Construtor da classe padro

'1
public HelloWorld() {
}
I"
... Mtodo para dizer hel Io para o chamador
... @return String dizendo "Helio"
' 1
publ ic String sayHell o() {
return "HelIo";
}
I "
... Mt odo para dizer hi para o chamador
... @return String dizendo "Hi! "
' 1
public String sayHi() I
return "H1!";
}
Compilando e executando
Para compilar a classe, execute:
javac HelloWorld
561
no diretrio-raiz da origem. Se tiver xi to, voc ver um arq uivo HelloWorld .class gerado 110
mesmo di retrio.
Em segui da, execut e o programa, digitando:
java HelloWorld
Apndice B
Se o programa Hell oWorl d executar com sucesso e impri mir "Hello" e "Hi! ", como mostrado na
Figura 8.2, voc configurou seu SDK corrctamentc; enl retanl O, se voc ver o segui nt e ao exeu-
lar java Hel l oWorld,
Except ion in thread "main" java. lang.NoClassOefFoundError:Hell oWorld
ou no configurou o CLASSPATH correlamente ou colocou oarquivo Hel loWorld.java em um lugar
que no a rai z da ori gem. Em qualquer caso, confinne pri meirose o CLASSPATH contm a raiz da
ori gem (\projects\ sr c\java\cl asses) e, em seguida, confi rme se o arquivo He ll oWorld.java
est na raiz da origem.
FIGURA 8 .2
Compilando e
exeC"II/(lI1do
HelloWorld.
Criando um arquivo

. Jar
Em seguida, lente executar o ulil itrio jar nos arquivos do diretrio. Na ra iz da origem, execute:
jar cvf hel l o.jar *.java *.class
Voc ver um arqui vo hello.jar gerado.
Para confinnar o contedo de hello.jar, execute:
jar tvf hello.jar
Voc ver dois arquivos-Hel loWorld .java e HelloWorld. class- na listagem, como na Figura 8.3.
Em seguida, exclua HelloWorld.java e HelloWorld. class da raiz da origem (\pro-
jects\src \java\classes). Final mente, voc precisa executar:
jar xv f hel lo.jar
Isso extrair os arquivos Hel loWorl d.java e He ll oWorld .class na ra iz da origem (veja a Figura
B.3).
FIGURA 8 .3
Criando, /is/ando e
ex/rail/do hello.jar.
Gerando javadoc
Resumo do Java
Se voc examinar o cdigofonte de HelloWorld, notar comentrios no estil o javadoc para a
classe e para os mtodos da c lasse.
Para gerar a documenlao, crie o diretri o de documentao. Sob c : \projects, cri e um direl
ri o docs e depois execute:
javadoc - public - d c:\projects\docs HelloWorld
o comando depositar a documentao HTML no diretrio c : \projects\docs para todos os m
todos pblicos da classe Hel l oWorl d, como se v na Figura B.4. Para ver a documentao, abra
c: \projects\docs\ index, html em um navegador da Web. Observe a semel hana de estil os en
tre a documentao gerada e a documentao da APl J2SE da Sun.
FIGURA 8 .4
Tela do gerao de jamdoc
de He 11 oWorl d.
Apndice B
Mecnica da linguagem Java
Aps segui r os passos anteriores, voc deve ter um ambiente de desenvolvimento Java totalmen-
te configurado, assim como um entendimento das ferramentas bsicas do SDK. De posse do am-
biente de desenvolvimento, agora hora de escrever algumas classes Java.
Classe Java simples
A segui rest a verso simplificada do programa He11 olior1 d apresentado na seo anterior. Ago-
ra que voc sabe como faz para compilar e executar programas Java, pode exami nar o cdi-
go-fonte com mais detalhes:
publ ic class Simp1eHe11oWorld {
I
public stat i c void main ( String ar gs E] ) {
String hi new String(" Hello All lO)
System.out.print1n(hi)
I
A primeira palavra-chave utilizada publ ic. A palavra pub1 ic denominada modificador de
acesso. Semelhanlement e linguagem C++ ou SmallTalk, a li nguagem Java fomece modifica-
dores de acesso para especi ficar quem pode acessar um mtodo, atributo ou classe em particular.
O acesso pblico garante o acesso a todos aqueles que qui serem usar uma classe. mtodo ou atri-
buto em particular. Os outros modificadores de acesso so protected, private e nivel de pacote.
Nvel de pacote algo especial na linguagem Java. Basicamente, um modi fi cador de nvel de pa-
cote garante o acesso a todas as classes dent ro do mesmo pacote ou di retri o.
A prxima palavra-chave do exemplo de classe c1 asso Em Java, uma classe o fundamento b-
sico e os blocos de construo de programas. Ela o encapsulamento de varivci s de dados ou
atributos e operaes, funes, ou mtodos. Tudo em Java deve residir dent ro de uma classe.
O nome do exemplo de classe Simp1eHe11oWor 1d. Em Java, o cdigo-fonte dessa classe deve
residir em um arquivo chamado Si mp 1 eHe 11 oWor 1 d. j a va. Se a classe residir em qualquer outro
arquivo, o compi lador reclamar que "c 1 ass S i mp 1 eHe 11 oWor 1 d is pub 1 i c, deveri a ser declara-
do em um arquivo com nome Simp1eHelloWorl d.java". O arquivo de classe compil ado reside
em SimpleHel1oWor ld.c1ass.
A classe Si mp 1 eHe 11 oWo r1 d tambm contm pub 1 i c s ta t i c voi d ma i n (Stri ng args []). Ignore
os modificadores static e voi d. A linguagem Java exige um mtodo pri ncipal, se voc quiser
executar uma classe Java atravs do comando java. Voc pode optar por adicionar mais mtodos
e operaes na classe; entretanto, sem um mtodo com essa assi natura, voc no pode executar a
classe.
Observe as chaves ({}) e pontos-e-vrgulas ( ) no cdigo-fonte. Em Java, as chaves designam
blocos de programa. Um mtodo e uma classe devem comear e tenni nar com uma chave.
Aesumo do Java
Assi m, voc deve tomara cuidado especial de terminar chaves de abertura com chaves de fecha-
mento. Os pontos-e-vrgulas designam o final de uma instruo. Se voc programador de
C/C++, entoj est familiarizado com eles e sabe que deve fechar todas as instrues com pon-
los-c-vrgulas.
As palavras-chave static e void descrevem um mtodo. A palavra-chave void o valor de re-
torno. Semelhantemente s outras linguagens, os mtodos Java tm um valor de retorno. Neste
caso, o mtodo princ ipal no retorna nenhum valor. A palavra-chave statlc designa o mtodo
como acessvel atravs da classe. Em outras palavras, voc pode chamar um mtodo esttico de
uma c lasse, sem criar uma instncia da classe.
As duas linhas de cdigo a seguir, encapsuladas pelas chaves do mtodo principal, representam
o m ;010 do programa.
String hi new String(" Hello All
U
) ;
System.out.print ln( hi);
Aqui, uma referncia chamada hi aponta para uma instncia construda da classe Stri ng. Como
em Small Talk ou Ctt, o operador new cria a instncia. A instncia de St ring contm o valor
"Hello All". Ela recebe o valor como parmetro do construtor. Na linha seguinte, o objeto
System imprime o valor de hi no console do sistema.
Note tambm os pontos-e-vrgulas no final de cada li nha de cdigo. A falha em tenlli nar inst rues
de programa ou declaraes de varivel com um ponto-e-virgula resultar em erros de compilao.
Tipo de Dados
A li nguagem Java, assim como C++ e Smal ltalk, fort emente tipada. Assim, ao declarar vari-
veis e valores de retomo, voc deve especificar a varivel ou tipo de retomo. A linguagem Java
contm oito tipos primit ivos. A Tabela R I lista os ti pos primitivos vl idos em um programa
Java e o numero de bits associados ao tipo:
TABELA B. 1 Tipos primi tivos J ava e tamanhos de armazenamento
Tipo Nmero de bits
byte 8 bits
short 16 bits
char 16 bits
i nt 32 bits
fl oat 32 bits
doub 1 e 64 bits
10ng 64 bits
boolean 1 bi t
Apndice B
Na maioria dos cenrios, voc pode usar i nt para representar inteiros e float para representar
valores de ponto fl ut uante; ent retanto, certos tipos de dados podem exigir espao de armazena-
mento maior. Por exemplo, talvez voc queira expressar o nmero de mi lissegundos desde 1970.
Esse nmero sufi cientemente grande para exigir um valor l ong, em vez de um inteiro.
Voc pode representar um valor 1 ong como I OOOOOOOOOL. A letra L pos-fixada denota o nmero
como long. Analogamente, voc pode representar valores f loat como 4.3405F.
Se voc for programador de C++, sabe que nessa linguagem os caracteres so ASCI I. A lingua-
gem Java, entretanto, usa Unicode para representar caracteres. O padro Unicode usa 2 bytes
para representar caracteres, em oposio a I byte usado pelo padro ASCI I. Isso pennite a repre-
sentao de um conjunto de caracteres maior para propsitos de int ernacionalizao. Por exem-
plo, a maioria das li nguagens As ian exige armazenamento maior do que o padro ASCII . A
linguagem Java no o impede completamente de usar ASCII. Em vez disso, voc tem a escolha
de usar um dos dois. Por exemplo, voc pode usar seqUncias ASCII comuns, como \n para
nova linha ou \ t para tabulao.
Em certas ocasies, talvez voc queira converter um tipo numrico cm outro, como de i nt para
1 ong. A I inguagem Java fornece converso automtica entre tipos numricos, se a converso no
levar a nenhuma perda de preciso. Ela converter um valor int de 32 bi ts aut omaticamente para
um valor long de 64 bits; entretanto, voc deve especificar explicitamente a converso de ti po,
para converter de um valor 10ng para um valor i nt ou de um valor doub 1 e para um valor i nt. A
li nguagem Java ehama essa operao de converso. Se voc no converter ao realizar uma con-
verso de reduo de preciso, o compil ador rejei tar.
As linhas a seguir demonstram uma converso explcita:
lon9 valuel 40000L

int va I ue (int)valuel

float value2 z 4.003F;
double value3 value2;
Observe que a converso de fI oat para double no exige converso explcita, poi s um valor flo -
at tem 32 bits e um valor double tem 64 bits. Assim, a operao aumenta a preciso.
Variveis
A lm de ser fortement e tipada, a linguagem Java tambm leva em considerao letras maiSCU-
las e minsculas. ConseqUentemente, a li nguagem Java considera duas variveis com posiciona-
mento de letras maisculas e minsculas di ferent e corno duas variveis separadas. Por exemplo,
variableOne e variabl eone so duas declaraes de varivel diferentes. Um nome de varivel
Java deve comear com uma letra e cont er quaisquer caracteres alfanumricos. Os caracteres al-
fanumricos podem ser qualquer caractere Uni code que denote uma letra em qualquer idioma;
ent retanto, o nome no pode conter quaisquer smbolos, como $, %. & etc.
As seguintes palavras reservadas no podem ser utilizadas:
Aesumo do Java
abs t ract boolean break
case catch char
canst cont inue defaul t
daub1e else extends
f inal1 y f1 oat for
generic goto if
import inner instanceof
interface 10ng native
null operator outer
private protected public
return short static
swi tch synchroni zed this
throws transient try
void volatile while
A seguir esto alguns exemplos de declaraes de varivel:
int valuel;
doubl e Value2;
float _va l ue3 ;
char VALUE4 , Value5 ;
567
byte
c1ass
do
f i na 1
fut ure
i mplements
int
new
package
rest
super
throw
,ar
Observe a ltima declarao de vari vel. A linguagem Java permite vrias declaraes de tipo de
varivel por linha. Nesse cenrio, VAlUE4 e Va 1 ue5 so valores char. Para declarar ml tiplas va-
ri veis, use uma vrgula para separar cada nome de vari vel e ternline com um ponto-e-vrgula.
Tambm existem modificadores de atributo que voc pode adicionar em uma declarao de va-
ri vel. Por exemplo, as vari veis podem ser declaradas pub 1 i c, pri va te ou protec ted, para con-
trole de acesso. Uma varivel tambm pode ser declarada sttic ou final, ou ambos. Uma
vari vel sta t i c acessvel atravs da classe, enquant o uma varivel fi na 1 no pode ser medi fi-
cada.
Embora voc tenha poucas restries quanto aos nomes de varivel , altamente aconselhvel
seguir alguma forma de conveno de atri buio de nomes ou padres de codifi cao. Os pa-
dres de codi fi cao levam a um cdigo unifonne e, assim, melhoram a legibi lidade do cdigo.
Uma conveno de atribuio de nomes de varivel comum colocar a primeira letra de toda pa-
lavra em maiscul a. exceto a primeira pal avra. Os nomes seriam como:
int anlntegerValue;
char aCharValue;
Outra conveni'lo prefixar todas as variveis pri vadas e protegidas com um sublinhado. Assim,
as variveis seriam como:
private int _value;
pr;vate char _aCharValue:
Voc deve segui r os padres de codificao de sua empresa ou seguir um padro de codi fi cao
comum.
Apndice B
Constantes
As constantes podem ser consideradas como um tipo especial de vari vel. Assim como em ou-
tras li nguagens. as constantes Java so vari veis com valores que no mudam. Voc pode decla-
rar uma constante anexando as palavras-chave stati c final no inicio da declarao de varivel .
Exemplos de declaraes de constante incluem:
pri vate stati e final String _NAME_VALUE "MyName";
pr; vate stati e final i nt _AN_INTEGER_CONSTANT 1;
publi c stati e fina l String PARAMETER_NAME = "MyParam";
proteeted static f i nal ehar _TYPE_CHAR_VALUE 'c';
Observe que os nomes de constante esto em letras maisculas. Embora no seja um requi sito,
uma prtica normalmente seguida entre os desenvolvedores de Java nomear as constantes com
todas as let ras maiscul as.
Voc pode acessar essas constantes atravs de <el assname>.<cons tant_name>. Por exemplo, se
as constantes anteri ores forem declaradas em MyCl ass, voc poder acessar a constante
PARAMETER NAME atravs de MyCl ass. PARAMETER NAME. Essa a nica constante pbl ica declarada
- -
e, assim, essa a nica constante di sponvel fora de MyCl ass ; entretanto, voc pode usar qualquer
uma das outras constant es dentro de MyCl asso Voc tambm pode usar a conSlante
_ TYPE _ CHAR_ VALUE em todas as subclasses de HyC1ass. Ao usar constantes dentro da mesma clas-
se, voc pode omilir o prefixo <c1 assname>. Por exemplo, para acessar _ NAME_VALUE dentro de
HyClass, voc pode fazer referncia constante como MyCl asso _ HAME_ VAlUE ou simplesmente
NAME VALUE.
Operadores
A linguagem Java fornece vrios operadores para operaes aritmticas e booleanas. Aqueles
que esto famili ari zados com a sintaxe da linguagem C/C++, devem conhecer a sitHaxe desses
operadores. Conforme mencionamos anteri ormente, Iodas as instrues Java devem terminar
com um ponlo-e-vrgula.
A linguagem Java tem os operadores +, I, -,. normais para operaes aritmticas. O operador =
usado para atribuio. Alm disso, a linguagem Java suporta o operador de mdul o ou resto, %.
Por exempl o, 15 / 3 igua l a 5, enquanto 15 % 3 igual a O. Voc tambm pode usar operadores
aritmticos ao ini cializar varivei s. Por exemplo, inicializar x como n + 2 semelhante a:
int x n + 2;
Voc tambm pode opiar por usar uma sinlaxe abreviada ao efetuar operaes na mesma vari-
vel. Por exemplo, para incrementar x por n, voc pode optar por escrever:
x .. n + x;
Voc tambm pode adotar uma estratgia abreviada e escrever:
Aesumo do Java 569
A linguagem Java tambm oferece suporte para exponenciao. A linguagem Java no fornece
um operador. Em vez di sso, voc usa o mtodo pow, fornecido na classe java. lang. Hath. assim,
para elevar x potncia n, a expresso seria semel hante a:
int y Hath.pow(x, n}:
A linguagem Java tambm fornece operadores de incremento e decremento, como em C/C++.
Para incrementar x por 1, voc pode escrever o seguinte:
x z X + I;
x +" I;
A me lhor maneira, ent retanto, escrever:
x++' ,
o mesmo se aplica ao opemdor de decremento:
x_O;
Para os dois operadores, existem duas fonnas. Voc pode colocar o operador antes ou depois da
varivel. Por exemplo, para decrementar x, voc pode se expressar como segue:
x_O:
-- x;
A localizao do operador diz quando ele efet uado. Em uma expresso aritmtica, colocar o
operador antes da vari vel incrementar (ou decrementar) a vari vel primeiro, antes da avalia-
o da expresso. Se voc colocar o operador depois da varivel, a expresso ser avali ada pri -
meiro. Pegue como exemplo o seguinte trecho de cdigo:
i nt
x " 5:
i nt y .. 6;
i nt k "++x;
I I' ps esta expresso , k 6 e x 6
i nt j
"Y++: I I'ps
esta expresso ,
J
6 e y 7
Como voc pode ver, o posicionamento do operador de incremento ou decremento fundamen-
ta l. Tome o cuidado especial de usar os operadores apropriadamente.
Os operadores booleanos da linguagem Java so muito parecidos com os operadores booleanos
de outras li nguagens de programao. Ao comparar maior que ou menor que, a linguagem Java
fornece> e <, respecti vament e. Alm disso, <= e >= denotam menor ou igual a e maior ou igual a,
respectivamente. Isso se aplica comparao de tipos primitivos, como valores int eiros (inte-
gers), long, doubl e, caracteres, etc:
intx"S:
inty "6:
boolean z .. x < Yi /1 Z .. verdadeiro
Apndice B
Para fazer comparao de igualdade, a li nguagem Java fornece dois operadores diferentes. Voc
pode usar o operador para comparar tipos primiti vos; entretant o, ao comparar dois obj etos
(como String, MyObject), voc deve usar o mtodo equalsO,de fi nido para o objelo. Se voc
usar = por engano, para comparar dois obj eros, isso na verdade comparar a referncia dos dois
objetos e no os objelos reai s. A no ser que voc esteja comparando as mesmas refernc ias de
obj eto, esta operao retornar falsa:
String X " new Stri ng") ;
String y. new String(UMy St r i ng");
boolean z " (x y); II z falso
boolean w " (x.equals(y)) ; II w verdadeiro
Para fazer comparao de desigualdade, a linguagem Java usa o operador!. A desigualdade en-
Irc lipos primitivos usar! = e ent re dois objetos ser !objl.equals(obj2).
Voc tambm pode optar por usar && e II para verificar condicionais (operaes and (e) e or
(ou), respect ivamente).
Estruturas condicionais
As estrut uras condicionais so uma part e importante de qualquer linguagem de programao.
Assim como ClC++, a linguagem Java fornece o operador i t l el se. A sintaxe. assim como em
C/C++, como segue:
if (condio) {
.. . llcomportamento para quando a condio for verdadeira
}
el se {
.. . 11 comportamento para quando a condio for fal sa
}
Voc pode optar por ter um nico; f , i f je 1 se ou ; f com vrias instrucs e 1 se.
A seguir est um exemplo de instruo i f j e 1 se com vri os el se:
if
(, y)
I
x --:
}
e l se if (x > y)
I
x '" 2;
}
el se (
, I 2;
)
Observe as chaves que denotam o inc io e o final de um bloco i f. Embora as chaves no sejam
exigidas, se voc ti ver apenas uma instruo no bloco i t , us- Ias nessa situao recomendado.
Fazendo isso, voc pode evitar dores de cabea em potencial posteriormente, quando decidi r
Aesumo do Java
571 I
adicionar mai s instrues no bloco i f. Se voc se esquecer de adicionar chaves nesse momento,
ter que depurar para encontrar as chaves ausentes.
A linguagem Java, assim como C/C++, fornece um operador ternrio para reduzi r a expresso
lf/else. Uma expresso temria como segue:
z =(x>y)? 3:1;
(x > y) o teste condicional. O pri mei ro valor aps? representa o valor de z se a condicional for
verdadeira. O segundo valor representa o valor de z se a condicional for falsa.
Seguindo o exemplo anterior, se x 5 e y " 7, ento z .. 1. A condicional falsa (5 > 7) e, assi m,
z recebe O segundo valor na expresso, I.
laos ou estruturas de repetio
Os laos ou estruturas de repet io so um componente importante para qualquer linguagem de
programao. A li nguagem Java, assim como muitas outras, fornece urna variedade de mecanis-
mos de lao.
Um lao usado comumente, o lao for, tem a seguinte si ntaxe:
for (i nt x O; x < 8; x++) {
l/_al guma operao em lao
I
A restrio do lao, x, definida dentro dos parnteses e ini ciali zada como zero. A instruo se-
guinte testa a restrio para garanti r que ela esteja dent ro dos I imites necessrios. Neste caso, x
deve ser menor que 8. A ltima instruo incrementa a restrio do lao.
Outro lao comumente usado, o lao whi 1 e, tem a seguinte si ntaxe:
while (condio for verdadeira) {
/ l .. executa alguma operao
I
o lao continuar a executar, dcsdc que a condio dentro do teste entre parnteses seja verdadeira.
Classes e interfaces -
da linguagem Java
blocos de construo
Em Java, voc no pode fazer nada sem classes e, at certo ponto, int erfaces. As classes compreen-
dem os blocos de construo bsicos da linguagem. Assim, quando escrever seu prprio progra-
ma, voc ter que cri ar classes e tambm usar classes de bibliotecas j existent es. Talvez voc
tambm precise construir interfaces para melhor expressar seu projeto atravs do programa.
Apndice B
Usando classes j existentes
Para usar classes j existentes no SDK Java, voc precisar criar uma instncia da classe, inicia-
liz- Ia e depois trabalhar com as instncias. Para uti li zar a classe existente j ava. uti 1. String-
Buffer, voc cri ari a uma instncia ou objeto dessa classe:
St ri ngBuffer sbTest new St r i ngBuffer();
Agora que voc j criou um novo Stri ng Buffer para usar, pode operar no objeto. Por exemplo,
talvez voc quisesse anexar outra String no buffer.
sbTest.append("This is a test St r ing") ;
Talvez seja preciso criar vrias instncias da mesma classe, para executar as operaes necess-
rias. Assim, voc pode criar quantos objetos Str i ng Buffer forem necessrios:
StringBu ff er sbTest2 new Stri ngBuffer();
Agora, voc criou uma nova instncia de um objeto StringBuffer, identificado pe la referncia
sb Tes t2. Voc tambm pode atribuir uma varivel a outra, at ravs do sinal ::::. 1 sso confi gurar as
duas vari veis para que apont em para o mesmoobjelo. Assim, as operaes exe<:utadas nas duas
variveis afetaro o mesmo objeto. Tome como exemplo as instrues a seguir:
StringBuf fer sbTest new St r i ngBuffer();
StringBuffer sbTest2 new Stri ngBuffer();
sbTest '" sbTes t 2

sbTes t. append( NTest String 1. " );
sbTest2.append( aTes t St r i ng 2.- )
System.out. printl n("Output f or sbTes t = " +sbTest.toSt ringO)
System.out.println("Output f or sbTest2 '" " +sbTest2. t oSt r ing(} )j
Como voc configura sbTest sbTest2, as operaes de anexao em sbTest e sbTes t 2 modi-
ficaro o mesmo objeto subjacent e. A sada do trecho de cdigo anterior ser:
Output for sbTest = Test Stri ng I. Tes t String 2.
Output for sbTest2 " Te s t String I.Test String 2.
Criando suas prprias classes
A sintaxe Java para uma classe :
public class Cl assName {
l/mtodos e atri butos da c lasse
I
Todos os mtodos e atribulas da classe residiro dentro das chaves. Todas as classes tambm de-
vem residir em um arq uivo chamado ClassName.java.
Exami ne o trecho de cdigo do arquivo Product.Java, apresentado na Listagem 8 .2.
Aesumo do Java
LISTAGEM 8.2 Trecho de Product.java
lO>

* @author Michael C.Han
... @vers i on 1. 0
' 1
public class Product (
lO>

... @param argumentos passados da l i nha de comando
' 1
publ ic stat i c void main (Stri ng [] args) (
Product prod
new Product("wi dgetl" , "Acme Inc" , "Mas ter Widget".
"This is the master widget product to sol ve all
problems!",
I
90. 10f);
System.out.println(prod.getProductId())j
System.out.printl n(prod. getManufact urer () );
System. out .pr i nt ln (prod.getProduct Desc()) ;
pri vate St ring prodName , productld. manufacturer , desc i
f loat pri ce i
lO>

... @param argumentos passados da linha de comando
' 1
pu bl ic Product(String product ld . String manufact urer ,
I
Stri ng prodName. String desc, float pr i ce) (
this.prodName prodName ;
this.productld = productld j
th1s.manufacturer manufacturer;
t his.desc a desc i
this.price = price ;
lO>

... @re turn i d do produt o
' 1
publ ic St ring getProductld() I
retur n productIdj
I
I 574 Apndice B
LISTAGEM 8.2 Trecho de Product.java (continuao)
J

* nome do produ to
'1
publ ic St ring getProductName() {
return prodName;
J
I"

* @ret urn nome do fabricante
' 1
public String getManufacturer() (
return man ufact urer;
J
I "

* do produt o
'1
publ ic St r ing getProductDesc() {
return desci
J
I "

* @return preo do produto
'1
public fl oa t getPri ce() (
return price ;
J
I"

* @param price - novo preo desse produto
' 1
publ ic void setPri ce(float price) {
this.price price ;
J
A classe Product tem um mtodo construtor com cinco parmetros: product name, manufactu-
rer, product i d, descri ption e price. O construtor efetua as operaes necessrias para iniciali -
zar O objeto. Neste caso, voc ini cializa as infonnaes do produto designadas. Um construtor
deve seguir as regras que citaremos:
Aesumo do Java
O construtor deve ter o mesmo nome da classe.
Um const rutor pode receber qualquer nmero de parmetros. Um construtor sem parme-
tros chamado de construtor padro.
Um construtor no retorna valores.
Um construt or s pode ser chamado atravs da palavra-chave new (por exemplo, Product
prod = new Produc t ( . .. ).
Uma classe pode ter mais de um construtor (ou, mais comumente conhecidos como cons-
frufores sobrecarregados).
Note o uso da palavra-chave thi s dentro do construtor. A palavra-chave thi s opera sobre a ins-
tncia corrente da classe. No construtor, voc usa a palavra-chave t hi 5 para evitar confundir os
atributos privados com os parmetros do construtor.
Alm dos construtores, a classe Product tambm tem quatro OUlltfodos de obfel1o.
Os acessores fornecem acesso de leitura aos atri but os da classe Product. Para modificar at ri but os
da classe, voc deve usar mtodos chamados modificadores ou de cOI/figurao. A classe Pro-
duct tem um modificador, setPri ce, para modificar o preo de um produto.
Observe que todos os atributos da classe Product so privados e apenas um, pr i ce, pode ser mo-
dificado aps um objeto Product ser cri ado. importante lembrar que as classes no devem ex-
por seus atri but os internos, a menos que o usuri o da classe tenha motivos legt imos para ler e/oll
modi fi car o atributo. ConseqUentemente, voc fornece acesso aos atri butos atravs de modifica-
dores e acessores.
A classe Product tem apenas mtodos de acesso pblico. Voc pode optar por implemcnt ar m-
lodos com outros niveis de acesso; voc pode optar por implementar mtodos pri vados ou prote-

gidos, alm dos mtodos pblicos. E importante lembrar que os mtodos privados so acessveis
dentro da classe que est implementando e que os mtodos protegidos so acessveis tant o den-
tro da classe que est implementando quandto de todas as suas subclasses. Ao decidir-se sobre os
n veis de acesso para um mtodo, lembre-se das seguintes diretrizcs para mtodos privados:
Um mtodo pri vado no traz preocupaes para os usuri os da classe.
O mtodo mudar se a implementao da classe mudar.
Lembre-se tambm do seguinte em relao aos mtodos protegidos:
Um mtodo protegido no traz preocupaes para os usurios dessa classe; entretanto, as
classes que estendem funcionalidade da classe que est implementando exigiro acesso
ao mtodo.
O mtodo atende aos requisitos funcionais de todas as subclasses.
Interfaces
Assi m como as classes, as interraces so recursos bsicos da linguagem Java. Ao contrrio das
cl asses, ent retanto, as interfaces no defi nem atri butos e mtodos para uma classe. Em vez disso,
Apndice B
as interfaces fornecem definies de mtodo que podem ser implementados pelas classes. I)ara
aqueles que esto familiarizados com e++, as interfaces sero semelhantes s definies de clas-
se dent ro de arqui vos de cabealho.
D uma olhada em uma interface para objetos que podem ser ordenados ou comparados:
I "
* Interface para comparar a i gual dade de dois objetos
,
' I
public interface Comparable {
I
I"
* Compara esse objeto com um objeto desejado. Se o corrente
* for maior , ento retorna I, o objeto toCompare maior .
* ento retorna - 1. Se os dois objetos forem igua is . retorna O
* @param toCompare - objeto para comparao
* @return - 1 se toCompare > this. O se toCompare this .
* 1 se thi s > toCompare
' I
public int compare(Object toCompare);
Essa interface reside dentro do SDK Java. Ela defi ne os mtodos que todos os objelos de tipo
Comparable devem implementar. Neste caso, todos os objetos Comparabl e devem implement ar o
mtodo de comparao. De forma simples, uma int erface um cont rato que uma classe que este-
ja implementando deve cumpri r. Se uma classe implementa uma inter face em particular, ela pro--
mete implementar todos os mtodos designados pela interface.
Atualmentc, a linguagem Java fornece suporte apenas para herana simples. Em outras palavras,
uma classe Java s6 pode estender uma classe Java. Conseqentemente, se voc optar por classifi-
car um objcto de Cl assA c C1 assB (herana mlti pla), ento s podcr fazer isso atravs de inter-
faces. Usando interfaces para simular herana mltipla, a linguagem Java recupera grande parte
da funcional idade fornecida pela herana mltipla. Part e da outra func ionalidade perdida pode-
ria scr recuperada parcialmente, at ravs de mtodos de projeto, como composio de objeto.
As interfaces tambm tm vrias outras propriedades. Voc no pode instanciar uma interface
atravs de new. Sua classe pode implementar vrias interfaces. Por exemplo, a classe Product
pode implementar as interfaces Sortable e Clonable:
publi c class Product imp1ements Sortable . Clonable
As interfaces tambm podem estender outras int erfaces. A interface Sortable tambm pode es-
tender uma interface Collectible. Uma classe implementando a interface Sortabl e tambm
deve cumprir o cont rato da int erface Collect i bl e:
public interface Sortable extends Cl onable
Aesumo do Java 577
Classes internas e classes internas annimas
Os arquitetos da linguagem Java acrescentaram o concei to de classes internas com a Java 1. 1.
Uma classe interna uma classe declarada dentro do escopo de uma classe pbli ca. Porque voc
deve usar uma? As classes internas tm as seguintes vantagens imponantes:
Um objeto de uma classe interna pode acessar quaisquer atributos, privados ou no, da
classe que est encapsulando.
As classes internas annimas simplifi cam tarefas, comocallbacks e tratamento de eventos.
As classes internas so extremamente t eis para a criao de objctos que armazenam da-
dos, que no tm nenhum significado fora do cont exto da classe que os empacota, corno
uma chave de hashing especializada para uma cache. Fora da cache, a chave de hashing
no tcm nenhum significado. Assim, voc cria uma classe interna Ha shKey dentro doesco-
po da classe ObjectCache.
Aqui est como a cl asse Ob j ectCache com a cl asse interna HashKey seri a:
i mport java.util . Map ;
i mport java.util.Has hMap ;
publi C class Obj ectCache (
private Map cache ;
publ iC Object Cache() (
cache new Ha shMap();
}
pub11C void add(String oid , St r ing objName, Object obj) (
Ha shKey key new HashKey(oid , objName);
cache. put(key , obj) ;
}
publ ic Object get(String oi d, St ring objName) {
Has hKey key = new HashKey( oid. objName);
Object obj cache.get( key);
return obj ;
}
// .... Mais mtodos ...
pri vate class HashKey {
private Stri ng oi d, objName ;
publiC Ha shKey(St r ing oid , St ring objName) I
thi s.oid oid;
thi s .objName = objName ;
}
}
}
Apndice B
publ iC String getOi d() {
r eturn oi d;
}
public String getObjName() {
return objName;
}
public boolean equals(Object obj) {
}
if (obj instanceof HashKey) {
HashKey key = {Ha shKey)obj;
}
return (key.getOidO.equals(getOidO ) &&
key.getObjName{).equals{getObj Name{) ) ) ;
return fal se ;
public int has hCode() {
return 17;
}
Nas classes internas, assi m como nas classes normais, voc pode acessar os atributos da classe
interna com a palavra-chave t his; entretanto, voc tambm pode acessar os atributos da classe
que est encapsulando. Voc precisar usar a palavra-chave ou ter para acessar esses at ri butos.
As classes anni mas so uma forma especial de classes internas. As classes annimas so mais
predominantes na escrita de cdigo de tratamento de eventos. Tome como exemplo o trecho de
cdigo a seguir, para tratar de eventos de ao em um boto OK:
publi c class FooFrame {
}
II
JButton ok .. new Jbutton("ok");
ok.addActionLis t ener(new ActionListener{) {
} } ;
11-
public voi d actionPerformed(ActionEvent evt) {
II real iza al gum tratamento de evento para o botao ok
}
Embora a sintaxe seja um pouco complicada, as classes int ernas annimas permi tem que voc
reduza o numero de classes em seu projeto. Em vez de uma classe ou classe interna para cada
manipulador de evento, voc colocaria as dedaracs de d asse em linha. Isso economi za muito
tempo; entretanto, devido natureza complexa do cdigo, classes internas anni mas em dema
Aesumo do Java
sia reduziro a legibilidade do cdigo. Conseqentemente, se voc tiver de real izar muito trata-
mento de evento, talvez queira usar alguns padres de proj eto (como o padro Command) para
melhorar seu projeto e, assim, esclarecer sua implementao.
Resumo
De modo algum este resumo uma introduo completa linguagem Java. Entretanto, ele for-
nece informaes suficientes, dentro do contexto deste texto. Se voc quiser obter mais infonna-
es, existem vri os sites na Web que fornecem exerccios dirigidos aprofundados sobre os
fundamentos da linguagem Java. Um recurso excelent e para desenvolvedores iniciantes e expe-
rientes o JDC (Java Developer's Connecti on), local izado no endereo developer.java . sun.
com. Esse site fornece muitos exerccios dirigidos e software de acesso adiant ado para desenvol-
vedores de Java.
ApNDICE
Referncia da UML
Referncia da UML
Este apndice fornece lima referncia rpida para a nOlao UML usada por todo O livro.
Classes
A UML representa uma classe atravs de uma caixa di vidida em trs sees. A seo superior
contm O nOme, a seo do meio contm os atributos e a seo inferior contm os mtodos.
A Figura C. I ilustra como a UML representa uma classe.
Objeto
A UML representa objeto igual a uma classe. A nica diferena que o nome do objeto subli-
nhado e os mtodos so omi tidos. Os at ri butos tambm podem exibir um valor.
Visibilidade
A Figura C.2 il ustra como a UML representa visibil idade de atri buto e mtodo:



+ represent a visi bi lidade pbl ica
# representa visibil idade protegida
- representa visibili dade pri vada
FIGURA C.1
UII/a c/asse UMI..
FI GURA C.2
Visibilidade d(! mtodo
e atributo.
Apndice C
Nome r::
da classe
--

,,<Nome de Cl_
<<AtribulOD>
,
,
Opera6es
Vislbllldade
+pl.lblic_anr
'protecte-(Canr
-private-_attr
+pl.lblic_op,( )
'p-rotecte-(Copr( )
-private_op,( I
Classes e mtodos abstratos
_____ . Atribulol
As classes e mtodos abstraias so simbolizados pelo nome abstrato em itl ico. A Figura C.3 d
um exemplo de classe abstrata.
FIGURA C.3
Uma cltlSse (/bsll(l/a.
Voc tambm pode adi cionar a restrio {abs tract} aps o nome. Usar o rtul o de restrio aj li-
da ao se desenhar um diagrama mo.
Notas

As vezes, uma nota tornam um modelo mais inl eli gvel. Na UML, uma nota semelhante a uma
nota adesiva e ligada ao elemento que a eSl recebendo com uma linha tracejada.
A Figura C.4 ilustra a nota UML. Voc pode anexar uma nota em qualquer parte de seu modelo
UML.
FI GURA C.4
A 1I01a U:\IL
Esteretipos
Refe rncia da UML
+addAccount I )
+total Holdings f)
+totalAccounts ( )
+deposil ( )
+balanc::e I )
----_.
B!!nk cont6m vllri!lS conl!!S'
fornece opera6es para
manipular essas c::onlas.
583
Um estereripo um elemento da UML que permite a voc estender o vocabulrio da prpria
li nguagem UML ou class ificar uma marcao. Um esteret ipo consiste em uma palavra ou frase
includa entre e> >. Voc coloca um estereti po acima ou ao lado de um element o existente.
A Fi gura C.5 ilustra um esteret ipo que define um tipo de mtodo.
FIGURA C.5
O esteretipo UML
Relacionamentos
acc::essoO' +getBalanc::el )
+depositfundsll
+withdrawFund'()
Um relacionamelllo descreve como as classes interagem umas com as outras. Na UML. um rela-
cionament o uma conexo entre dois ou mai s elementos de notao. Na UML, um relaciona-
mento normalmente ilustrado atravs de uma linha ou de uma seta entre as classes.
Dependncia
Em um relacionamento de dependllcia, um obj eto dependente da especificao de outro obj e-
to. Se a especificao mudar, voc precisar atualizar o objelo dependente.
Na UML, voc representa uma dependncia como uma seta tracejada entre as classes dependen-
tes. A Figura C.6 ilustra a notao de dependncia da UML. O relacionament o infonna que
Cl assA depende de Cl as sB.
FIGURA C.S
Um relaciol/amel/to de
depel/del/da simples.
I
c .... Claq B
I
Apndice C
Associao
Uma associao indica que um obj etocontm outro. Nos termos da UML, quando se est em um
relacionameOlo de associao, um objeto est conectado a outro.
Na UML, voc representa uma associao como uma li nha que conecta as duas classes. Diz-se
que uma associao que no tem seta bidirecional. Uma seta significa que o relacionament o
funciona apenas em uma di rco.
A Figura C.7 ilustra a notao de associao da UML. O rel acionament o diz que Cl assA est as-
sociada a ClassB.
FIGURA C.7
I
ClusA
I I
CI .. sB
I
Um re/(/c ;OI/(//IIeIlfO
de associa(;o.
Papis
A UML pennite que voc denote o papel de cada classe na associao. O papel da associao a
part e que um objelo desempenha em um relacionamento.
A Figura C.8 il ustra a notao UML para o papel.
FIGURA C.8
O pape/lia UML.
j I I ~ 1 B I
I I
Multiplicidade
A UML permi te que voc denote a multiplicidade da associao. A multiplicidade indica quan-
tos objctos podem tomar parte na instncia de uma associao.
O intervalo dos valores de mult"iplicidade est listado na Tabela C. I.
TABELA C.1
NOfao
I

1.. *
X .. y
Valores de multipli ci dade
Valor
Um
Qualquer nmero
Pelo menos um
Qualquer nmero de valores no interva lo x a y
A Figura C.9 il ustra a notao UML para multi plicidade.
FI GURA C.9
AJlllliplicidade.
Agregao
Ref erncia da UML
I
Cln sA
I
, I
A UML fornece notao para agregao. Uma agregao um tipo especial de associao que
modela relacionamentos 'tem um' de todo/parte entre pares.
Voc modela uma agregao como uma linha com um losango aberto na extremidade relat iva a
' todo/parte'. A Figura C. l O ilustra a notao UML para agregao.
FI GURA C.10
Agregaeio.
Composio
ClusA
I
A UML fornece notao para composio. Uma composio um tipo especial de associao
que modela relacionamentos ' tem um' de todo/parte entre classes que no so pares. A parte no
independente do todo em um relacionamento de composio.
Voc mooela a composio como uma linha com um losango fechado na extremidade relativa ao
'todo/parte' . A Figura C I I ilustra a notao UML para composio.
FIGURA C.1 1
Composifio.
Generalizao
I
a . ...
I I I
,
Um relacionamento de generalizao existe entre o geral e o espec fi co. E a herana.
A generalizao simbolizada atravs de uma li nha cheia com uma seta fechada e vazada. A Fi-
gura C, 12 il ust ra a notao UML para generalizao,
FIGURA C.12
General i:aeio.
a ....

CI. asA
I
a."" I
Apndice C
Diagramas de interao
Os diagramas de interao modelam as interaes entre os objelos.
Diagramas de colaborao
Os diagramas de colaborao representam as mensagens que os objetos enviam uns para os outros.
Cada objeto simbolizado como uma caixa no diagrama. Uma li nha conecta cada objeto que in
terage. Sobre essa linha, voc escreve as mensagens que os objetos enviam e a direo dessas
mensagens.
Os diagramas de colaborao destacam os relacionamentos ent re os atores. A Figura C. 13 ilustra
o diagrama de colaborao UML.
FIGURA C.13
Um diagrama de
colabo/"ar7o.
Diagramas de seqncia
Objelol
Ob!e!03
Objelo2
Os diagramas de seqUncia modelam a seqUncia de event os em um cenri o, com o passar do
tempo.
Cada objeto no diagrama si mbol izado na parte superi or do diagrama como uma caixa. As li -
nhas que saem das caixas representam a linha da vida do obj eto. As mensagens so passadas en-
tre os objctos. A Fi gura c' 14 ilustra o diagrama de seqUncia UML.
FI GURA C.14
Vm diagrama
l/e seqiiimcia.
I Objeto1 I
ApNDICE
Bibliografia selecionada
o domnio dos objetos s pode vir com o tempo, a prtica e o estudo. Nenhum livro pode ensi
n-Io tudo que h a respeito da programao orienlada a objetos.
Este Apndice apresenta lima li sta de recursos de 00 classificados. Use esta lista como guia
para seus prximos passos no estudo e na aplicao de POO. Embora no seja important e que
voc investigue cada recurso, esta li sta pode conduzi-l o para mais informaes sobre os assuntos
que voc achar interessantes.
Anlise, projeto e metodologias
Beck, Kent. Ex/reme Prograllllllillg ETplailled: Embrace Change. Boston: Addison-Weslcy, 2000.
Baoch, Grady. Objecl Oriellled Ana/ysis And Design: Wilh Applicaliolls. Reading: Addi
son- W esley, 1994.
Baoch, Grady, James Rumbaugh e IYar Jacobson. The Unified Modeling Langl/age Use,. Guidc.
Reading: Addison-Wesley, 1999.
Fowler, Martin e Kendall Scott. UML Dislilled: A BriefG/lide to fhe Standard Ohjecl Modeling
Language. 2'" ed. Readi ng: Addi son-Wcsley, 2000.
Johnson, Ralph E. e Brian Foote. "Designing Reusable Classes:' JOIl1"l1a/ of Objecl Orienled
Programming 1.2 (Junho/Julho 1988): 22-35.
Liberty, Jessc. Beginnillg Objecl Orienled Ana/ysis and Design. Ollon, UK: Wrox, 1998.
Apndice D
Programao com C++
Stroustrup, Bjame. TI/e C++ Programmillg Lallguage. Special ed. Readi ng: Addison-Wcsley,
2000.
Padres de projeto
Buschman, Frank, Regi ne Meunier, Hans Rohnen, Peler Sommerlad e Michael Slal. Pal-
tern-Oriellted Software Architecture: A System of Patterns. Chi chesler: Wiley, 1996.
Garnma, Erich, Ri chard I-I elrn, Ralph Johnson e John Vlissides. Design Pallel'llS: E/emenls of
Rel/sab/e Object-Oriel/fed Software. Reading: Addison- Wesley, 1995.
Princpios e teoria geral da 00
Booch, Grady. Object Oriel1led Analysis AI/d Design. With Applicatiolls. Reading: Addi-
son-Wesley, 1994.
BlId, Ti molhy. Ali /ll/rodllctiOIl lo Object Oriel1led Programming. 2'" ed. Reading: Addi-
son-Wesley, 1997.
Fowler, Martin. Refactoring: /mprovillg lhe Design of Edsling Code. BOSlon: Addison-Wcsley,
2000.
Rumbaugh, James. " Disinhcrited! Examples of Misuse of Inherilance." Joumal ofObjecl Ori-
enled Programming 5.9 (Feverei ro 1993): 22-24.
Seidewi tz, Ed. "Controll ing Inherilance". Joul'I1al ofObject Oriellled Programming 8.8 (Janeiro
1996): 36-42.
Taenzer, David, Murthy Ganti e Sunil Podar. "Objecl-Orienled Software Reuse: The Voyo Pro-
bl em." ./OII1'11al ofObjecl Oriented Programming 2.3 (setembr%utubro de 1989): 30-35.
Teoria "Hard Core" (mas no deixe isso
assust-lo! )
Cardelli, Luca e Peter Wegner. "On Understandi ng Types, Dala Abstraclions and Polymorp-
hism". Compllting SlIr\leys 17.4 ( 1985): 471-523.
Danfonh, Scott e Chri s Tomlinson. 'Type Theori es and Objecl Oriented Programming". ACM
Computing SlIrveys 20. 1 ( 1988): 29-72.
Bibliografia selecionada
Snyder, Alan. "Encapsulation and lnheri lance in Objecl Orienled Prograrnrning Languages".
Proceedings ofthc 1986 OOPSLA Conference on Object Oricnted Programming Syslems, Lan-
guages and App1icalions. Sigp/all Nolices 21.11 ( 1986): 38-45.
Wegner, Peler e Stanley B. Zdonik. " Inheritance as an Incremental Modificat ion Mechanism or
What Likc is and isn' l Likc". ECOOP 1988: 55-77.
Programao com Java
Bloch, Joshua. Efleclive .Java Programming Langl/age Guidc. Boslon: Addison- Wes ley. 200 1 .
Eckel, Bruce. Thinking i/1 Java. 2
0d
cd. Upper Saddle River: Prenlice Hall , 2000.
Warren, Nigel e Philip Bi shop. Java in Praclice: Design S/y/es alld Idiolllsfor Eflec/ive Java.
Harlow, UK: Addi son- Wesley, 1999.
Miscelnea
Brooks, Frederick P., Jr. Tlle Mylhica/ Man-Mo1l1h. Anniversary ed. Rcading: Addison- Wesley,
1995.
Scame, John. Scarne' s Encyclopedia ofCard Games: Ali lhe Rules for Ali thc Games You' lI
Want to Play. Nova York: Harper, 1983.
Smalltalk
Budd, Timot hy. A Liule SII/(III/alk. Reading: Addison-Wesley, 1987.
Goldberg, Adele c David Robson. Small/aik-80: Tlle Language. Reading: Addison-Weslcy,
1989.
Teste
Beck, Kent. Ex/reme Prograllllll ing Exp/ained: Embrace Change. Boston: Addi son- Wesley,
2000.
Mackinnon, Tim, Stcvc Frceman e Philip Craig. "Endo-Testing: Unit Tcst ing \\Ii th Mock
Objects". Artigo apresentado na conferencia eXtreme Programming and Flexiblc Processes in
Software Engineeri ng - XP2000, Cagl iari, Sardinia, Itl ia, junho de 2000.
ApNDICE
Listagens do cdigo do jogo
vinte-e-um
Nos dias 15 a 21 , voc construiu um jogo vinte-c- um completo. Muitos dos exerccios tambm
pedi ram para que voc adicionasse mais funcionalidade ao sistema. Esta listagem de cdi -
go-fonte apresenta a verso final do jogo vinte-c-um. A verso final combina cada recurso que
foi adicionado nos dias 15 a 21.
Este apndice cont m a listagem completa de todo o cdigo. O cdigo foi empacotado para evi-
tar arquivos-fonte duplicados. O que pode ser comparti lhado compm1 il hado. O que no pode
ser compartilhado no compmt il hado.
O cdigo-fonte contm uma OUI MVC, urna OUI PAC, urna UI CU e um si mulador. O cdi -
go-fonte fo i dividido nos seguintes pacotes:
blackjack.core
blackjack.core.threaded
blackjack.exe
blackjack.pl ayers
bl ackjack. ui
bl ackjack . ui.mvc
bl ackjack . ui . pac
Ap ndi ce E
blackjack.core
blackjack .core contm todas as classes comuns encontradas nas listagens E.I a E.14. Essas
classes constroem o sistema do jogo vi nte-e-um bsico.
liSTAGEM E.1 Bank.java
package blackj ack. corej
public class Bank (
private int total ;
private int bet ;
publiC Bank( int amount )
tota I amount ;
I
publ ic voi d doubleOown()
placeBet( bet ) ;
bet - bet * 2-,
I
publ ic void placelOOBet()
placeBe t( 100 );
I
public void place50Bet() (
placeBet( 50 ) ;
I
publi C voi d pl acel0Bet()
placeBet( 10 ) ;
I
publiC voi d win() I
I
total +- ( 2 * bet ) ;
bet - O;
publ ic void l ose () I
/1 j ext rado de total
bet O;
I
publi C void blackjack() I
Li stagens do cdigo do jogo vinte-e-um
LI STAGEM E. 1 Bank.java (continuao)
J
J
total +- ( ( ( 3 bel ) / 2 )+ bel );
bel - O

publiC void standoff() I
total +- bet;
bel - O;
J
public String toString() {
return ( "$" + total + " . 00" l;
J
private void placeBet( inl amount ) {
bet - amount;
tota 1 _ a amount ;
J
LISTAGEM E.2 BettingPlayer.java
package blackjack . core;
public abstraet elass Bett i ngPlayer extends Player {
private Bank bank;
publiC BettingPlayer( St r ing name, Hand hand. Bank bank 1 {
super( name , hand li
this.bank a banki
J
593
11************************************************* *************
Ilcomportamento sobreposto
publ ic Stri ng toString(l {
return ( super . getName() + lO: " + getHandO.toString() + "\n" +
bank.toStr ing() )i
J
publie Stri ng getName() {
return ( super.getName() + " " + bank.toString() l i
J
publ ie void wi nO {
I 594 Apndi ce E
LISTAGEM E.2 BettingPlayer . java (continuao)
J
bank .winO:
super.winO:
publi C void l ose() {
bank.loseO:
super .lose() ;
J
public voi d standoff() {
bank. s tandoff () :
super . standoff():
J
publ ic voi d blackjack() {
bank.blackjack O:
super.blackjack() :
J
protected PlayerState geUnitial StateO {
return get8ettingState();
J
protected Playe rState getPlayingState() {
return new 8etterPlaying():
J
11**************************************************************************
Iladicionado recentemente para BettingPlayer
protected final 8ank get8ank() {
return bank:
J
protected PlayerStale getBettingState() {
return new Betting():
J
protected PlayerState getDoublingDownState() {
return new DoublingOown():
J
protected abstract void bet():
protected abst ract boolean doubleDown( Dealer deal er );
private class Betting implements PlayerState {
Li stagens do cdigo do jogo vinte-e-um
LISTAGEM E.2 BettingPlayer.java (continuao)
publiC void handChanged() I
II impossfvel no estado de estouro
J
publiC void handPlayable() I
J
II impossfvel no estado de estouro
J
public void handBlackjack() {
II impossfvel no estado de estouro
J
publi c void handBusted() {
I I impossfvel no estado de estouro
J
public void execute( Dea l er dealer ) {
bet () ;
J
setCurrentState( getWaitingState() );
dealer.doneBetting( BettingPlayer.this );
II tenni na
private class DoublingDown implements PlayerState I
public void handChanged( ) {
J
notifyChanged():
J
publiC void handPlayable() {
setCurrentState ( getStandingState() ):
notifyStanding():
J
publ iC void handBlackjack() {
I I impossfvel no estado de dobro
J
publi C void handBusted() {
setCurrentState( getBustedState() ):
notifyBustedO ;
J
publi c void execute( Dea ler dealer ) {
bank .doubleDown();
J
dealer.hit( BettingPlayer.this };
getCurrentState{).execute( dealer ):
private class BetterPlaying implements PlayerState I
595
I 596 Apndice E
LI STAGEM E.2 Bett ingPlayer . java (continuao)
I
I
I
publiC "oid handChangedO {
not i fyChanged () ;
I
public "oid handPlayable(} {
Il pode ignorar no es tado de jogo
I
publ i c void handBlackjack(} {
Ilimpossf"el no estado de jogo
I
public void handBusted() {
setCurrentState( getBustedState() };
notifyBusted O j
I
publi c "oid execute( Dealer dealer ) {
I
i f( getHand().canDoubleDown( ) && doubl eDown( dealer ) ) {
setCurrentState( getDoubl ingDownState(l );
getCurrentState().execute( dea1er l ;
return;
i r( hit( dealer ) ) {
dealer.hit( BettingPlayer.this };
) else {
I
setCurrentState( getStandingState() );
notifyStanding();
getCurrentState().execute( dealer ) ;
II transio
LI STAGEM E.3 B1 ackjackDea 1 er . java
package bl ackjack.core;
import java.util . ArrayList ;
import java.uti 1. Iterator ;
publ ic cl ass BlackjackDealer extends Player implements Oeal er {
private Oeckpi l e cards ;
priva te ArrayLi st pl ayers = new ArrayList() ;
Li stagens do cdigo do jogo vinte-e-um
LI STAGEM E.3 8lackjackDeal er.java (continuao)
protected ArrayList waiting_players;
protected Arraylist betting_players;
private ArrayList standing_players;
private Arraylist busted_players ;
private Arraylist blackjack_players;
public 81ackjackOeal er( String name. Hand hand, Oeckpile cards ) {
super( name, hand ) ;
thls.cards cards;
J
597
//**********************************************************************
//Mtodos Que os jogadores podem chamar
public void blackjack( Player player ) {
J
blackjack_players.add( player );
play( thls );
publiC vold busted( Player player ) {
busted_players.add( player );
play( this )i
J
publiC void standing( Pl ayer player ) {
standing_pl ayers.add( player );
play( this );
J
public void doneBetting{ Player player ) {
waiting_players . add{ player );
play( this ) i
J
public void hit( Player player ) {
player.addCard( cards.dealUp() );
J
public Card getupCard{) {
J
Iterator 1 getHandO.getCards{)i
while( i.hasNext() ) {
Card card = (Ca rd) i.next();
if( card.lsFaceUpO ) {
return card;
J
I 598 Apndice E
LI STAGEM E.3 8lackjackDea 1 er. java (continuao)
II no deve chegar aqui
return nu11;
}
II ................. .
II Mtodos de conf igurao do jogo
pub1ic void addPlayer( Player pl ayer ) {
players . add( pl ayer );
}
public void reset() (
super,reset();
}
Ilconfigura os baldes do jogador
waiting_pl ayers 3 new ArrayList() ;
standing_players new ArrayList() ;
busted_p1ayers new ArrayList();
b1ackjack_players a new ArrayList();
betting_players E new ArrayList() ;
betting_players .addA1l(p1ayers ):
cards . reset O;
lterator i players.iterator ():
while{ i.hasNext() ) (
}
Player p1ayer : (Player) i .next {) ;
player,reset{);
pu bli c void newGameO (
reset O;
I I vai!
play( this );
}
11************************* ******.*****
public void dea l () (
cards.shuffle();
II reconfigura cada jogador e distribui uma carta abert a para cada um e
II para si mesma
P1ayer [] player : new Player (waiting players.size{)]:
waiting-p1ayers.toArray{ player };
for{ int ; O; i < player.length; i ++ ) {
player (1] . addCard( cards .dealUp() ):
}
this.addCard( cards.dealUp() ) :
Li stagens do cdigo do jogo vinte-e-um
599
LISTAGEM E.3 8lackjackDea 1 er. java (continuao)
II distribui mais uma carta aberta para cada jogador e uma fechada para
II s1 mesma
J
for( int i O; i < player.length: i ) {
player[i] .addCard( cards.dealUpO ):
J
this.addCard( cards .dealDown(l l:
protected boolean hit( Dealer dealer ) {
if( standing_players . size() > O && getHand().total() < 17 ) {
return true:
J
return false

J
protected voi d exposeHand () (
getHand().turnOver();
notifyChanged():
J
protected PlayerState getBlackjackState() (
return new OealerBlackjack();
J
protected PlayerState getDealingState() (
return new OealerDealing(l;
J
protected Pl ayerState getCollectingBetsState() I
return new OealerCo ll ectingBets() ;
J
protected PlayerState getBustedState() {
return new DealerBusted():
J
protected PlayerState getStandingState() {
return new DealerStanding() :
J
protected PlayerState getWaitingStateO {
return new DealerWaiting() :
J
protected PlayerState getInitialState() {
return new Oea lerCollect i ngBets():
J
private class DealerCollectingBets implements Pl ayerState (
public void handChanged() {
I 600 Apndi ce E
LISTAGEM E.3 8lackj ackDea 1 er. java (continuao)
II impossivel no estado de aposta
I
public void handPlayable() {
II imposslvel no estado de aposta
I
pu bli c void handBlackjackO (
II impossfvel no estado de aposta
I
publ ic void handBusted() (
II impossfvel no estado de aposta
I
public void executeI Oealer dealer ) (
I
1f( !betting_players. isEmptyO ) (
Player pl ayer s( Player )betting_players.get(O) ;
bett l ng_players.remove( player );
player.play( dealer ) ;
I else (
I
setCurrentState( getOealingState() ) ;
getCurrentState() . execute( dealer );
II faz a trans i o e executa
I
private cl ass OealerBusted implements Pl ayerSt ate (
publ i c void handChanged() (
II imposshel no estado de est ouro
I
public vold handPlayabl e() (
II impossfvel no estado de estouro
I
publ ic void handBl ackjack() (
II impos sf vel no estado de estouro
I
publ i c vol d handBust ed() (
II impossfvel no estado de estouro
I
publl c void executeI Oea l er dealer ) (
I terator 1 standi ng_pl ayers. i terator() ;
while( i.hasNext() ) {
I
Pl ayer pl ayer =( Pl ayer ) i .next() ;
player.wlnO;
i s blackjack_players. i terator( ) ;
wh l1 e( i .hasNext() ) {
Li stagens do cdigo do jogo vinte-e-um
LISTAGEM E.3 8lackjackDea 1 er. java (continuao)
J
J
J
J
Player player = (Player) 1. next();
player.blackjack();
i = busted_players.iterator() ;
while( i.hasNext() ) {
J
Player player z (Player) i.next();
player.lose() ;
private class DealerBlackjack implements PlayerState {
publie void handChanged() {
not i fyChanged () ;
J
publie void handPlayable() {
II impossfvel no estado de vinte-e-um
J
publie void handBlackjaek() (
II impossfvel no estado de vinte-e- um
J
publie void handBusted() (
II impossfvel no estado de vinte-e-um
J
publie void execute( Dealer dealer ) (
exposeHand();
J
Iterator 1 pl ayers.iterator();
while( i.hasNext() ) (
J
Player player =(Player) Lnext();
;t( player .getHandO .blackjackO ) {
player.standoff() ;
) else {
player.loseO ;
J
private class DealerStanding implements PlayerState {
publie void handChangedO (
II impossfvel no estado de parada
J
publ ie void handPlayable() {
II impossfvel no estado de parada
J
publiC void handBlackjack() {
II impossfvel no estado de parada
601
I 602 Apndi ce E
LISTAGEM E.3 8lackj ackDeal er.java (continuao)
}
}
public void handBusted () {
II impossfve l no estado de parada
}
publiC void execute( Oealer dealer ) I
Iterator i standi ng_players. iterator();
while( i.hasNext() ) I
}
}
Pl ayer player (Player) i .next();
if( player .getHandO. i sEqual( getHand() ) ) I
player . standoff() ;
) else if( player .getHand() . isGreaterThan(getHand() ) ) I
player.w;n{) j
) el se I
player . lose() ;
}
i blackjack_players.iterator() ;
wh ile( i.hasNext( ) ) I
}
Pl ayer player (Pl aye r) LnextO;
player.bl ackjack()i
i busted_players . iterator();
whi le( i.hasNext() ) (
}
Player pl ayer : (Player) i .next () i
pl ayer.lose ();
private class OealerWaiting i mplements Pl aye rState I
public void handChanged () {
II imposs vel no estado de espera
}
public voi d handPlayable( ) {
II impossvel no es t ado de espera
}
publ ic voi d handBl ackjack() {
II i mpossfvel no estado de espera
}
publiC voi d handBusted() I
II impossvel no estado de espera
}
publi c voi d executeI Oealer dealer ) (
i f(!waiti ng_pl ayers.i sEmpty() ) I
Player pl aye r (Pl ayer) wa i t i ng_players .get(O),
waiting_players.remove( player li
Li stagens do cdigo do jogo vinte-e-um
LISTAGEM E.3 8lackjackDeal er.java (continuao)
}
}
}
player.pl ay( dealer ) i
) else {
}
setCurrent State( getPlayingState() );
exposeHand () i
getCurrentState() . execute( dealer ) ;
Il faz a transio e executa
private class DealerDeal ing implements Playe rState {
publ ic void handChanged() {
}
noti fyChanged() i
}
public void handPlayable() {
setCurrentState( ge tWa i tingState() li
II transi o
}
publiC void ha ndBlackjack() {
}
setCurrent S ta te ( get Bl ackj ackS ta te () ) i
notifyBlackjack() ;
II transio
publ ic voi d handBust edO {
II impossfvel no estado de di stribui o
}
public void execute( Deal er deal er ) {
dealO ;
}
get CurrentSt ate( ) .execute( dealer ) i
II faz a transio e executa
LISTAGEM E.4 Ca rd. java
package blackjack.core;
publ iC class Card {
pri vate Rank rank:
private Suit suit;
pri vate boolean face_uPi
public Card( Suit suit . Rank rank ) {
603
I 604 Apndice E
LISTAGEM E.4 Ca rd. java (continuao)
J
J
th'is.sult sult:
thls . rank rank:
publ'ic Sult getSuit() {
return SUl t:
J
public Rank getRank () {
return rank;
J
public void setFaceUp( bool ean up ) {
fa ce_up up;
J
publ iC boolean isFaceUpO {
return face_up:
J
public String toStr'ing() {
i f( ! isFaceUpO ) {
return -Hidden" :
J
return rank.toString() + suit .toSt ring() ;
J
LI STAGEM E.5 Deal er.java
package blackjack.core;
publi c interface Oealer {
J
II usado pelo jogador para 'i nteragir com a banca
publ ic void hl t( Player player l:
II usado pelo jogador para comuni car estado banca
public vold blackjack( Player player l:
publ ic voi d busted( Player player l ;
public voi d stand'i ng( Pl ayer player l;
publ ic void doneBetting( Player player ):
publ ic Card getUpCard();
Li stagens do cdigo do jogo vinte-e-um
LISTAGEM E.6 Oeck.java
package blackjack . core i
import java. ut il .Iteratori
impo rt java. ut il.Randomi
public class Oeck 1
I
private Ca rd [] deck ;
pr i vate int index;
pu bliC Deck() (
buildCardsOi
I
publ ic voi d addToStack( Deckpil e stack) (
stack .addCards( deck )i
I
protected voi d setOeck( Card [] deck ) (
t hi s. deck deck;
I
protected voi d buildCardS( ) 1
I
deck new Card[52] i
Iterator suit s Suit.SUITS.i terator() i
int coun ter Di
while( su its . hasNext() ) {
I
Sui t sui t (Suit) suits .next()i
Iterator ranks Rank.RANKS.iterator() ;
whi l e( ranks.hasNext() ) {
I
Rank rank (Rank) ranks.next()i
deck(counter] " new Ca rd( suit. rank ) i
counter++i
605
I 606 Apndi ce E
LISTAGEM E.7 Oeckpi l e.java
package bl ackjack . core ;
import java.util.Arraylist;
import java.util.lterator;
import java . util.Random;
publi c class Oeckpile (
private Arrayllst stack new Arraylist()j
private int i ndex;
private Random rand z new Random();
public void addCards( Card [] cards ) (
,
for( int i O; i < cards.length; i ++ ) {
stack . add( cards [i) ) ;
,
publ ic void shuffle() {
reset();
randomize() ;
randomizeO;
randomi ze () :
randomizeO;
,
publ ic Card dealUp() {
,
Card card z deal ();
i f( card !z nul l ) {
card.setFaceUp( true );
,
return card;
publiC Card deal0ownO {
,
Card card z deal();
if( card ! - null ) {
card . set FaceUp( false );
,
return card;
public void reset() {
index z O;
Iterator 1 stack.iterator();
Li stagens do cdigo do jogo vinte-e-um
LISTAGEM E.7 Oeckpi l e.java (continuao)
J
J
while( 1. hasNext( ) ) I
J
Card card (Card) i. next O:
card.setFaceUp( fa l se ) :
private Card deal() I
J
if( index ! - stack.size() ) I
J
Card card (Card) stack.get( i ndex ):
index++;
return card:
return null;
private void randomlze() {
J
int num_cards stack.size();
for( int i O: i < num_cards: i ++ ) I
int index - rand.nextlnt( num_cards ) ;
Card card_i (Card) stack.get( i ):
J
Ca rd card_index (Card) stack. get( index ):
stack . set ( i, card_index ):
stack.set( i ndex, card i ):
LI STAGEM E.a Hand.java
package blackjack.core:
import java . utl1 . ArrayList :
import java.uti l. lterator:
publi C cl ass Hand {
private ArrayList cards - new ArrayList() :
private stat ic final int BLACKJACK : 21;
private HandListener hOl der:
private i nt number_aces :
public HandO I
setHolder(
new HandUstenerO {
607
I 608 Apndice E
LI STAGEM E.a Hand.java (continuao)
} ;
}
}
publiC void handPlayable() {}
publ ic void handBlackjackO {}
public voi d handBustedO {I
publ ic void handChangedO {I
public vo1d setHolder( HandListener holder ) {
this.hol der holder i
}
public Iterator getCardsO (
return cards.iterator();
}
publ iC void addCard( Card card ) (
cards.add( card )i
J
holder.handChanged();
if( card. getRank () Rank .ACE ) {
number_aces++:
}
if( b,stO ) I
hol der.handBusted();
return;
}
if( blackjack() ) (
holder.handBlackjack();
return ;
J
if ( ca rds.size () >= 2 ) {
holder.handPl ayable() ;
return ;
J
publi c boolean canOoubleOown() {
return ( cards.size() == 2 );
J
publ iC boolean isEqual ( Hand hand ) {
if( hand . totalO this.total{) ) {
Li stagens do cdigo do jogo vinte-e-um
LISTAGEM E.a Hand.java (continuao)
return true ;
}
return false;
}
public boolean i sGreaterThan{ Hand hand ) I
return thi s.total() > hand.total();
}
public boolean blackjack() (
if( cards. sizeO ,,= 2 && total ()
return true;
}
return fal se ;
}
publ iC void resetO {
cards. clearO ;
number aces " O;
}
public void turnOver() I
}
Iterator i " cards.iterator ();
while( i.hasNext() ) I
}
Card card " (Card) i.next();
card.setFaceUp( true );
public String toString() (
Iterator i " cards.iterator();
String string " '''';
while( i.hasNext() ) (
Card card = (Card) i.next ();
BLACKJACK ) I
string " string + " " + cardo toString() ;
}
return string ;
}
public int total0 (
int total = O;
Iterator i " cards.iterator();
while( i.hasNext() ) (
Card card " (Card) LnextO i
total +. card.getRank().getRank();
609
I 610 Apndice E
LISTAGEM E.a Hand.java (continuao)
}
}
}
int temp_aces number_aces ;
while( total> BLACKJACK && temp_aces > O ) I
total = total - 10;
temp_aces-- ;
}
return total;
private boolean bustO {
}
if( total() > BLACKJACK ) {
return true ;
}
return false;
LI STAGEM E.9 HandListener . java
package blackjack.core;
public interface HandLlstener I
publi C void handPlayable( );
public void handBlackjack() ;
publiC void handBusted();
public void handChanged();
}
LI STAGEM E.10 Pl ayer.java
package blackjack.core ;
import java.ut ll.ArrayList;
import java.utll.Iterator;
publ i c abstract class Player I
private Hand hand;
Li stagens do cdigo do jogo vinte-e-um
LISTAGEM E.10 Player.java (continuao)
private Stri ng name :
private ArrayList l isteners new ArrayList();
private PlayerState current_state:
publi C Pl ayer( String name, Hand hand ) (
this.name name:
this.hand hand;
setCurrentState{ getlnitialState{) );
I
publi C void addCard{ Card card ) 1
hand.addCard( card ):
I
publ ic void play( Oealer dealer ) {
current_state . execute( dealer }:
I
public void reset() {
hand. reset O;
I
setCurrentState( getlnitialState() );
notifyChanged():
publi C vo1d addlistener( Playerlistener 1 ) (
listeners.add( 1 );
I
public String getName() 1
return name:
I
publi c Stri ng toString() 1
return (name + ": " + hand.toStringO ):
I
publ ic void win() 1
notifyWinO :
I
publiC void lose() (
not ifyLoseO :
I
public vo1d standoff() I
611
I 612 Apndice E
LISTAGEM E.10 Player.java (continuao)
no t 1fyStandoff() :
}
publl C void blackjack() I
not 1 fySl ackj ack () :
}
public Hand getHand() {
return hand:
}
protected void notifyChanged() I
Iterator i l i s t eners.iterator():
while( i.hasNext() ) 1
}
}
PlayerListener pl .. (PlayerListener) i.next();
pl.playerChanged( this ) :
protected voi d notifyBusted() (
Iterator i .. li steners.iterator();
while( i.hasNext() ) (
}
}
Pl ayerli s tener pl .. (PlayerListener) i .nextO :
pl . playerSusted( this );
protected yoid notifyBlackjack() {
Iterator i hsteners .iterator():
while( i.hasNext() ) {
}
}
PlayerListener pl : ( Playerlistener) i . next();
pl.playerBlackjack( this ):
protected void notifyStanding() (
Iterator i l i s teners . i t erator() :
while( i .hasNextO ) (
}
}
Pl ayerListener pl .. (PlayerListener) i .next() ;
pl.playerStand i ng( this ) :
protected yoid notifyStandoff() (
Iterator i l i steners.iterator() :
Li stagens do cdigo do jogo vinte-e-um
LISTAGEM E.10 Player.java (continuao)
J
while( 1. hasNext( ) ) I
J
Playerlistener pl (PlayerListener) i .next();
pl . playerStandoff{ this );
protected void notifyWin(} I
J
Iterator i listeners.iterator{);
while( 1. hasNext() ) I
J
PlayerListener pl (Player l istener) i .next{);
pl.playerWon{ this ) ;
protected vol d not1fyLose() {
J
Iterator i listeners.iterator();
while( i .hasNext() ) I
J
Playerlistener pl z (PlayerListener) i .next();
pl .pl ayerlost( this };
protected fina l void setCurrentState( Pl ayerState state ) I
current _sta te state;
hand . setHolder( state ) ;
J
protected final PlayerState getCurrentStateO I
return current_statei
J
protected PlayerState getBustedState() {
return new Busted();
J
protected PlayerState getStandingState() I
return new Standing() ;
J
protected PlayerState getPlayingState() {
return new Playing(} ;
J
protected Playe rState getWaitingState() (
return new Waiting();
613
I 614 Apndice E
LISTAGEM E.10 Pl ayer.java (continuao)
}
protected PlayerState getBlackjackState{) I
return new Blackjack{);
}
protected abstract PlayerState getInitiaIState():
protected abstract boolean hit( Dealer dealer );
private class Waiting implements PlayerState I
public void handChanged() {
}
not i fyChanged () :
}
publi c void handPlayable{) {
setCurrent Sta te{ ge tPlayingState() l:
II transio
}
public void handBlackjack{) {
}
setCurrentS ta te ( getBl ackj ackS ta te () );
notifyBlackjack();
II trans i o
publ ic void handBusted{) {
II impossvel no estado de espera
}
public void execute{ Dealer dealer ) {
II no faz nada enquanto espera
}
private class Busted implements PlayerState {
public void handChanged {l {
II impossvel no es tado de estouro
}
public void handPl ayable() {
II imposs fve l no estado de estouro
}
pUblic voi d handBlackjack{) I
II impossvel no estado de estouro
}
publi c voi d handBusted{) I
II impossvel no estado de estouro
}
publ ic void execute( Dealer deal er ) I
Li stagens do cdigo do jogo vinte-e-um
LISTAGEM E.10 Player.java (continuao)
}
}
dealer.busted( Player.this );
II tennina
private class Blackjack implements PlayerState (
public void handChanged{) I
}
II impossfvel no estado de vinte-e-um
}
public void handPlayable() I
II impossfvel no estado de vinte-e-um
}
public void handBlackjack() {
II impossfvel no estado de vinte-e- um
}
public void handBusted() {
II impossfvel no estado de vinte-e-um
}
public void execute( Dealer dealer ) (
dealer . blackjack{ Player.this );
II tennina
}
private class Standing implements Pl ayerState I
public void handChanged() {
}
II lmpossfvel no estado de parada
}
public void handPlayable() {
II lmpossfvel no estado de parada
}
public void handBlackjack{) {
II lmpossfvel no estado de parada
}
public void handBusted{) {
II impossfvel no estado de parada
}
public void execute( Deal er dealer ) (
dealer.standing{ Player . this ) ;
II tenni na
}
private class Playing implements PlayerState I
public void handChanged() (
notifyChanged() ;
}
public vold handPlayable() I
615
I 616 Apndice E
LISTAGEM E.10 Pl ayer.java (continuao)
II pode ignorar no estado de jogo
}
public void handBlackjack() I
II impossivel no estado de jogo
}
publ ic void handBustedO I
setCurrentState( getBustedState() ) ;
notifyBusted(}i
}
public void execute( Dealer dealer ) {
if( hit( dealer ) } {
deal er.hit( Pl ayer.this }i
} else (
setCurrentState( getStandingSt ateO );
notifyStanding{) i
}
}
}
current_state.execute( dealer ) i
II transiao
}
LISTAGEM E.l1 PlayerUstener. java
package blackjack .corei
public interface PlayerListener {
public void playerChanged( Player player };
publi c void playerBusted( Player player l i
publi c vofd playerBlackjack ( Player pl ayer } ;
publ ic yoid playerStanding( Player player } ;
publ ic yoid
playerWon( Player player li
public void playerLost( Player player )i
public void playerStandoff( Player player li
}
Li stagens do cdigo do jogo vinte-e-um
LISTAGEM E.12 PlayerState.java
package bl ackjack . core :
public interface PlayerState extends Handlistener I
publiC void execute( Oealer dealer ):
I
LI STAGEM E.13 Rank.java
package blackjack. core :
import java.util . Collections:
import java.util . list :
import java.util.Arrays;
public final class Rank {
publiC static final Rank lWO new Rank( 2 ,
public stati c final Rank THREE
"
oew Rank( 3,
public static final Rank FOUR
"
oew Rank( 4,
public stati c f inal Rank FIVE
"ew
Rank( 5 ,
public static fi nal Rank
51' "
oew Rank( 6,
public stati c fi na 1 Rank SEVEN
"ew
Rank( 7 ,
pubh c stati c f ina l Rank EIGHT
"e, Rank( S,
public static final Rank NINE ne, Rank( 9,
publ ic static final Rank
TE' "
ne'
Rank( lO,
public static final Rank JACK "e,
Rank( l O,
public static fina l Rank QUEEN
-
"e,
Rank( lO,
public static final Rank KING
"
new Rank( 10,
public stat i c fi na l Rank ACE
"
"ew
Rank( 11,
private static final Rank [] VALUES "
I TWO, THREE, FOUR , FIVE , SIX, SEVE N,
"2" };
"3"
I ;
"4 "
I ;
" 5" I ;
"6" I ;
"7"
I ;
"S"
I ;
"9" I ;
"10" ):
"J"
I ;
"Q"
I ;
" K" I ;
" A " I ;
EIGHT, NINE, TEN , JACK, QUEEN , KING , ACE J:
II fornece uma lista no modif icvel para fazer l ao
publ ic static final List RANKS
Co 'l ect ions .unmodifiablelist( Arrays.asList( VALUES ) }:
private
private
fina l
fi na 1
int
String
rank:
display;
private Rank( int rank , String displ ay ) {
this.rank z rank;
617
I 618 Apndice E
LI STAGEM E.13 Rank.java (continuoo)
}
thiS.display displaYi
}
publlC int getRankO {
return rank i
}
publ ic String toString() {
return displaYi
}
LI STAGEM E.14 $u;t.java
package blackjack.corei
i mport java. util. Co ll ections;
i mport java.utll.listi
import java.ut il.Arraysi
publiC final class Suit {
Ildefine estaticamente todos os valores vlidos de Suit
publl c static final Suit OIAMONOS
-
new Suit ( (char)4 ) i
publl c st atic final Suit HEARTS new Suit ( (char)3 )i
public static final Suit SPAOES new Suite (char)6 ) ;
public static final Suit (LUBS new Suite (char)5 )i
private static final Suit [] VALUES = {OIAMONDS. HEARTS . SPAOES . CLUBS }i
II fornece uma lista n1l0 modificvel para fazer l ao
public st atic fi nal List SUI TS
Collect i ons.unmodifiableLi st( Arrays.asList( VALUES ) )i
II varivel de instncia para conter o valor de exibio
private final char displaYi
II no permite inst anciao por objetos externos
private Suit e char display ) {
lh i s. display displ ay;
}
II retorna o valor de Suit
publ ic String toStringO {
Li stagens do cdigo do jogo vi nte-e-um
LISTAGEM E,14 $ult.java (continuao)
}
return String.valueOf( display };
}
blackjack.core.threaded
619
bl ackj ack. core. threaded contm um objeto Bl ackjackOeal er que coloca osjogadores em suas
prprias linhas de execuo (Listagem E. IS).
LI STAGEM E.15 ThreadedBl ackjackDea 1 er.j ava
package blackjack . core.threaded;
import blackjack. core.*;
i mport java.utll .ArrayLi st;
import java.uti 1. Iterator ;
public cl ass ThreadedBlackjackDealer extends BlackjackOealer (
publiC ThreadedBlackjackOealer( String name , Hand hand, Oeckpile cards ) (
supere name , hand, cards );
}
protected PlayerState getWaitingState() (
return new OealerWaiting();
}
protected PlayerState getCollectingBetsState() (
return new DealerCol l ectingBets() ;
}
private class DealerCollectingBets implements PlayerState (
publi c void handChanged{) {
II impos s ve l no estado de aposta
}
public void handPl ayable() {
II impossvel no estado de aposta
}
public void handBl ackjack() {
II impossvel no estado de aposta
}
publ ic void handBusted() {
II impossvel no estado de aposta
I 620 Apndice E
LI STAGEM E.15 ThreadedBl ackjackDea 1 er .java (cont inuoo)
}
}
public void execute( fina l Oea ler dealer } {
H( !betting_p1ayers. isEmptyO } {
}
final Player player (Player) betting_players.get( O }i
betting players.remove( player };
Runnable runnable = new Runnable(} (
publi c void run() I
player.play( dealer };
}
} ;
Thread threaded = new Thread( runnable }i
threaded.start(}i
} else I
}
setCurrentState( getDealingState() )i
getCurrentState().execute( dealer )i
II faz a transio e executa
private class DealerWaiting implements PlayerState (
publi c void handChanged() {
II impossfvel no estado de espera
}
publ i C void handPlayable() {
II impossfvel no estado de espera
}
publiC void handBlackjack() {
II impossfvel no estado de espera
}
publiC void handBusted() I
II impossfvel no estado de espera
}
public void execute ( final Dealer d ) I
H( !waiting_players.isEmptyO ) {
final Player p K (Player) waiting_players.get( O )i
waiting_players . remove( p );
Runnable r z new Runnable() I
public void runO {
p.play( d )i
}
} ;
Thread t new Thread( r )i
t.startO i
} else {
Li stagens do cdigo do jogo vinte-e-um
LISTAGEM E.15 ThreadedBl ackjackDea 1 er .java (cont inuoo)
}
}
}
}
setCurrentState( getPlayingState() l ;
exposeHand () ;
getCurrentState().execute( d );
II faz a transio e executa
blackjack.exe
blackjack.exe contm os executveis para GUI MVC, GUI PAC, UI CU e si mulador
(I iSlagens E. 16 a E. 19).
LI STAGEM E.16 Bl ackjackCLI.java
package bl ackjack.exe;
i mpo rt blackjack.core. *:
import blackjack.players.*;
import blackjack.ui.*;
public class Bl ackjackClI 1
publ1c static vo1d maln( String [] args ) 1
Oeckpile cards new Oeckpile() :
for( int i .. O; i < 4; i ++ ) {
cards.shuffl eO:
}
Deck deck new Deck():
deck.addToStack( cards l ;
cards. shuf fle{):
Hand dealer_hand new Hand();
621
BlackjackDealer dealer .. new BlackjackDealer{ "Oealer" , dealer_hand. cards
" );Bank human_bank .. new Bank{ 1000 );
Hand human_hand new Hand(l:
Player player .. new Coomandl inePlayer( "Human", human_hand. human_bankl;
dealer . addllstener{ Consol e.INSTANCE ) ;
player.addl istener{ Consol e.INSTANCE l;
deal er.addPlayer( pl ayer );
do I
I 622 Apndice E
LI STAGEM E.16 BlackjackCLI.java (continuao)
J
J
J
dealer.newGame( );
} while ( playAga i n() );
Console .INSTANCLprintMessage( "Thank you for playing !" );
private stat ic boolean playAgain() (
Console. INSTMCLprintMessage( "Wou ld you like to play again? [Y] es [Nlo" ) ;
String response -Console. INSTANCLreadlnput( "invalid" );
if( response.equalsIgnoreCase( "y" ) ) {
return true;
J
return fa 1 se;
LI STAGEM E.17 BlackjackMVC . java
package blackjack.exe ;
import blackjack.core . *;
import blackjack.core . threaded . *;
import blackjack.ui.mvc .*;
import javax.swing.*:
import java . awt . *;
import java.awt.event.*;
public class 8lackjackMVC extends JFrame (
public static void main( St r ing [] args ) (
JFrame frame = new 81ackjackMVC() ;
frame.get ContentPane(). set8ackground( FOREST GREEN )i
frame.setSize( 580 , 480 );
frame.show():
J
private BlackjackDealer
private GUIPl ayer
private JPanel players -
dealer;
human:
new Jpanel( new Gridlayout( O, 1 ) };
private static fina l Color FOREST GREEN = new Color( 35 , 142, 35 ,;
public Bl ackjackMVC() {
Li stagens do cdigo do jogo vinte-e-um
LI STAGEM E.17 BlackjackMVC. java (continuao)
}
setUpO ;
WindowAdapter wa new WindowAdapter() (
} ;
public void windowClosing( WindowEvent e ) I
System.exit ( O );
}
addWindowListener( wa };
II precisa ser protegido se houver subclasse
private PlayerView getPlayerView( Player player } {
PlayerView view new PlayerView( player };
view.setBackground( FOREST_GREEN };
return view;
}
II precisa ser protegido se houver subclasse
private void setUp{) {
}
BlackjackOealer dealer getOealer(};
PlayerView vI getPlayerView( deal er };
GUIPlayer human getHuman(};
PlayerView v2 getPlayerView( human ):
PlayerView (] views I vI, v2 }:
addPlayers{ views }:
dealer.addPl ayer( human };
addOptionView( human, dealer }:
II precisa ser protegido se houver subclasse
private void addPlayers( PlayerView [] pview ) {
players.setBackground( FOREST_GREEN }:
}
for( int i O: i < pview. length: i ++ } {
players.add( pview [i] };
}
getContentPane().add( players, Borderlayout.CENTER }:
private void addOpt ionView( GUIPlayer human , BlackjackOealer dealer ) I
OptionView ov new OptionView( human, dealer ):
ov.setBackground( FOREST_GREEN }:
getContentPane().add( ov, BorderLayout.SOUTH };
623
I 624 Apndi ce E
LI STAGEM E.17 Bl ackjackMVC . java (continuao)
}
}
private 81ackjackDealer getDea1er() (
}
if( dea1er == null ) (
}
Hand dea1er_hand = new Hand();
Deckpi 1e cards ,. getCards() ;
dea1er" new ThreadedBlackjackOea1er( "Dealer ", dea1er_hand, cards) ;
return dea1er;
private GUIP1ayer getHuman( ) (
}
if( human a. nu11 ) (
}
Hand human_hand 3 new Hand() ;
8ank bank ,. new Bank( 1000 ) ;
human" new GUIPl ayer( "Huma n", human_hand , bank );
return human;
pr;vate Oeckpi1e getCards() {
Oeckpi1e cards ,. new Oeckpile(} ;
for( int i ,. O; i < 4; i ++ ) {
cards.shuff1e{} ;
}
}
Deck deck new VOeck();
deck.addToStack( cards );
cards.shuffleO;
return cards ;
LISTAGEM E.18 BlackjackPAC.java
package b1ackjack.exe;
i mport
i mport
import
i mpo rt
bl ackjack.core.*;
bl ackjack. ui. pac. *;

Javax. swlng. ;
. t
Java.aw . ;
. t t
l mpor jdva.awt.even . ;
pub1ic cl ass B1ackjackPAC extends J Frame {
Li stagens do cdigo do jogo vi nte-e-um
LISTAGEM E.18 8lackjackPAC. java (continuao)
J
publ iC static void main( String [] args ) {
J
JFrame frame new Bl ackj ackPAC().
frame .getContentPane(}.setBackgraund{ FOREST_GREEN )i
frame.setSize{ 580. 480 ).
frame.shaw();
private VPlayerFactory factary = new VPlayerFactorY()i
private JPanel players new Jpanel( new GridLayout( O. I ) ) i
private static final Colar FOREST GREEN = new Co l or( 35 . 142. 35 );
public Bl ackjackPAC() {
setup() ;
J
WindowAdapter wa new WindowAdapter() {
J ;
publ i c voi d windowCl osi ng( WindowEvent e ) {
System.exit( O )i
J
addWindowListener( wa ,;
II preci sa ser protegido se houver subcl asse
private void setup() {
J
VBlackjackDealer dealer factory.getOealer()i
GUIPlayer huma n = factory.getHuman() ;
dealer.addPl ayer( human };
players.add( dealer.view() );
players.add( human.view() ) ;
getContentPane().add( pl ayers . 8orderLayout.CENTER )j
LISTAGEM E.19 BlackjackSim. java
package bl ackjack . exe;
import blackjack.core.*;
import blackjack.ui.*;
import blackjack.players.*;
625
Apndi ce E
LI STAGEM E.19 8lackj ackSim. java
publ i c class BlackjackSim {
public static void main( String [] args } I
Console , INSTANCE.printMessage( "How many t imes should the simulator
pl ay?" ):
St ring response Consol e.INSTANCE. read Input( "invalid" ):
1nt loops Integer.parselnt( response ) :
Oeckpile cards new Deckpile() :
for( int i O: i < 4: i ++ ) {
ca rds . shuffl e () :
I
Deck deck new Deck():
deck.addToStack( cards ) :
cards.shuffl eO:
II cri a uma banca
Hand dealer hand new Hand() :
BlackjackOealer dealer" new Bl ackjackDealer( -Oeal er". dealer_hand. cards ) :
II cria um OneHitPl aye r
Bank one_bank new Bank( 1000 }:
Hand one_hand new Hand( ) ;
Pl ayer oplayer new OneHHPlayer( "OneHH", one_hand , one bank );
II cr ia um SmartPlayer
Bank smart_bank " new Bank( 1000 ) :
Hand smart_hand new Hand():
Pl ayer smplayer new SmartPlayer( "Smart" , smart_ha nd. smart_bank ):
II cria um SafePlayer
Bank safe_ban k t new Bank( 1000 }:
Hand safe_hand = new Hand() ;
Pl ayer spl ayer new SafePl ayer( "Safe" , safe_hand , safe bank ) i
II cria um FlipPlayer
Bank flip_bank new Bank( 1000 ) :
Hand flip_hand new Hand() ;
Player fplayer = new FlipPlayer( MFlip". flip_hand. fl i p_bank )i
II cria um jogador intel igente
Bank kn_bank new Bank( 1000 );
Hand kn_hand " new Hand();
Li stagens do cdigo do jogo vi nte-e-um
LISTAGEM E.19 8lackjackSim. java (continuao)
Pl ayer knpl ayer ,. new KnowledgeablePlayer( "Knowledgeable", kn_hand.
kn_bank );
J
J
/1 cri a um jogador "tlmo"
Bank opt_bank ,. new Bank( 1000 ) ;
Hand opt_hand new Hand();
Player optpl ayer ,. new OptlmalPl ayer( "Opti mal " , opt_hand. opt_bank );
1/ rene todos os jogadores
dealer.addlistener( Console.INSTANCE ) ;
oplayer.addlistener( Console . INSTANCE ) ;
dealer . addPlayer( opTayer )i
splayer.addlistener ( Consol e. INSTANCE )
dealer.addPlayer( splayer ) i
smplayer . addllstener( Console.INSTANCE )
dealer . addPlayer( smplayer )i
fplayer .addlistener( Console.INSTANCE )
dealer.addPl ayer( fplayer ) ;
knplayer.addlistener( Console.INSTANCE );
deal er.addPl ayer ( knplayer );
optplayer.addli stener( Console . INSTANCE );
dealer.addPlayer( optplayer li
int counter O;
while( counter < loops ) {
dealer . newGame( )
counter ++;
J
blackjack.players
627
bl ackjack. pI ayers contm os vrios jogadores que foram criados no texto e cm alguns dos
exerccios (listagens E.20 a E.26).
LISTAGEM E.20 COrmlandL i nePl ayer . j ava
package bl ackj ack.pl ayers

import blackjack.core.*
import blackjack .ui.*
Apndi ce E
LI STAGEM E.20 COl11TlandL i nePl ayer . java
publ i c class CommandLinePlayer extends BettingPlayer (
I
private final static String HIT " "H" :
private fi na 1 statlc String STANO "S" :
pri vate fi na 1 static String PLAY _ MSG = "[H] H ou [5] tay " ;
private fi nal static Str; ng BET_MSG = Pl ace Bet:(l O] [50] or [100]";
private fi nal static Str; ng 00 MSG "Oouble Oown? [i] es [N]o
" .
,
-
private fi na 1 static String BEl_lO = "10" :
private fi na 1 static Stri ng BEl_50" "50":
private fi na 1 static String BEl_IOO = "100" :
private final static String NO = "N":
private final static String YES = "Y" :
private fina 1 static String OEFAULT" "i nvali d":
publ ic CommandLinePlayer( String name , Hand hand , Bank bank ) (
supere name , hand, bank ):
I
protected boolean hit( Oealer dealer ) (
I
while( true ) (
I
Console. INSTANCE.printMessage( PLAY_MSG ) :
String response Console.INSTANCE. readlnput( OEFAULT );
if( response.equal sIgnoreCase( HI T ) ) I
return true:
I el se if( response.equalsIgnoreCase( STANO ) ) I
return false:
I
II se chegarmos at aqui . faz lao at obtermos uma entrada
II significativa
protected boolean doubleOown ( Oealer deal er ) (
I
while( true ) (
Console. INSTANCE.printMessage( OO_MSG ) ;
I
Stri ng response Consol e.INSTANCE.readlnput( OEFAUlT ):
if( response.equals IgnoreCase( NO ) ) (
return false;
lelse if( response.equalsIgnoreCase( YES ) ) {
return true;
II se chegarmos at aqui , faz l ao at obtermos uma entrada significativa
Li stagens do cdigo do jogo vinte-e-um
LI STAGEM E.20 Colt1t1andL i nePl ayer. j ava (cont inuoo)
J
protected void betO (
J
whl1e( true ) {
Co nsole . INSTANCE.pri ntMessage( BET_MSG )j
J
String response = Console . INSTANCE . readInput( DEFAULT )j
if( response.equal s( BET_I0 } ) I
getBank() . place lOBet()j
return j
J
if( response . equals( BET_50 ) ) I
getBank() . place50Bet() :
returnj
J
if( response .equal s ( BET_I00 ) } (
getBank().placelOOBet();
returnj
J
II se cheganmos at aqui. faz lao at obtenmos uma entrada
II s ignif icat iva
LISTAGEM E.21 Fl ipPlayer. java
package blackjack.players:
import blackjack.core.*;
publ ic class FlipPlayer extends BettingPlayer {
private boolean hit false;
private boolean should_hit_once false ;
publ ic Fl i pPlayer( Stri ng name. Hand hand. Bank bank ) {
supere name, hand , bank };
J
public boolean hit( Dea ler dealer ) {
if( should_hit_once && !hit ) {
hit .. true;
return true j
J
629
Apndice E
LISTAGEM E.21 Fll pPl ayer .java (continuao)
}
return false :
}
publlC voi d resetO I
super. reset O;
}
hit false ;
should hit once
- -
public void bet() I
getBank{) .placel OBetO ;
}
publi c boolean doubleDown( Dealer dealer ) {
ret urn false:
}
LISTAGEM E.22 KnowledgeablePlayer.java
package bl ackjack.players:
import blackjack. core . *:
publ i c cl ass Knowl edgeablePlayer extends BettingPl ayer I
public KnowledgeablePlayer( String name, Hand hand , Bank bank) I
supere name, hand, bank ) ;
}
publ ic boolean doubleDown( Dealer dealer ) {
int total getHandO . total O;
1f( total 10 I I total ,.'"' 11 ) {
return true:
}
ret urn false:
}
publ iC boolean hit( Dealer dealer ) I
int total. getHandO.total0:
Ca rd card = dealer. getUpCard( ) :
l/nunca di stribu i mais cartas , independente de qual, se total> 15
1f( total> 15 ) I
Li stagens do cdigo do jogo vi nte-e-um
LISTAGEM E.22 Knowl edgeab 1 ePl ayer . java (continuao)
I
I
return false;
I
l/sempre distribui mais cartas para 11 e menos
1f( t otal c- 11 ) {
return true;
I
l/isso deixa 11, 12, 13 , 14
l/baseia a deciso na banca
1f( card .getRank() .getRankO > 7 ) {
return true;
I
return false:
publ ic voi d bet() {
getBank().placelOBet();
I
LISTAGEM E.23 OneHitPlayer.java
package blackjack.players;
import blackjack . core.*:
publ i c class OneHit Player extends Bett1ngPlayer {
pr1vate boolean has_hit false :
publ iC OneHitPlayer( String name , Hand hand, Bank bank ) {
supere name , hand, bank ):
I
publ ic boolean hit ( Dea ler dealer ) {
1f( !has_hit ) {
has_hit - true;
return t rue;
I
return fa lse ;
631
I 632 Apndi ce E
LISTAGEM E.23 OneHitP1ayer .java (continuao)
}
}
public void reset() I
super.reset():
has hit .. false:
}
public void bet() {
getBank() .placelOBet():
}
publiC boolean doubleOown( Oealer dealer ) {
return false;
}
LISTAGEM E.24 Opt ima lPlayer.java
package bl ackjack . players :
import blackjack.core.*:
public class Opt imalPlayer extends BettingPlayer I
publi C OptimalPlayer( St ring name, Hand hand , Bank bank ) I
super( name , hand, bank ):
}
public boolean doubleOown( Oealer dealer ) {
i nt total .. getHand() . tota 1 () :
Card ca rd = dealer.getUpCard() :
if( total 11 ) {
return true:
}
H( total .... 10 ) {
}
if( card . getRank().getRank() != Rank.TEN.getRank() &&
card .getRankO )" Rank .ACE ) {
return true:
}
return fa l se:
ifl tot.1 9 } I
H( card.getRankO .... Rank. TWO II
card.getRank() .... Rank.THREE I I
Li stagens do cdigo do jogo vinte-e-um
LISTAGEM E.24 Opt imal Player . java (conmt inuoo)
}
}
}
card.getRankO == Rank.FOUR II
card . getRank() Rank.FIVE I I
card . getRank{) Rank.SIX ) {
return true;
return fal se ;
return false;
publi C boolean hit( Oealer dealer ) {
; nt total .. getHand O . tota 1 () ;
Card ca rd dealer.getUpCard() ;
H( total >. 17 ) {
return false;
}
H{ total " 16 ) {
}
H{ card.getRankO == Rank..SEVEN II
card . getRank() Rank.EIGHT I I
card . getRank {) Rank..NINE ) I
return true;
} else I
return false;
}
H{ total 13 II total 14 II total ... 15 ) {
}
if( card.getRank{) Rank.TWO I I
card.getRankO == Rank . THREE II
card.getRank.{) .... Rank .FOUR II
card.getRank{) ~ Rank . FIVE I I
card.getRank.{) == Rank . SIX ) {
return false;
} else {
return true;
}
if( total . ~ 12 ) {
H( card.getRankO == Rank..FOUR II
card . getRank() Rank.FI VE II
card.getRank{) Rank.S IX ) {
return false;
} else {
633
I 634 Apndice E
LISTAGEM E.24 Opt imal Player . java (conmt inuoo)
I
return true:
I
I
return truei
I
publ ic voi d betO {
getBank().pl acel OBet() :
I
LI STAGEM E.25 SafePlayer.java
package blackjack.pl ayers i
i mport bl ackjack. core.*:
publiC class SafePlayer extends BettingPlayer {
I
publ ic Sa fePlayer( String name , Hand hand, Bank bank ) (
super( name , hand. bank )i
I
publi C boolean hit ( Oealer dealer ) (
return falsei
I
publiC boolean doubleOown( Dealer dealer ) {
return fa lse i
I
public void bet() {
getBank() . placelOBetO i
I
LISTAGEM E.26 SmartPl ayer.java
package bl ackjack.players;
import blackjack. core.*i
public class Sma rtPlayer extends Bett i ngPlayer {
Li stagens do cdigo do jogo vinte-e-um
LI STAGEM E.26 SmartPlayer.java (continuao)
J
publiC SmartPlayer( St ring name, Hand hand , Bank bank ) (
super( name , hand, bank );
J
publiC boolean hit( Oealer dealer ) (
if( getHand().total() > 11) I
return fal se ;
J
return true ;
J
publiC void bet() I
getBank() .placelOBet();
J
publ ic boolean doubleOown( Dealer dealer ) {
return false;
J
blackjack.ui
blackjack.ui contm cdigo da UI comum (Listagem E.27).
LISTAGEM E.27 Co nsol e.java
package blackjack.ul ;
import blackjack.core.*j
import java . io.BufferedReader;
import java.io. lnputStreamReader j
import java.io.IOException:
publi C cl ass Console implements PlayerListener {
II console singleton
public final static Console INSTANCE = new Console() :
private BufferedReader in =
new BufferedReader( new InputStreamReader( System.in ) );
publiC void printMessage( String message ) (
Sys tem.out.print ln( message );
635
I 636 Apndi ce E
LISTAGEM E.27 Console .java (continuao)
}
}
publiC String readlnput( St r ing default_input ) (
String response;
}
try (
return i n.readLine();
I cat ch (IOException ioe) I
return default_input;
}
public void pl ayerChanged( Player pl ayer ) {
printMessage( player.toString() , ;
}
public voi d playerBusted( Player player ) I
printMessage( player.toStringO + "BUSTEOl" , ;
}
publ ic void playerBlackjack( Pl ayer player ) I
pr i ntMessage ( player.toStringO + "BLACKJACK!" );
}
publiC void playerStanding( Pl ayer player )1
printHessage( pl ayer . toStringO + "STANOING };
}
publi C void playerWon( Pl ayer pl ayer ) I
printMessage( pl ayer . toStringO + "WINNER!" );
}
publi C void playerLost( Pl ayer pl ayer ) I
printMessage( player.toStringO + "LOSER!" ,;
}
publiC void playerStandoff( Player player ) I
pr; ntMessage ( pl ayer. toSt ri ng () + "STANDOFF" );
}
l/privado para evi tar instanciao
private ConsoleO {}
blackjack.ui.mvc
blackjack. ui .mvc contm o cdigo mvc (listagens E.28 a E.34).
Li stagens do cdigo do jogo vinte-e-um
LISTAGEM E.28 Ca rdVi ew.java
package bl ackjack . ui .mvc ;
import blackj ack .core . *;
import javax.swing.*;
import java . awt.*;
publi c class CardView extends Jlabel (
I
I
pr i vate Imagelcon icon;
publiC CardView( VCard card ) (
get Image( card.get lmage() )j
set Icon( i con );
setBackground( Co lor.white );
setOpaque( true )i
pri vate void getlmage ( St ri ng name ) (
I
java.net.URl url this.getCl ass() . ge tResource( name l i
icon new Imagel con( url ) i
LISTAGEM E.29 GUIPlayer. j ava
package blackj ack . ui.mvc ;
import blackjack.core.*;
publ ic class GU IPlayer extends Bett ingPlayer {
private Dealer dealer;
pu bl iC GU IPlayer ( String name , Hand hand , Bank bank) (
supere name, hand , bank );
I
publ ic boolean hit ( Dealer dealer ) {
return truei
I
public voi d betO I
I I no faz nada , ist o no ser chamado
II em vez disso. o jogador humano pressiona um bot o da GUI
637
I 638 Apndi ce E
LISTAGEM E.29 GUIP1ayer.java (continuao)
}
}
II esses mtodos de aposta sero chamados pelo controlador da GUI
II para cada um: faz a aposta correta, muda o estado, penmite que a
II banca saiba que o j ogador tenminou de apostar
publ ic void placelOBetO I
getBank().placelOBet();
setCurrentState( getWaitingState() );
dealer.doneBetting( this );
publiC void place50Bet() (
}
getBank() .place50Bet();
setCurrentState( getWaitingState() );
dealer . doneBetting( this );
publ iC void placelOOBet() (
getBank() . pl acel OOBet() ;
setCurrentState( getWaitingState() ) ;
dealer.doneBetting( this );
}
}
}
II a aposta em dobro um pouco diferente , pois o jogador precisa
II responder aos eventos de Hand quando uma carta adicionada na mo
II de modo que configura o estado como Ooubli ngOown e depois o executa
protected boolean doubleDown( Dealer d ) I
setCurrentState( getDoublingDownState() );
getCurrentState().execute( dealer ) ;
return true;
II takeCard ser chamado pel o control ador da GUI quando o jogador
II decidir receber mais cartas
public void takeCard() {
dealer.hit( this ) ;
II stand ser chamado pel o controlador da GUl quando o jogador optar
II por parar. quando a parada mudar de estado. deixa o mundo saber. e depois
II diz banca
public void standO {
setCurrentSta te ( getS tandi ngS tate () );
not ifyStanding() ;
getCurrentState().execute( dealer );
Li stagens do cdigo do jogo vinte-e-um
LISTAGEM E.29 GUIP1ayer.java (continuao)
}
II voc precisa sObrepor play para que ele armazene a banca para
II uso posterior
public void play( Dealer dealer ) I
this.dealer dealerj
super.p l ay( deal er );
}
II o seguinte trata dos estados
protected PlayerState getPlayingState() I
return new Playing();
}
protected PlayerState getBettingState() I
return new Betting();
}
private class Playing implements PlayerState I
publiC void handPlayable() {
II no faz nada
}
publiC void handBlackjack() I
setCurrentState( getBl ackjackState() );
notifyBlackjack();
getCurrentState().execute( dealer ) ;
}
publiC void handBusted() I
setCurrentState( getBustedState() );
not ifyBus ted () ;
getCurrentState().execute( dealer );
}
public void handCh anged() I
notifyChanged();
}
publiC void execute( Dealer dealer ) I
}
II no faz nada aqui, as aes viro da GUI, Que
II externa ao estado, mas quando eventos vierem, certifica- se de
II forar a transio de estado imediatamente
639
I 640 Apndice E
LI STAGEM E.29 GUIP1ayer.java (continuao)
}
}
private class Betting implement s Pl ayerState I
public void handChanged{) {
II impossfvel no estado de estouro
}
public void handPlayable() {
II impos sfvel no estado de estouro
}
public void handBlackjack() {
II impossfvel no estado de estouro
}
public void handBusted() I
II impossfvel no estado de estouro
}
publ1c vold execute( Oea l er dealer ) I
II no faz nada aqui, as aes viro da GUI, que
II exter na ao estado, pois nenhum evento aparece como parte da
II aposta, o estado precisar ser mudado externamente para este estado
}
}
LISTAGEM E.30 OptionView.java
package blackjack . ui.mvc:
import blackjack . core.*;
import
import

Javax.swlng. :
. t
Java . aw . :
publi c class Op tionVi ew extends JPanel {
pub 1 i c
publi c
publ ic
publi c
publi c
publ ic
publ ic
publi c
private
pr; vate
private
static fi nal String NEW GAME
static fi na l String QUIT
static final String HIT
static final String STAND
static fi nal String BEl 10
-
static fi na l St r ing BEl 50
statlc final String BEl 100
static final String OOUBlE OOWN
JButton bet 10
JButton bet 50
JButton bet 100
new Jbutton(
new Jbutton(
-
new Jbutton(
"new":
"quit" :
-
"hit";
"stand":
"BETlO" :

-BETlOO
M
;

Mdd'"

"$10" );
"$50" ):
"$100" l:
Li stagens do cdigo do jogo vinte-e-um
LISTAGEM E.30 Opt i onVi ew .java (continuao)
private JButton deal new Jbutton( NNew Game- );
priva te JButton quit new Jbutton( "Quit- );
private JButton hit new Jbutton( "Hit" ) ;
private JButton stand = new Jbutton( Stand
N
):
private JButton ddown z new Jbutton( -Double Down );
pr ivate BlackjackDealer dealer:
private GUIPlayer player:
private stat1c final Color FOREST_GREEN = new Co lor( 35 , 142, 35 ) :
publi C OptionView( GUIPlayer player , BlackjackDealer deal er ) I
super( new BorderLayout() ):
this.player player:
this.deal er dealer;
attachController( makeControl ler() );
buildGUI ();
I
publiC void attachController( OptionViewControl ler controller )1
deal.addActionl istener( control ler ) :
quit.addActionlistener( controller ) ;
I
hit . addActionListener( controll er ) ;
stand.addActionlistener( controller ):
bet_lO.addActionListener( controller ):
bet_50.addActionlistener( controller ) ;
bet_lOO. addActionListener( controller ):
ddown.addActionlistener( controller }:
public void enableDoubleDown( boolean enable ) I
ddown . setEnabled( enable };
I
publi C void enableBettingControl s( boolean enable ) I
bet_l O. setEnabled( enable );
bet_50. setEnabled( enable ) :
bet_lOO.setEnabled( enabl e );
I
public void enablePlayerControls( boolean enabl e ) (
hit . setEnabl ed( enable );
stand. setEnabled( enable l ;
I
public vo1d enableGameControls( bool ean enabl e ) I
641
Apndice E
LI STAGEM E.30 OptionView. j ava (con tinuao)
J
J
deal. setEnabled( enable};
quit . setEnabled( enable );
protected Op t ionViewCont roller makeController(} {
return new Opt i onVi ewControl ler( player, dealer, this };
J
private vo1d buildGUI() I
J
JPanel betting_controls new JPanel () ;
JPa nel game_control s = new Jpanel() ;
add ( betting_controls. Border layout.NORTH );
add( game_controls. Borderlayout . SOUTH );
betting_control s . setBackground{ FOREST_GREEN };
game control s . setBackground( FOREST GREEN );
- -
ddown. setAc ti onCommand( DOUBlE_DOWN ) ;
dea l .setActi onComma nd( NEW_GAME ) i
quit. setActionCommand( QUIT }i
hit . setActionComma nd( HIT ) ;
stand .setAct i onCommand( STAND ) ;
bet_lO.setAct i onCommand ( BET_lO l ;
bet_50.setActionCommand( BET_50 l;
bet_lOO. setAct ionCommand( BET_100 };
betting_control s.add ( bet_lO l ;
bett i ng_control s.add ( bet_50 l ;
betti ng_controls . add ( bet_IOO l ;
game_contro l s . add( ddown };
game_control s.add( hit l ;
game_control s . add( st and };
game_control s .add( deal ) ;
game_controls.add( quit };
enableBettingControl s( fal se );
enablePlayerControls( false };
enableDoubleDown( false };
LI STAGEM E.31 Opt i onVi ewControl l er . j ava
package blackjack.ui.mvc;
import blackjack. core. ;
import java. awt.event . ;
Li stagens do cdigo do jogo vinte-e-um
643
LI STAGEM E.31 Dpt 1 onVi ewContro 11 er .java (cont inuoo)
publiC class OptionViewController implements Actionllstener , Pl aye rlistener {
prlvate GUIPlayer mode1i
private QptionView view:
private BlackjackDealer dealer;
public OptionViewControl 1er( GUIPlayer model , BlackjackOealer dealer ,
OptionView view ) (
J
thls.model model i
model.addlistener{ this ) i
this.dealer dealer ;
thls.view view;
view.enablePlayerControls( false ) i
public void actionPerformed( ActionEvent event ) {
if( event.getActionCommand() . equals( OptionView.QUIT ) ) (
System.exit( O )i
) else if( event.getActionCommand().equals( OptionView. HIT ) ) (
view.enableDoubleOown( false ) i
model.takeCa rd( );
} else if( event . getActionCommand().equals( OptionView.STAND ) ) {
view.enableOoubleOown( false };
mode l. standOi
} else if ( event.getActionCommand().equal s( OptionView. NEW_GAME ) ) {
view.enableOoubleDown( false )i
view.enableGameControls( false };
view.enablePlayerControls( false )i
view.enableBettingControls( true )i
dealer.newGame();
I else i f{ event.getActionCommand().equals( OptionView.BET_lO ) ) {
vlew. enableBettingControls( false };
view.enablePlayerControls( t rue )i
view.enableDoubleDown( true ) ;
model.placelOBet()i
) else if( event.getActionCommand().equals( OptionVi ew.BET_50 l ) {
view.enableBettingControl s( false li
vlew. enablePlayerControls( true );
view.enableDoubleOown( true )i
model.place50Bet() ;
} else if( event.getActionCommand() . equals( OptionView.BET_lOO ) ) {
view.enabl eBettingControl s( false )i
view.enabl ePlayerControls( t rue );
view.enableOoubleOown( true ):
model.placelOOBetO i
I 644 Apndice E
LI STAGEM E.31 OptionVi ewController.java (continuao)
I
} else if( event.getActionCommand().equals( OptionView.OOUBLE_OOWN ) ) {
view.enableBettingControls( false };
view. enablePlayerControl s( false );
view.enableOoubleOown( false );
view.enableGameControls( true );
model.doubleOown( dealer );
I
I
public voi d pl ayerChanged( Player player } {}
publiC void playerBusted( Player player ) {
view.enablePl ayerControls( false ) ;
view.enableOoubleOown( false ) ;
view.enableGameControls( true ) ;
I
publ iC void playerBlackjack( Player player ) {
view.enablePlayerCont rols( false };
view.enableOoubleOown( fal se ) ;
view.enableGameControls( true ) ;
I
publiC void playerStanding( Player player ) (
view.enablePlayerControl s( false ) ;
view.enableGameControls( true );
I
public void playerWon( Player player ) (
view.enablePlayerControls( false );
view.enableGameControls( true );
I
publiC void playerLost( Player player } (
view.enablePlayerControls( false );
view.enableOoubleOown( false };
view.enableGameControls( true );
I
public void playerStandoff( Player player ) (
view.enablePlayerControl s( fal se );
view.enableGameControls( true };
I
Li stagens do cdigo do jogo vinte-e-um
LISTAGEM E.32 PlayerView.java
package bl ackjack . ui .mvc:
import blackjack.core . *:
import
import
import
import
. .
Javax.swlng. :
javax.swing.border.*:
. t
Java.aw . j
java.util.lterator:
public class PlayerView extends JPanel implements PlayerL1stener {]
private JPanel cards new JPanel (new FlowLayout( FlowLayout.LEFT ) ):
private T;tledBorder border:
publi c Pl ayerView( Player player ) (
super( new Border LayoutO ):
bUildUI( player )i
player.addListener( this );
I
public void playerChanged( Player pl ayer ) (
border.setTille( player . getName() ) :
cards.removeAl 1():
I
Hand hand player.gelHand() :
Iteralor i hand.getCards();
while( 1.hasNext() ) (
I
VCard vcard (Vcard) i.next() :
JLabel card : new CardView( vcard ) ;
cards.add( card ):
reval idateO;
repa;ntO i
publi c voi d playerBusted( Player player ) (
border.setTitle( player.getNameO + " BUSTED!" l;
cards . repaint();
I
publ ic void playerBlackjack( Player pl ayer )(
border.setTille( player.getName() + };
cards. repaint( ) i
I
public void playerSlanding( Player player ) (
border.setTitle( player.getNameO + STANOING " ) ;
cards. repaint():
645
I 646 Apndice E
LISTAGEM E.32 Pl ayerVi ew . java (con tinuao)
}
}
public voi d playerWon( Player playe r ) I
border.setTitle( playe r.getNameO + " WINNER!" )i
cards.repaint( )i
}
publ ic vold pl ayerLost( Player player ) (
border.setTitle( player.getName() + " LOSER!" li
cards .repaint() ;
}
pu bli c voi d pl ayerStandoff( Player player ) I
border.setTitle( player.getNameO + " STANDOFF!" ) i
cards .repaint():
}
pri vate void buildUI( Player pl aye r ) (
add ( cards . Borderlayout.NORTH l i
}
borde r new TitledBorder ( player .getName () l:
cards.set6order( border );
cards.setBackground( new Color( 35. 142 . 35 ) li
border.setTit leCo lor ( Color.black li
LISTAGEM E.33 VCard.java
package blackjack.ul.mvc :
import blackjack . core. *j
public cl ass VCard extends Ca rd I
private String imagei
publi c Ycard( Suit suit , Rank rank, St ring lIl1dge ) I
super( suit. rank ) i
thi s. image imagei
}
publiC St ring getlmage() {
if( isFa ceUp() ) (
return image i
Li stagens do cdigo do jogo vinte-e-um
LISTAGEM E.33 VCard.java (continuao)
} else {
return "/ b 1 ackj ack/ ui / bi tmaps/ empty _pi 1 e. xbm" ;
}
}
}
LISTAGEM E. 34 VDeck . java
package blackjack.ui .mvc ;
import blackjack.core.*j
import java.util . lterator;
publi C class VDeck extends Deck {
protected void buildCardsO {
// Isso horrvel, mas melhor do que os laos e estruturas
condi cionais alternativas
Ca rd () deck new Card [52];
setOeck( deck );
deck [O] new Vcard( Suit.HEARTS, Rank.TWO,
"/ blackjack/ ui / bitmaps/ h2" l;
deck [1] new Vcard( Suit. HEARTS , Rank.THREE,
/ blackjack/ ul / bitmaps/ h3" ,;
deck [2] new Vcard( Suit.HEARTS, Rank.FOUR,
"/b 1 ackj aCk/u i /bi tmaps/h4" ,;
deck [3] new Vcard( Suit.HEARTS, Rank.FIVE,
"/ b 1 ackj ac k/u i /bi tmaps/h5" ) :
deck [4 ) = new Vcard( Suit.HEARTS, Rank . SIX .
"/b 1 ac kj ac k/u 1 /bi tmaps/h6" ):
deck [5] new Vcard( Suit.HEARTS, Rank.SEVEN,
"/bl ackjack/ui/bitmaps/h7" );
de ck [6] new Vcard( Suit.HEARTS . Rank.EIGHT,
/blackjack/ ui /bi tmaps/h8" ):
deck [7] new Vcard( Suit.HEARTS. Rank.NINE,
"/ blackjack/ ui / bitmaps/ h9" };
deck [8 ] new Vcard( Suit .HEARTS , Rank.TEN,
"/ blackjack/ ui/ bitmaps/ hIO" ):
deck (9] new Vcard( Su it . HEARTS, Rank . JACK ,
"/ blackjack/ ui / bitmaps/ hll );
deck [10] new Vcard( Suit . HEARTS, Rank.QUEEN ,
/ blackjack/ ui / bitmaps/ hI2" );
647
I 648 Apndice E
LI STAGEM E.34 VOeck.java (continuao)
deck (11] new Vcard( Suit.HEARTS . Rank.KING.
"j blackjackj u1 j b1tmapsj h13" );
deck [12] new Vca rd( Suit.HEARTS . Rank.ACE.
"j blackjackj ui j bitmapsj hl " );
deck (13] " new Vcard( Sult.DIAMONDS . Rank . TWO.
"j bl ackjackj ui j bi tmapsj d2" );
deck [14] " new Vcard( Suit . DIAMONDS . Rank.THREE.
"/ bl ackjackj ui /M tmapsj d3" ) ;
deck [1 5] new Vcard( Suit.OIAMONDS. Rank.FOUR.
"/b 1 ackj ackju i /bi tmaps/d4" ) ;
deck [16) new Vcard ( Suit.OIAMONDS , Ra nk. FIVE ,
"/b 1 ac kj ac k/u i /bi tmaps/d5" ) ;
deck (1 7) " new Vcard( Sui t.OIAMONDS. Ra nk. SIX.
"/ b 1 ackj ackju i /b i tmaps/d6" ) ;
deck [18J new Vcard( Suit. OI AMONDS . Rank.SEVEN.
"/blackjack/ui/bitmaps/d7" );
deck [19] " new Vcard( Suit.DIAMONDS , Rank.EIGHT,
"j blackjack/ ui / bitmaps/ d8" );
deck [20] new Vcard( Suit .OIAMONOS . Rank.NINE .
-j blackjack/ ui j bitmaps/ d9" );
deck [21J " new Vcard( Suit.OIAMONOS. Rank . TEN.
"j blackjackj ui j bitmapsj dlO" );
deck [22] " new Vcard( Suit.DI AMONOS. Rank.JACK.
"/ blackjackj ui j bitmapsj dl1" );
deck [23] new Vcard( Suit.DIAMONOS. Rank .QUEEN.
"j bl ackjackj ui j bi tmapsj dl 2" ) ;
deck [24] new Vcard( Suit.OIAMONDS . Rank.KING,
"/ blackjackj ui / bi tmapsj d13" ) ;
deck [25] new Vca rd( Suit.OIAMONDS. Rank.ACE.
"/blackjackjui/bltmaps/dl" ) ;
de ck [26) " new Vca rd( Suit.SPADES. Rank.TWO.
"/bl ackjack/ui/bitmaps/s2" );
deck (27) " new Vcard( Suit.SPADES. Rank.THREE.
"/bl ackjackjui / bitmaps/s3" );
deck [28] new Vcard( Suit.SPAOES. Rank.FOUR.
"/blackjack/ui/bltmaps/ s4" );
deck [29] " new Vcard( Suit.SPADES. Rank.FIVE.
"j blackjackj ui / bltmaps/ s5" );
deck [30] new Vcard( Suit.SPAOES. Rank.SIX.
-j blackjack/ ui j bitmapsj s6" );
deck [31] = new Vcard( Suit.SPADES. Rank.SEVEN.
"j blackjackj ui j bitmapsj s7 " );
deck [32] " new Vcard( Suit.SPAOES. Rank.EIGHT,
"j blackjackj ui j bitmapsj s8" );
deck (33] new Vcard( Suit.SPAOES. Rank.NINE,
Li stagens do cdigo do jogo vi nte-e-um
LI STAGEM E.34 VOeck.java
-j blackjackj ul j bitmapsjs9" );
deck [34] new Vcard( $uit.SPADES. Rank.TEN.
Mj blackjackj ui j bitmapsj slO" );
deck [35] = new Vcard( Suit . SPAOES , Rank.JACK.
-j blackjackj ui j bitmapsjsll" );
deck [36] new Veard( Suit . SPAOES. Rank.QUEEN.
"/ blackjackj ui j bitmapsj sI2" );
deek [37J new Veard( Suit.SPAOES. Rank.KING.
"/ b 1 ackj ackju 1 / bl tmapsjs 13" );
deek [38J new Veard( Suit.SPAOES. Rank.ACE.
"/ b 1 aekj aekj u i / bi tmaps/s 1" );
deek [39J new Veard( Suit.CLUBS . Rank . TWO,
"/bl aekjaekjui/bitmaps/c2" ) ;
deek [40) new Veard( Suit.CLUBS . Rank . THREE .
"/bl aekjaek/ ul / bitmaps/c3" );
deek [4 1] new Vcard( Suit.ClU8S. Rank.FOUR.
"/ blaekjaek/ ui / bitmaps/c4" ,;
deck [42] new Vcard( Suit.ClUBS . Rank.FIVE,
Mj blaekjaek/ui j bi t ma ps/c5" )i
deck [43] new Vcard( Suit.ClUBS. Rank.S IX.
-j blackjackj ui j bitmapsjc6" ,;
deck [44] new Vcard( $uit.ClUBS. Rank.SEVEN.
-j blackjackj ui j bitmapsjc7" 'i
deck [45] new Vcard( Suit . ClUBS. Rank . EIGHT.
-/ b 1 ackjackj ui / bi t maps/c8" );
deck [46J new Veard( Suit.CLUBS. Rank . NINE.
H j blackjackjui j bi tmapsje9" );
deek [47] new Veard( Suit.CLUBS. Rank . TEN ,
"/ b 1 ackj aekj u i / bi tmapsje 10" ) ;
deek [48J new Veard( Suit.CLUBS . Rank.JACK.
"/b 1 aekj ae kj u i / bi tmaps/ c 11" );
deek [49] new Vcard( Suit .CLUBS . Rank.QUEEN.
"/bl aekjaekj ui/bitm apsje12" 'i
deek [50) = new Veard( Suit .CLUBS . Rank . KING .
"/b 1 ackj ae k/ u i / bitmaps/ c 13" ) ;
de ek [51} new Veard( Suit.ClU8S. Rank.ACE.
};
I
I
blackjack.ui.pac
b 1 ackj ae k. ui . pac contm o cdigo pac (listagens E.35 a E,42).
649
Displayable.java
package blackjack . ui . pac:
import javax.swing.JComponent:
publiC interface Oisplayable I
public JComponent view() :
}
Listagem E.36 GUIPlayer.java
package blackjack.ui.pac:
import blackjack.core.*;
i mport javax.swing.*:
import java.awt.*:
i mport java.awt.event.*:
Apndice E
publiC class GUIPlayer extends VBettingPlayer impl ements Displayable (
private BlackjackDealer dealer;
private JPanel view:
pUblic GUIPlayer( Str ing name , VHand hand, Bank bank . VblackjackDealer
_ dealer ) I
}
super( name. hand, bank ):
this .dealer dealer ;
public boolean h1t( Dealer dealer ) I
return true;
}
public void bet() I
II no faz nada, isto no ser chamado
II em vez disso, o jogador humano pressiona um boto da GUI
}
II esses mtodos de aposta sero chamados pelo controlador da GUI
II para cada um: faz a aposta correta, muda o estado. permite que a
II banca saiba que o jogador terminou de apostar
public void placelOBet() {
getBank().pl acelOBet():
setCurrentState( ge tWai tingState() ) :
dealer.done8etting( thi s ) :
Li stagens do cdigo do jogo vinte-e-um
LISTAGEM E.36 GUIP1ayer.java (continuao)
}
public void place50Bet () {
getBank().place50Bet();
setCurrentState( getWaitingState() );
dealer.doneBetting( this ):
}
public vo1d placelOOBet() {
getBank().placeIOOBet() :
setCurrent State( getWaitingState() ) ;
dealer . doneBetting( this ):
}
II a aposta em dobro um pouco diferente, pois o jogador precisa
II responder aos eventos de Hand quando uma carta adicionada na mo
II de modo que configura o estado como DoublingDown e depois o executa
protected boolean doubleOown( Dealer d ) {
}
setCurrentState( getOoublingOownState() ) ;
getCurrentState().execute( dealer ) :
return true :
II takeCard ser chamado pelo controlador da GUI quando o jogador
II decidir receber mais cartas
public void takeCard() {
dealer.hit( this );
}
II stand ser chamado pelo controlador da GU I quando o jogador optar
651
II por parar, quando a parada mudar de estado, deixa o mu ndo saber, e depois
II diz ba nca
publi c void standO {
}
setCurrentState( getStandingState() );
notifyStandi ng():
getCurrentState() . execute( dealer l :
publ ic JComponent view() {
if( view ,,= null ) {
view = new Jpanel( new Borderlayout() ):
JComponent pv " super.view():
GUIView cv new GUIView();
addListener( cv l;
view.add( pv, BorderLayout. CENTER ):
I 652 Apndi ce E
LISTAGEM E.36 GUIP1ayer.java (continuao)
view.add( cv, Bo rderlayout.SOUTH );
I
return view;
I
II o seguinte trata dos estados
protected PlayerState getPlayingState() (
return new Playing()j
I
protected PlayerState getBettingState() I
return new Betting() ;
I
private class Playing implements PlayerState {
I
publiC void handPlayableO I
II nlio faz nada
I
publiC void handBl ackjack() (
setCurrentState( getBlackjackStateO );
notifyBlackjack():
getCurrentState().execute( dealer )j
I
public void handBusted() (
setCurrentState( getBustedState() ) ;
notifyBustedO:
getCurrentState().execute( dealer l i
I
public voi d handChanged{) {
not i fyChanged () ;
I
publ i c void executeI Oea l er dealer ) (
I
II nlio faz nada aqui, as aes viro da GUI , que
II externa ao estado, mas quando eventos vierem, certifica-se de
II forar a transio de estado imediatamente
private class Betting implements Pl ayerState I
public void handChanged() {
II impossfvel no estado de estouro
Li stagens do cdigo do jogo vinte-e-um
653
LI STAGEM E.36 GUI P1ayer.java (cont inuao)
I
}
publ ic vol d handPlayable() {
II impossfvel no estado de estouro
}
publ ic void handBlackjack() {
II impossfvel no estado de es t ouro
}
pu bl lc void handBusted{) {
II impossfvel no estado de estouro
}
publ ic void execut e( Dealer dealer ) {
II ~ o faz nada aqui, as aes viro da GU I. que
II externa ao estado, pois nenhum evento aparece como parte da
II aposta, o estado preci sar ser mudado externamente para este estado
}
}
private class GU IView extends JPanel implement s Playe rl ist ener , Act ionl istener
private JButlon bet 10
-
new Jbutton ( "$10 }:
pri vate JButton bet 50 new Jbutton( "$50 ) ;
prlvate JButton bet 100 new Jbutton( "$100 };
-
pri vate JBut ton dea l new Jbutton { NNew Game" };
pri vate JButt on quit new Jbutton{ Quit"
} :
pr i vate JButt on hit new Jbutt on( "Hit"
} :
pr i vate JButton stand new Jbutton ( Stand"
) :
private JBut ton ddown new Jbutton ( "Double Down"
) :
pr ivate fi nal String NEW GAME "new" :
-
pr ivate fi na l String QUIT "quit" ;
pr ivat e final String HIT "hit";
private f inal Str ing STAND "stand":
private final St ring BET 10
-
"BETlO"

-
private final St ring BET 50 "BET50" ;
-
private final String BET 100 "BETlOO" ;
private fi na 1 St ring O DOWN "ODown " .

private final Color FOREST GREEN = new Color( 35 . 142. 35 );
publ iC GUIView() (
}
supe r e new BorderLayoutO );
GUIPlayer.thi s.addl istener ( this ) ;
bui 1 dGUI ();
I 654 Apndi ce E
LI STAGEM E.36 GUIP1ayer.java (continuao)
private void buildGUI() I
I
JPanel bett i ng_controls new Jpanel():
JPanel game_control s new JPanel():
add( betting_controls . Borderl ayout.NORTH ):
add( game_controls. Borderlayout.SOUTH ):
betting_controls.setBackground( FOREST_GREEN ) ;
game_control s.setBackground( FOREST_GREEN ):
deal.setActionCommand( NEW_GAME ) :
deal.addActionlistener( this );
qu i t.set ActionCommand( QUIT ) :
qu i t.addActionlistener( this ) :
hit.setActionCommand( HI T ) ;
hit . addActionlistener( this ) :
stand.setActionCommand( STAND ):
stand.addActionlistener( this ):
bet_lO.setActionCommand( BET_IO ) :
bet_IO. addActionlistener( this );
bet_SO. setActionCommand( BET_50 ):
bet_50 .addActionlistener( this );
bet_IOO.setActionCommand( BET_IOO ):
bet_IOO.addActionlistener( this ):
ddown. setActionCommand( D_OOWN ):
ddown.addActi onli stener( this ) :
betting_control s.add( bet_IO );
betting_control s.add( bet_50 );
betting_controls.add( bet_IOO ) ;
game_control s.add{ ddown ):
game_control s.add{ hit ) :
game_control s.add{ stand );
game_control s.add{ deal ) :
game_control s.add( quit ) :
enableBettingControls( false ) ;
enablePlayerControls( fa l se ) :
enabl eDoubleOown( false }:
private void enableBettingControls( boolean enable ) I
bet_lO. setEnabled( enable };
bet_50 . setEnabled( enable );
bet_lOO.setEnabled( enabl e ):
I
private void enablePlayerControls( bool ean enable ) {
Li stagens do cdigo do jogo vinte-e-um
LI STAGEM E.36 GUIP1ayer.java (continuao)
}
hit.setEnabled( enabl e li
stand . setEnabl ed( enable )i
private void enableGameControls( boolean enabl e ) (
deal.setEnabled( enabl e )i
quit.setEnabled( enable );
}
private void enableDoubleDown( boolean enable ) {
ddown,setEnabled( enable );
}
public void actionPerformed( ActionEvent event ) {
if( event.getActionCommand(),equal s( QUIT ) l {
System.exit( O ,;
lelse if( event.getActionCommand().equals( HIT ) ) {
enabl eDoubleDown( false );
takeCard O i
)else if( event.getActionCommand().equals( STANO ) ) {
enableOoubleOown( false l i
standO i
)e l se i f ( event.getActionCommand().equals( NEW_GAME ) ) {
enabl eOoubleOown( false );
enabl eGameControls( fa lse );
enablePlayerControls( false )i
enableBettingControls( true )i
dealer,newGame();
lelse if( event .getActionCommand(),equals( BET_IO ) ) {
enableOoubleDown( true )i
enableBetti ngControls( false )i
enablePlayerCont rols( true );
pl acelOBet () i
lelse if( event.getActionCommand() .equals( BET 50 } ) {
enableOoubleDown( true ) i
enableBettingControls( false }i
enablePl ayerControls( true ) i
placeSOBet() i
)else if( event.getActionCommand().equals( BET 100 ) ) {
enableOoubleOown( true );
enableBettingControl s( false l i
enabl ePlayerControls( true );
placelOOBetO;
}else if( event.getActionCommand().equals( O OOWN ) ) I
enabl ePlayerControls( false lj
655
I 656 Apndi ce E
LISTAGEM E.36 GUIP1ayer.java (continuao)
I
I
I
I
enabl eDoubleDown( false ) ;
doubl eDown( dealer );
public void playerChanged( Player pl ayer ) {}
publiC void playerBusted( Pl ayer player ) (
enablePlayerControls( false ) ;
enableGameControls( true ) ;
I
public void playerBl ackjack( Pl ayer player ) {
enabl eDoubleDown( false ) ;
enablePl ayerControls( fa l se ) ;
enableGameContrOl S( true };
I
publiC void playerStanding( Player player ) (
enabl ePlayerCont rols( fa l se l ;
enableGameControls( true l ;
I
publiC void playerWon( Player player ) (
enablePlayerControl s( false );
enableGameControls( true ,;
I
public void playerLost( Player player ) {
enableDoubleDown( false ) ;
enablePl ayerControls( false ) ;
enableGameControls( true , ;
I
publiC void playerStandoff{ Player pl ayer ) {
enabl ePlayerControls( false };
enabl eGameControl s{ true };
I
Li stagens do cdigo do jogo vi nte-e-um
LISTAGEM E.37 VBettlngPlayer.java
package bl ackjack . ui . pac;
import blackjack.core . *;
lmport java.awt.*;
import javax.swlng.*;
import javax.swing . border.*;
public abstract class VBettingPlayer extends BettingPlayer implements
- Oisplayable {
private BettingView view;
public VBettingPlayer( String name , VHand hand, Bank bank ) {
supere name, hand. bank ) ;
I
publ iC JComponent view() {
H( view ... null ) {
I
I
vlew new BettingView( (VHand)getHandO );
addListener( view );
return view;
II Note que tudo que essa classe faz recuperar o modo de vlsualiza!o de
Hand. adi ciona esse modo
657
II em si mesmo e atualiza a borda , conforme for necessrio. Note o que essa
classe no faz:
II atualiza as cartas quando elas mudam. 00 ponto de vista deste modo de
visualizao. a
Ilatuallzaao da carta acontece automaticamente, pois VHand atualiza sua
exibio nos
Ilbastidores
private class BettingView extends JPanel implements Pl ayerListener {
private TitledBorder border;
publiC BettingVlew( VHand hand ) (
I
supere new FlowLayout( Fl owLayout.LEFT ) );
buildGUI( hand.view() );
publiC void playerChanged( Player pl ayer ) {
String name VBettingPlayer.this.getName();
Apndice E
LISTAGEM E.37 VBett 1 ngPl ayer .java (continuao)
}
}
border.setTit l e( name ):
repalntO:
publ iC void player6usted( Player player ) (
String name VBettingPlayer.this.getHame():
border.setTitle( name + " BUSTEO!" )i
repaint()i
}
publ iC void playerBlackjack( Player player ) {
String name VBettingPlayer.this.getName()i
border.setTitle( name + " BLACKJACK!" )i
repa i ntO:
}
publiC void pl ayerStanding( Player player ) (
String name V6ettingPlayer . this.getName() ;
border. setTitle( name + " STANDING ):
repa intO ;
}
publ ic void playerWon( Pl ayer pl ayer ) (
String name VBettingPlayer. t his .getHame() i
border.setTit l e( name + " WINNER! " ):
repaintO;
publ ic void playerLost( Player player ) (
}
String name VBettingPlayer.this.getName() :
border.setTitle( name + " LOSER !" );
repaintO i
publiC void playerStando ff( Player player ) (
St ring name VBettingPlayer.this.getName()i
border.setTitle( name + " STANDQFF !" ) i
repaint() ;
}
pri vate void buildGUI( JComponent hand )(
border new TitledBorder( V6ettingPlayer.thi s.getNameO );
setBorder ( border ) ;
setBackground ( new Col or( 35 , 142, 35 i
border . setTlt l eCol or( Co l or.bl ack ) ;
Li stagens do cdigo do jogo vinte-e-um
LISTAGEM E.37 VBettlngPlayer.java (continuao)
add( hand );
}
}
}
LISTAGEM E.3S VBlackjackDealer.java
package blackjack.ui.pac ;
import blackjack.core.*;
import blackjack.core.threaded.*;
import javax . swing.*;
import javax.swing.border.*;
import java.awt.*;
public class VBlackjackDealer extends ThreadedBlackjackDealer implements
Displayable {
private OealerView view;
public VBlackjackDealer( String name, VHand hand, Deckpile cards ) {
supere name . hand, cards ) ;
}
publi c JComponent view() {
if(v1ew null ) (
}
}
v1ew new OealerView( (VHand)getHand() );
addlistener( view );
return view;
II Note que tudo que essa classe faz recuperar o modo de v1sualizaao de
Hand, adiciona esse modo
II em si mesmo e atualiza a borda conforme for necessrio .Note o que essa
classe no faz:
II atual iza as cart as quando elas mudam. 00 ponto de vista desse modo de
visualizao.
659
II a atualizao da carta acontece automaticamente, pois VHand atualiza sua
exibio
II nos bast idores
private class OealerView extends JPanel impl ements Playerlistener {
private TitledBorder border ;
I 660 Apndice E
LISTAGEM E.3S VBlackjackOeal er . java (continuao)
publiC Oeal erView( VHand hand ) I
J
supe r e new Fl owlayout( Fl owlayout.lEFT ) );
Stri ng name VBlackjackOealer.this.getName() ;
border = new Ti tledBorder( name );
setBorder ( border ) ;
setBackground ( new Col or( 35 . 142. 35 ) ) i
border.setTit leColor( Co l or . black ) ;
add( hand.view() ) i
repaintOi
publiC voi d playerChanged( Player player ) {
St ring name VBlackjackDealer . this.getName()i
border.setTitle( name );
repalntO i
J
publ iC void pl ayerBust ed( Player player ) {
J
String name VBlackjackOeal er.this .getName() ;
border.setTitle( name +" BUSTED! ") i
repaintO i
publ iC voi d playerBl ackjack( Player player ) I
Stri ng name VBlackjackDealer . this.getName() ;
border.setTitle( name + " BlACKJACK!" )i
repa intO;
J
pu bl ic void playerStandi ng( Player pl ayer ) (
String name VBlackjackDealer. this . getName ()i
border.setTit le ( name + " STANDING " );
repaintOi
J
publ ic void pl ayerWon( Playe r player ) {
J
String name VBlackjackOealer.this .getName() i
border. setTitle( name + " WINNER!" ) ;
repaintO i
publ ic voi d pl ayerLost( Playe r player ) (
String name VBlackjackDealer . this.getName():
border.setTit le( name + " LOSER!- )i
repaintOi
Li stagens do cdigo do jogo vinte-e-um
LI STAGEM E.3S VBlackjackOeal er . java (continuao)
I
I
I
publ i c void playerStandoff( Player player } I
Stri ng name z VBlackjackOealer . this.getName();
border . setTit l e( name + M STANOOFF!M };
repa intO;
I
LI STAGEM E.39 VCa rd. java
package blackjack.ui.pac;
i mport
i mpor t
blackj ack . core.*;

Javax.swlng. ;
. t t
l mpor Java.aw . ;
publ i c class VCa rd extends Card implements Displayabl e {
private Stri ng image ;
private CardView view;
publ ic IJcard( Suit suit, Rank rank . String image ) (
supere sui t, rank l ;
thi s. image image ;
view = new CardlJiew( getImageO );
I
publ iC void set Fa ceUp( boolean up ) I
super. se tFaceUp( up );
view. changed();
I
public JComponent view() I
return view;
I
pri vate String get Image( ) (
i f( i sFaceUp() ) (
return image ;
) else {
return "/ blackj ack/ ui / bi tmaps/ empty pile.xbm
M
;
661
I 662 Apndice E
LISTAGEM E.39 VCard.java (continuao)
}
}
}
private class CardView extends JLabel {
}
publi c CardView( St ring image ) {
setImage( image ) ;
setBackground( Color.white );
setOpaque( true );
}
publie void changed(){
set Image( getlmage() );
}
private void setImage( String image ) {
}
java . net.URL url .. this .getClass().getResouree( image );
Imagel eon ieon .. new ImageIeon ( url ) ;
set lcon( ieon );
LISTAGEM E.40 VDeck . java
package blackjack . ui.pae ;
import blaekjaek.eore.*;
import java . uti l .Iterator;
publi c class VOeck extends Oeck {
protected void buildCards () {
II Isso ho rrvel. mas me lhor do que os l aos e as estrut uras
condicionai s alternativas
Card [] deck" new Card[52] ;
setDeck( deck ) ;
deck (O] .. new Vcard( Suit.HEARTS. Rank. TWO .
-/ blackjack/ ui / bitmaps/ h2" ):
deck (1] z new VCard(Suit.HEARTS. Rank. THREE .
-/ blackjack/ ui / bitmaps/ h3" );
deck [2] .. new Vcard( Suit. HEARTS. Rank . FOUR.
Li stagens do cdigo do jogo vinte-e-um
LI STAGEM E.40 VOeck.java (continuao)
- j b 1 ackjackj u; j bi tmaps j h4" );
deck (3) new Vcard( Suit.HEARTS, Rank.FIVE,
- j blackjackj ui j bitmapsj h5" );
deck [4) = new Vcard( Sult.HEARTS. Rank . SIX,
- j blackjackj ui j bitmapsj h6" );
deek [5] new Veard( Suit.HEARTS . Rank.SEVEN,
H / bl aekjaekj ui / bi tmaps j h7" ) ;
deek [6] new Vcard( Suit.HEARTS, Rank.EIGHT.
"/b 1 aekj aekju 1 /bl tmaps/h8" ) ;
deck [7] new Veard( Sult . HEARTS. Rank.NINE,
"/ b 1 aekj aekju i /bi tmaps/h9" );
deek [8) new Vcard( Suit.HEARTS . Rank.TEN.
"/b 1 ae kj ae kju i /bltmaps/hIO" ) i
deek [9] new Veard( Suit.HEARTS, Ran k.JACK ,
"/b 1 ae kjae k/u i /bitmaps/h 11" ) i
deck [10] - new Veard( Suit.HEARTS. Rank.QUEEN,
H /blaekjaekjui/bi tmaps/hI2" );
deek [11) .. new Veard( Sult .HEARTS . Rank.KING.
"j bl aekjaek/ui j bitmaps/ h13" ) i
deek (12 ) .. new Veard( Suit . HEARTS, Rank.ACE,
- j blackjackj ui j bitmapsj hI " );
deek (13) new Veard( Suit.OIAMONDS, Rank. TWO,
"j blackjaekj ui j bitmapsj d2" )i
deek [14) .. new Veard( Suit.OIAMONOS . Rank.THREE .
- / b 1 aekjaekj ui / bi tmaps j d3" );
deek [15) .. new Veard( Suit.OIAMONDS, Rank.FOUR,
H j blaekjackj ui j bi tmaps j d4" ) i
deek [16) .. new Veard( Suit.OIAMONDS . Rank .FI VE ,
"/b 1 aekjaekjui /bitma psjd5" ) i
deek [17) new Veard( Suit . DIAMONDS , Rank.SIX,
"/b 1 aekj ae kju i /bi tmapsjd6" );
deek [18) .. new Vcard( Suit.DIAMONDS , Rank . SEVEN.
"/b 1 ae kj ae kj u i /b i tmaps/d7" );
deck [19] = new Veard( Suit.DIAMONDS , Rank . EIGHT,
"/blackjaek/ui/bitmaps/d8" ) i
deck [20] new Veard( Suit.DIAMONDS . Rank . NINE.
"/blaekjaekjui/bi tmaps/d9" );
deek [21) - new Vcard( Sult.DIAMONDS. Rank. TEN,
"j blaekjaek/ ui j bitmaps / dl0" ) i
deck (22] .. new Veard( Suit . OIAMONOS . Rank . JACK.
- j blackjackj ui j bitmapsj dll" );
deek (23) .. new Veard( Suit.OIAMONOS. Rank.QUEEN.
"j blackjackj ui j bitmapsj d1 2" );
deek (24) .. new Veard( Suit.OIAMONDS.Rank . KING,
.. / bl aekjaekj ui / bi tmaps j d13 " );
663
I 664 Apndice E
LI STAGEM E.40 VOeck.java (con tinuao)
deck [25] new Vcard( Suit.OIAMONOS. Rank.ACE.
-j blackjackj ul j bltmapsj dl " l;
deck [26] new Vcard( Suit.SPAOES. Rank.TWO.
"j blackjackj ui j bilmapsj s2" l;
deck (27) new Vcard( Suit.SPAOES. Rank . THREE.
"j blackjackjui j bitmapsjs3" );
deck (28) new Vcard( Suit . SPADES. Rank .FOUR,
/ blackjackjui/bi tmapsjs4" ) ;
deck [29] new VCard(Sui t.SPADES. Rank. FIVE.
"/b 1 ackj ackju i /bi tmaps/sS" l ;
deck [30] = new Vcard( Suit . SPADES. Rank . SIX.
"/b 1 ac kj ac k/ u i /bi tmaps/s6" );
deck [31] new Vcard( Suit.SPADES . Rank.SEVEN.
"/bl ackjackjui/bitmaps/s7" );
deck [32] new Vcard( Suit.SPADES . Rank.EIGHT.
"/b 1 ac kjac k/u i /bi tmaps/s8" );
deck [33] new Vcard( Suit.SPADES , Rank . NINE.
"jblackjack/ui/bitmaps/s9" );
deck [34] new Vcard( Suit.SPADES, Rank.TEN.
"j blackjack/ ui j bi tmaps/s IO" l;
deck (35] new Vcard( Suit.SPAOES, Rank .JACK,
-j blackjackj ul j bHmapsjsll" l;
deck [36] new Vca rd ( Suit.SPAOES. Rank.QUEEN.
"/ blackjackj ui j bitmapsj sI2" l;
deck [37] z new Vcard( Suit.SPADES. Rank . KING.
"j blackjackj ui j bitmapsj s13" ) ;
deck (38) new Vcard( Suit.SPADES. Rank .ACE .
"/blackjackjuijbi tmapsjsl" l;
deck [39) new Vcard( Suit.CLUBS. Rank. TWO.
"/b 1 ackj ac kju i / bi tmaps/c2" l ;
deck [40] new Vcard( Suit.CLUBS . Rank.THREE .
"/b 1 ac kj ac k/u i /bi tmaps/ c3" l;
deck [41] new Vcard( Suit.CLUBS , Rank.FOUR.
"/bl ackjackj ui / bitmaps/c4" l;
deck [42] new Vcard( Suit.CLUBS , Ran k.FI VE .
"/b 1 ac kjack/u i / bi tmaps/cS" ) ;
deck [43J new Vcard( Suit.CLUBS, Rank . SIX .
"j blackjackjui / bitmaps/c6" l;
deck [44] new Vcard( Suit . CLUBS , Rank.SEVEN.
"j blackjack/ui / bitmaps/c7" );
deck (45] = new Vcard( Suit.CLUBS. Rank . EIGHT.
-j blackjack/ ui / bi tmaps/ c8" ,;
deck [46) new Vcard( Suit.CLUBS. Rank.NINE,
"j blackjack/ ui j bitmaps/c9" l;
deck [47) new Vcard( Suit.CLUBS. Rank. TEN.
Li stagens do cdigo do jogo vinte-e-um
LI STAGEM E.40 VOeck.java (continuao)
-j blackjack/ ul j bitmapsj clO
N
);
deck (48] new Vcard( Suit.CLUBS, Rank.JACK,
Mj blackjackj ui j bitmapsj cll
N
);
deck [49] = new Vcard( Suit.CLUBS. Rank . QUEEN,
Nj blackjackj ui j bitmapsj cl2" ) ;
deck [50] new Vcard( Sult.CLUBS . Rank.KING,
"/blackjackjui j bitmapsj c13" );
deck [51J new Vcard( Suit.CLUBS, Rank.ACE.
"/blackjackjul/bitmaps/cl" );
I
I
LI STAGEM E.41 VHand.java
package blackjack.ui.pac;
import blackjack.core.*;
import java.awt.*;
import javax . swi ng.*;
i mpo rt java.uti 1. Iterator;
public cl ass VHand extends Hand implements Oisplayabl e I
private HandView view = new HandView();
public JComponent view() I
return view;
I
665
II voc precisa sobrepor addCard e reconfigurar para que quando a mo mudar. a
II altera!o se propague no modo de visualizao
public vold addCard( Card card ) {
I
super.addCa rd( card ) ;
view.changed() ;
publ ic void reset() {
super. reset O i
view. changedO i
I
private class HandView extends JPanel I
publ ic HandView() I
super e new Flowlayout( Fl owlayout . lEFT ) };
I 666 Apndi ce E
LISTAGEM E.41 VHand.java (continuao)
I
I
setBackground( new Color( 35 . 142, 35 ) );
I
pub1i c void changed() I
relllOveA 11 () ;
I
Iterator i getCards() ;
whi1e( i.hasNext() ) I
I
VCard card ( Vcard) i. next();
add( card.viewO ) ;
revalidate();
LISTAGEM E.42 VPl ayerFactory .java
package bl ackjack.ui.pac;
import b1ackjack.core.*;
public class VPlayerFactory I
private VBlackjackDeal er dea1er ;
private GUIPl ayer human;
private Deckpile pile;
publiC VBlackjackOealer getDealer() I
II cria e retorna apenas um
I
if( dealer nul l ) {
I
VHand dea l er_hand = getHand() ;
Oeckpile cards getCards ()j
dea1er new VBlackjackOealer( "Dealer ". dea l er_hand . cards )i
ret urn dealer ;
publ iC GUIP1ayer getHuman() {
II cria e retorna apenas um
if( human null ) I
I
VHand human_ha nd getHand();
Bank bank new Bank( 1000 ) ;
human new GUI Player( -Human". human_hand. bank. getOeal er() );
Li stagens do cdigo do jogo vinte-e-um
LISTAGEM E.42 VPlayerFactory.java (continuao)
}
return human :
}
publlC Oeckpile getCardsO I
}
II cria e retorna apenas um
if( pile nul1 ) I
}
pi le new Oeckpile();
for( int i O: i < 4 : i ++ ) {
pile.shuffleO:
}
Oeck deck new VOeck(lj
deck.addToStack( pile l;
pile.shuffleO j
return pile:
private VHand getHand() I
return new VHand():
}
667
ndice Remissivo
Smbolos
(asterisco), agr egnes de objeto, 186
A
Abstrao,26-27
exemplo de jogo de cartas, 56
exemplo de, 26-29
implementao eficiente de, 41 -47
regras para, 28-29
situaes apropriadas para, 29
Abst rao, a lternati vas, 93
Abstracl Datll Typc. Veja ADT
Acesso
privado, 25
protegido, 25
pblico, 25
nveis de, 25
Assessores, 11
classes, 575
ACM Speciallntcrcst Group 0 0 Compu-
ter- Huma" lnleraction (SIGCHI), 290
Ada ptador es, 242
de classe, 244-245
de objeto, 244-245
Agent es, objetos. 231
Agregaes, UML, 585
Ambient e
configurao, SDK, 555-556
variveis, PATH, 556
Anali sadores
documentos XML, padro de projeto
Abslracl Faclol)' e, 266
exemplo de cdigo, 266-267
An li se
recursos, 587
Veja tambm AOO
Anli se de caso de uso, 199
casos de uso resul tantes, 204-205
combinando casos de uso, ?03-204
definindo a seqUncia de eventos,
205-207
diagramas, 207
de atividade, 212
de colaboraO. 211
de interao, 209
de seqUncia, 210-211
dicas para escrever, 207
dividindo casos de uso, 203-204
entrada do usurio e, 200
identificando atores, 200-201
jogo de cartas vinte-c-um
aposta, 414-417
GUI, 433-435
regras, 384-388
listando casos de uso, 201-203
lgica booleana da, 476
Ancestrais, 88
Aninhando instrues ir/cise, 337
AOO (Anli se Ori entada a Obj eto)
modelo de caso de uso, 199
casos de uso resultantes, 204
combinando casos, 203-204
definindo seqUncia de event os,
205-207
diagramas de atividade, 212
diagramas de caso de uso, 207-208
diagramas de colaborao, 211
diagramas de interao, 209-210
diagramas de seqUncia, 210-211
dividindo a li sta de casos, 203
dividindo casos, 203
gerando lista preliminar, 20 1-203
identificando atores, 200-201
670 Aprenda Programao Orientada a Objetos em 21 Dias
modelo de domnio, diagramas de 3t ividade,
2 12
objelivo, 352
panorama, 197-198
protlipos,2 14
sistema, 198
APls (interraces de programa aplicativo), 24
Argumentos
converso, 137
ferramentas de terceiros, adaptadores,
244-245
Veja wmbm parmetros, 133- 134
Arquivo
Product.java, 573-574
SimpleHelloWorldjava,564
Arquivos, criando arquivos .jar, 562-563
Associaes (obj elos), UML, 584
Asteriscos (.), associaes de objeto, 185
Atividades, diagrama de estados. 390-391
Atores, 200
anlise de caso de uso, 352-353
jogo de canas vi Ole-c-um, 353
modelando, 207
Atributos, 8
especializao, 87-89
herana, 77-78
recursivos, 84-85
sobrepostos, 79-83
controle de acesso, 83
visibi lidade, UML, 581-582
Atuali ... ..ando
documentao, 339
interfaces, 35
projeto de UI desacoplada e, 290-291
bibliotecas de terceiros, padro de projeto
Abst racl FaCial)', 264
Autotransies, dia gr amas de estado,
390-391
B
Bibliotecas
ferramentas de tercei ros
adaptadores, 244-245
aruali zando, 264
Swill g, 293
Blackjack.cxc, intcrraces com O us urio,
621-627
Blackjack.java, 376-377
BlackjackDealer.j ava, 374-375
c
C++, recursos, 588
Cabealhos (mtodos e classes), dOCulllcntll-
o, 338-339
Camada controladora (MVC), 301
combinando com camada de modelo,
302-303
implementando, 301-302
Camada de modelo (MVC), 294
implementando, 295-296
reunindo com camada de control e,
302-303
Camada de modo de vis ua lizai\o (MVC),
297
Capacidade de conexi\o, 91-92
implementando, 297-300
Cartes CRC (Class Rcs pons ibility Collabo-
rati on),224-225
aplicando, 225-226
exemplo, 226-229
GUls, jogo de cartas vinte-e-um, 437
limitaes, 230-23 1
Casos de teste, 316
nomeando, 322
teste de caixa branca, 316
teste de caixa preta, 316
Casos de uso
aposta, 414-416
atares, 352
jogo de cartas vinle-e-um, 353,
356-360
Banca efellla jogo, 387-388
Deal Cards, 384-387
Indice Remissivo
671 I
Cenri os (anli se de easo de uso), 205
Chamadas de mtodo, 8
Chaves ({ }) no cdigo-fonte, 564
Chaves, especificando, 51
Classe Bank Gogo de cartas vinte-e-um)
exemplo de cdigo, 159
implementao, 421 4 22
projetando, 417
Classe
BettingPlayer, implementao, 423-424
BlackjackOealer. implementao, 426-427
BlackjackGUI, mtodo setUpO, 448-449
CardView, implement ando, 443
CountedObjecl, exemplo de cdigo, 65
Oealer
DoubleKey
construtores, 52
exemplo de cdigo, 50-5 1
exemplo de cdigo, 61
FlipPlayer, implementando, 475-476
GUIPlayer, implementando, 445-448, 465
Hand, receptor para, 395-399
HumanPlayer, implementao, 424-426
OneHit l)layer. implementando. 476
Opti onView, implementando, 445
Opt ionViewCont roller, implementando, 445
Pl ayer
herana, refazendo a hierarquia, 419-420
interface PlayerListener, 403-404
interface Pl ayerState, 399-403
Pl ayerView, implementando, 444-445
progenitora, 77-79
exemplo de cdigo de herana, 99-100
palavra-chave super, 84
SafePlayer
adicionando na GUI, 472-473
criando, 471-472
Smart Player, implementando, 477
Stack, herana
exemplo de cdigo da soluo, 118- 119
exemplo de problenta, 11 7- 118
exposio do problema, 118
State, jogo de cartas vinte-e-um, 393
VBettingPlayer, implementando, 462-463
VBlackjackDealer, implementando,
464-465
VCard, implementando, 44 1-442, 460-46 1
VDeck, implementando, 442
VHand, implementando, 461-462
Classes abstratas
exemplo de cdigo, 102-103, 126-128
mtodos, definindo, 104
requisitos do exemplo, 105
UML,582
notao, 182
Classes anllimas, criando, 324
Classes filhas, 77-78
especiali zao, 87-88
exemplo de cdigo de herana, 100-10 I
novos mtodos, 84
palavra-chave super, 84
polimorfismo, exemplo de cdigo, 147-148
requisi tos do exemplo, 99-101
Classes fo lha, 89
Classes internas, 577-579
annimas, 577-579
Classes-raiz, 89
annimas, 577-579
Classes, 8
abstratas
exemplo de cdigo, 102- 103
notao UML, 181 - 182
requisitos do exemplo, 105- 106
AOT (Abstract Data Type), TAO, imple-
mentao eficiente de, 47
agregaes, UM L, 585
ancestral , 88
annimas, 577-579
criando, 324-325
assessores, 575
associaes de objelo, UML, 584
atributos, 8
Bank, 416-4 17
implementao, 42 1
BaseLog, exemplo de cdigo, 127-128
BettingPlayer, implementao, 423-424
672 Aprenda Programao Orientada a Objetos em 21 Dias
Blackjack
diagrama de at uali z.1llo, 420-42 1
mtodo setUp( ), 448-449
BlackjackDealer, implementao, 426-427
cabealhos, documentao e, 338-339
CardView, implcmcnlando, 443
cartes CRC (Class Responsibility Coll abo-
ration), 224-225
aplicando, 225-226
exemplo, 226-227
limitaes, 230-23 [
compil ando, 561-562
composii'lo, 76
UML,585
comuns
pacote blackjack.core, 592-619, 618-619
consideraes de projeto, lestes de unidade
e,321 -322
convenes de atribuio de nomes, 338
CountedObject, exemplo de cdigo, 65
criando, estado de jogo e, 393, 395
Dealer, implementao, 424-425
diagramas
de colaborao, UML, 586
de seqUncia, UML, 586
DoubleKey, construtores, 52
exemplo de cdigo, 9- 10
Bank, 159-1 60
BankAccount, 111-1 12
CheckingAccount, 114- 11 5
OverdraftAccount, 116
Savi ngsAccount, 112-113
TimeMaturi tyAccount, I 13-114
exemplo de cOnla
cdigo para, 55
requi sitos, 5343
exemplo de jogo de cartas, cdigo para,
57-62
exemplos de cdigo, DoubleKey.java, 50
filhas, 77
especiali zao, 87
exemplo de cdigo de herana, 100-101
novos mtodos, 84
palavra-chave super, 84
poli morfismo (exemplo de cdigo),
147- 148
requisitos do exemplo, 100
Fli pPlayer, implementando, 475
folha, 89
GUIPlayer, implementando, 445-448, 465
Hand, receptor para, 395-398
Hashtablc, canvcrsllo c, 157
herana, principias bsicos, 77-78
hierarquia de herana, 77
HumanPlayer, implementao, 424-425
instanciao, evitando mlt ipla, 268
internas, 577-579
Java, 564-565, 57 1-572
criando, 572-573
jogo de cartas vinte-c-um, 360-364
criando jogadores no-humanos,
471-472
implementao, 365-380
modelo, 365
mtodos
construtores, 574-575
de configurao, 575
de obteno, 575
modelando, 188
documentando cdigo, 179
notao de seleo UML, 181
notao UML avanada, 181
notao UML, 179-1 80
re lacionamentos de agregao, 186-187
relacionamentos de associao, 184-1 85
relacionamentos de composio, 187-188
relacionamentos de dependncia, 183- 1 84
relacionamentos de generalizao, 188-189
relacionamentos, 183
modificadores, 575
mult ipli cidade, UML, 584-585
numero de responsabilidades (problemas
de projeto), 229-230
objctos, 7-8
OneHitPlayer, implementando, 476
OptionView, implementando, 445