UNVERSDADE FEDERAL DE SANTA CATARNA

Relatrio 1: Metodologia para Ensino de

Programao Orientada a Objetos com
Jogos 2D
Kalu Caminha
Florianpolis, 2 semestre de 2012
UNVERSDADE FEDERAL DE SANTA CATARNA
DEPARTAMENTO DE NFORMTCA E ESTATSTCA
CURSO DE SSTEMAS DE NFORMAO
Relatrio 1: Metodologia para Ensino de
Programao Orientada a Objetos com
Jogos 2D
Kalu Caminha
Trabalho de Concluso de Curso
apresentado como requisito parcial para a
obteno de grau de Bacharel em
Sistemas de nformao.
Florianpolis, 2 semestre de 2012
Kalu Caminha
Relatrio 1: Metodologia para Ensino de
Programao Orientada a Objetos com
Jogos 2D
Trabalho de Concluso de Curso apresentado
como requisito parcial para a obteno de grau
de Bacharel em Sistemas de nformao.
Orientador
Professor Doutor Ricardo Pereira e Silva
Banca Examinadora
Leandro Jos Komosinski
Patrcia Vilain
Para os avaliadores deste relatrio 1
Percebi ao finalizar este primeiro relatrio o grande nmero de pginas.
Acredito qe isto se deve ao alto nmero de ilstra!"es e listas
tilizados e tamb#m a m detal$amento %talvez desnecessrio de
lagns cap&tlos'.
(em dvida visalizo qe isso precisar ser corrigido para a vers)o
final de modo qe o trabal$o n)o fiqe por demais extenso* solicito
a+da para como tratar esta qest)o. ,ito Obrigado
(mrio
Lista de Redues.............................................................................................................................10
Resumo...............................................................................................................................................11
1 Introduo......................................................................................................................................12
1.1 Justificativa..............................................................................................................................13
1.2 Objetivo Geral..........................................................................................................................15
1.3 Objetivos Especficos..............................................................................................................15
1.4 Metodoloia de !es"uisa.........................................................................................................15
2 Fundamentao Terica................................................................................................................17
2.1 !rorama#$o Orie%tada a Objetos...........................................................................................1&
2.1.1 'o%ceitos !OO ...............................................................................................................1(
2.1.2 Estruturas )*sicas de !rorama#$o em Java...................................................................1(
2.2 Joos 2+..................................................................................................................................1,
2.2.1 +ese%-o de imae%s........................................................................................................2.
2.2.2 /%ima#0es........................................................................................................................2.
2.2.3 1iles e 'omposi#$o de 'e%*rios......................................................................................2.
2.2.4 !o%tos 2 !la%o 'artesia%o................................................................................................21
2.2.5 3prites...............................................................................................................................21
2.2.4 +ispositivos de E%trada ..................................................................................................21
2.2.& E5ecu#$o de so%s.............................................................................................................21
2.2.( 1a5a de 6uadros e atuali7a#$o do joo............................................................................22
2.2., /cumuladores de 1empo..................................................................................................22
2.2.1. Gravidade.......................................................................................................................22
2.2.11 +etec#$o e 1ratame%to de 'olis0es...............................................................................22
2.2.12 O Game 8oop.................................................................................................................23
2.2.13 Movime%ta#$o e Gravidade %os ce%*rios......................................................................23
2.3 9rame:or;s Orie%tado a Objetos............................................................................................23
2.3.1 9rame:or;s OO...............................................................................................................23
2.3.2 Metodoloias de +ese%volvime%to de 9rame:or;s OO.................................................24
2.3.3 <so de 9rame:or:or;s OO............................................................................................24
2.4 !adr0es !eda=icos................................................................................................................25
2.4.1 O Mais >mporta%te !rimeiro ?Earl@ )irdA........................................................................25
2.4.2 Espiral ?3piralA.................................................................................................................24
2.4.3 Met*fora 'o%siste%te ?'o%siste%t Matap-orA..................................................................24
2.4.4 'ai5a de )ri%"uedos ?1o@ )o5A.......................................................................................24
2.4.5 'ai5a de 9errame%tas ?1ool )o5A....................................................................................2&
2.4.4 +isposi#$o do territ=rio ?8a@ of t-e 8a%dA......................................................................2&
2.4.& 'orriir para cima ?9i5er <pperA.....................................................................................2(
2.4.( Maior "ue a Bida ?8arer t-a% 8ifeA................................................................................2(
2.4., 3pri%t de !rojeto dos Estuda%tes ?3tude%t +esi% 3pri%tA...............................................2(
2.4.1. E%a%o ?Mista;eA...........................................................................................................2(
2.4.11 'a%al de 1este ?1est 1ubeA.............................................................................................2,
2.4.12 !ree%c-a as 8acu%as ?9ill i% t-e )la%;sA.......................................................................2,
2.4.13 Estrela de Ouro ?Gold 3tarA...........................................................................................2,
2.4.14 /valie isto %ovame%te 3am ?Grade it aai% 3amA..........................................................2,
3 Experincia pr!"ia com ensino de #$$ e %o&os.........................................................................31
3.1 'o%teCdos trabal-ados.............................................................................................................31
3.2 Metodoloia.............................................................................................................................33
3.2.1 E5emplo 1 D Movime%ta%do uma bola............................................................................34
3.2.2 E5emplo 2 D 'o%strui%do o primeiro joo.......................................................................35
3.2.3 E5emplo 3 D Ete%s e fases.................................................................................................35
3.2.4 E5emplo 4 D Guerra Especial...........................................................................................34
3.2.5 D !erso%ae%s e 'e%*rios.................................................................................................3&
3.2.4 D Joo de 8uta..................................................................................................................3(
3.2.& D Fevis$o..........................................................................................................................3(
3.3 /valia#$o e Fesultados............................................................................................................3,
3.3.1 /valia#$o 1e=rica.............................................................................................................3,
3.3.2 /valia#$o da Motiva#$o...................................................................................................4.
3.3.3 /valia#$o !r*tica..............................................................................................................4.
3.3.3.1 Grupo 1 D !o:erMusic.............................................................................................4.
3.3.3.2 Grupo 2 D '-ampio%s 9i-ter..................................................................................41
3.3.3.3 Grupo 3 D G-omai%e................................................................................................41
3.3.3.4 Grupo 4 D >ce 'ro:% 'itadel...................................................................................41
3.3.3.5 Grupo 5 D Moluscatio%.............................................................................................41
3.3.3.4 Grupo 4 D 1errorist 3trate@.....................................................................................41
3.3.3.& Grupo & D God of Gorms.........................................................................................41
3.3.3.( Grupo ( D 3ami Game..............................................................................................41
3.3.4 Fesultado avalia#$o pr*tica..............................................................................................41
3.3.4 'o%clus$o ao fi%al do m=dulo.........................................................................................42
' Ensino de #ro&ramao $rientada a $()etos............................................................................'3
4.1 Metodoloias para E%si%o OO.................................................................................................43
4.1.1 >saias 'amilo )oratti........................................................................................................44
4.1.1.1 /%*lise Geral do MHtodo..........................................................................................44
4.1.1.2 !o%tos 9ortes ...........................................................................................................4&
4.1.1.3 !o%tos 9racos...........................................................................................................5.
4.1.1.4 'o%clus$o.................................................................................................................53
4.1.2 +avid J. )ar%es e Mic-ael IJlli%..................................................................................53
4.1.2.1 +iretri7es .................................................................................................................54
4.1.2.2 /%*lise eral do mHtodo...........................................................................................5(
4.1.2.3 !o%tos fracos............................................................................................................5,
4.1.2.4 'o%clus$o.................................................................................................................4.
4.1.3 )ru%o 9eij= et al...............................................................................................................4.
4.1.3.1 /%*lise eral do mHtodo...........................................................................................42
4.1.4 3telios Ki%oalos.............................................................................................................42
4.1.4.1 O <so de ambie%tes de prorama#$o.......................................................................43
4.1.4.2 +iretri7es para o E%si%o das li#0es propostas..........................................................44
4.1.4.3 /%*lise Geral do mHtodo..........................................................................................&.
4.1.5 Mic-ael 'asperse%...........................................................................................................&1
4.1.5.1 /s etapas da metodoloias.......................................................................................&2
4.1.5.2 O 9rame:or; co%ceitual..........................................................................................&3
4.1.5.3 O i%cio.....................................................................................................................&3
4.1.5.4 !adr0es de '=dio....................................................................................................&3
4.1.5.5 Outros eleme%tos da metodoloia............................................................................&4
4.1.5.4 /%*lise Geral da Metodoloia..................................................................................&4
4.3 +iretri7es para o E%si%o de OO .............................................................................................&4
4.3.1 !ri%cpios baseados %a pr*tica com o )lueJ....................................................................&4
4.3.2 Feprese%ta#0es visuais para todas as estruturas e co%ceitos trabal-ados........................&5
4.3.3 Opera#0es de abstra#$o e frame:or; co%ceitual.............................................................&5
4.3.4 /mbie%te educacio%al L /mbie%te profissio%al..............................................................&5
4.3.5 !rocesso sistem*tico de dese%volvime%to.......................................................................&5
4.3.4 / partir do 7ero.................................................................................................................&4
4.3.& 1odos os recursos usados devem ser e5plicados..............................................................&4
4.3.( Estilo de '=dioMfo%te.....................................................................................................&4
4.3., 8ista abra%e%te de e5erccios e desafios........................................................................&4
4.3.1. 1odos os e5emplos devem e%volver joos.....................................................................&4
* Frame+or, %a"a para %o&os 2-..................................................................................................77
5.1 /"uisi#$o do 'o%-ecime%to de +om%io................................................................................&&
5.2 Modelaem do 9rame:or;N.....................................................................................................&&
5.2.1 Ge%erali7a#$o...................................................................................................................&&
5.2.2 9le5ibili7a#$o...................................................................................................................&(
5.2.3 Modelaem das 'lasses...................................................................................................&,
5.3Balida#$o...................................................................................................................................&,
5.4 +ocume%ta#$o.........................................................................................................................&,
. /etodo0o&ia de Ensino..................................................................................................................10
4.1 M=dulo 1N Objetos !rimeiro....................................................................................................(.
4.2 M=dulo 2N Mi%iMGame.............................................................................................................(1
4.3 M=dulo 3N Joo 2+..................................................................................................................(1
4.4 /valia#$o da Metodoloia........................................................................................................(1
7 2onc0uso.......................................................................................................................................12
&.1 1rabal-os 9uturos....................................................................................................................(2
1 3i(0io&ra4ia.....................................................................................................................................13
(.1 8ivros.......................................................................................................................................(3
(.2 /rtios e +ocume%tos acadOmicos..........................................................................................(3
(.3 )ibliorafia para c=dioMfo%te e materiais did*ticos dese%volvidos pelo autor......................(4
(.4 )ibliorafia 'o%sultada...........................................................................................................(5
-ndice de ilstra!"es
>lustra#$o 1N 'e%*rio baseado em 1iles..............................................................................................2.
>lustra#$o 2N E5emplo de uma 3prite..................................................................................................21
>lustra#$o 3N Movime%ta%do uma bola %a tela....................................................................................34
>lustra#$o 4N E5emplo mais comple5o utili7a%do a bola criada a%teriorme%te..................................34
>lustra#$o 5N 1ela fi%al do joo dese%volvido com o au5lio do roteiro.............................................35
>lustra#$o 4N 1erceira fase do e5emplo com diversos ite%s %a tela.....................................................34
>lustra#$o &N Bers$o fi%al do joo Guerra Espacial............................................................................3&
>lustra#$o (N !erso%aem salta%do sobre um i%imio represe%tado por uma bola vermel-a.............3(
>lustra#$o ,N E5emplo joo de luta.....................................................................................................3(
>lustra#$o 1.N / 'o%stru#$o do modelo. 9o%teN )oratti.....................................................................4(
>lustra#$o 11N Feprese%ta#$o Bisual de Objetos. 9o%teN )oratti. /daptado por IalHu 'ami%-a.......4,
>lustra#$o 12N >mpleme%ta#$o de Objetos. 9o%teN )oratti. /daptado por IalHu 'ami%-a................5.
>lustra#$o 13N Feprese%ta#$o Bisual de um /rra@. 9o%teN )oratti. adaptado por IalHu 'ami%-a.....5.
>lustra#$o 14N >%sta%cia#$o de objeto e c-amada de mHtodo em c=dio............................................5,
>lustra#$o 15N Objetos %a ba%cada de objetos ?em vermel-oA e c-amada de mHtodo de um objeto. .5,
>lustra#$o 14N >%sta%cia#$o de um objeto %o objectIarel com a ajuda da i%terface r*fica...............45
>lustra#$o 1&N 'ria#$o de uma tarefa a partir dos mHtodos de um robP.............................................44
>lustra#$o 1(N E5ecu#$o de um prorama. Q direita a visuali7a#$o do robPR Q es"uerda a lista de
tarefas e abai5o a descri#$o do "ue ocorre %o i%terior do mHtodo em e5ecu#$o................................44
>lustra#$o 1,N 'ria#$o sistem*tica de um prorama orie%tado a objetos...........................................&2
-ndice de tabelas
1abela 1N 'o%ceitos !OO...................................................................................................................1(
1abela 2N +ocume%ta#$o de frame:or;s............................................................................................25
1abela 3N 1abela demo%stra%do os co%teCdos trabal-ados %a e5periO%cia prHvia com e%si%o de
orie%ta#$o a objetos baseado em joos...............................................................................................32
1abela 4N E%dice de acerto em cada um dos critHrios de avalia#$o do joo 2+..................................42
1abela 5N 'o%teCdos e E5emplos da metodoloia de )oratti.............................................................44
1abela 4N 'o%teCdos e e5emplos da metodoloia de )ar%es..............................................................54
1abela &N 'o%teCdos e e5mplos da metodoloia de 9eij=..................................................................42
1abela (N 'o%teCdos e ambie%te de prorama#$o %a metodoloia de Ki%oalos..............................44
.ista de /ed!"es
#$$ !rorama#$o Orie%tada a Objetos
$$ Orie%ta#$o a Objetos
2- +uas dime%s0es
/esmo
O presente trabalho busca o desenvolvimento de uma metodologia de ensino de
Programao Orientada a Objetos tendo como campo de prtica os jogos em duas
dimenses. So descritas as ferramentas, o roteiro de aulas com sua respectiva carga
horria, avaliaes e exerccios a serem utilizados na metodologia apresentada, bem
como um framework Java que abstrai os principais recursos especficos da plataforma e
algoritmos avanados, importantes para o desenvolvimento de jogos.
1 0ntrod!)o
Por volta de abril de 2011 o autor deste trabalho viveu a experincia de ensinar
Programao Orientao a Objetos para alunos entre 15 e 17 anos no curso tcnico de
programao no SENA de So Jos, em Santa Catarina.
Dentre muitas dificuldades, as que mais se destacaram eram a evidente
desmotivao dos alunos com o tema de programao, a dificuldade com a sintaxe e
recursos especficos do Java e a ausncia de mtodo para transformao de um
problema em um conjunto de classes que representariam sua respectiva soluo.
A partir desta constatao, iniciou-se na turma do semestre seguinte uma busca por
solues para estes problemas que culminou em duas grandes mudanas, a primeira foi a
adoo da metodologia de ensino criada por David J. Barnes e Michael Klling utilizando
o BlueJ como ambiente de programao e no semestre seguinte, com a mesma turma,
iniciou-se um trabalho de desenvolvimento de jogos em Java a partir dos materiais
desenvolvidos por Bruno Feij e Esteban Clua.
Ficou evidente aps a aplicao destas prticas que a motivao dos estudantes
aumentou e os problemas com certas sintaxes e recursos do Java tambm diminuram.
Entretanto, na anlise dos trabalhos finais de desenvolvimento de jogos, ficou evidente
que para metade da turma, ainda havia um grande abismo entre o que sabiam e o
domnio prtico dos principais conceitos de Programao Orientada a Objetos.
Acredita-se que a inexperincia e a falta de mtodo do autor que acarretaram nas
dificuldades percebidas nos alunos ao final do processo de ensino aprendizagem.
E este o ponto de partida para este trabalho, a busca por mtodos, prticas,
conceitos e ferramentas que auxiliem alunos principalmente os que possuem maiores
dificuldades com programao a modelarem e desenvolverem softwares que
solucionem problemas com os quais eles prprios venham a se deparar no seu dia-a-dia,
deste modo, que se aprenda no apenas a desenvolver cdigos orientado a objetos, mas
principalmente, conseguir "enxergar os objetos, como bem colocado pelo professor
Ricardo Pereira e Silva na primeira reunio de orientao.
1.1 Justificativa
Na Orientao a Objetos, as metodologias e ferramentas de ensino no so to
maduras quanto nos paradigmas mais antigos como a programao estruturada e
funcional (Xinogalos), de forma que muitos professores de cincia da computao
(Xinogalos, Proulx, Caspersen, Bennedsen, Rosenberg, Klling, Barnes, Boratti) que se
depararam diante da tarefa de ensinar orientao a objetos, iniciaram uma srie de
pesquisas em busca de diretrizes, ferramentas e metodologias que norteasse essa
importante tarefa.
O autor considera, pela experincia com ensino que a grande maioria dos
exemplos didticos em Java, mesmo em algumas metodologias recentes, trabalha com
softwares muito simples para serem interessantes ou fora da rea de interesse e
conhecimento da maioria dos jovens estudantes de programao.
Um exemplo o primeiro projeto apresentado no livro texto do ambiente BlueJ,
uma mquina de vender bilhetes de trem, algo completamente fora da realidade brasileira,
porm, mesmo que adaptssemos o projeto para, por exemplo, uma mquina de vender
caf, ainda teramos a distncia do aluno entre simular uma mquina de vender caf e
programar uma mquina de vender caf da vida real.
Esta a vantagem da rea de jogos, possvel que o estudante crie algo com o
qual ele efetivamente poder se divertir e alm disso, a maioria dos jovens com os quais
trabalhei, aos 15 e 16 anos, j possuem um grande nmero de horas de experincia com
jogos, permitindo que eles tragam um conhecimento prvio para a atividade de
programao, facilitando a fixao dos conceitos com situaes problema com as quais
eles j esto familiarizados.
Alm desta perspectiva, o uso de jogos para o ensino de programao um
recurso j utilizado por muitos instrutores na comunidade de educadores de cincia da
computao, no s pela sua capacidade de estimular os alunos, mas tambm por ser um
tipo de aplicao para o qual convergem os maiores desafios da computao (Feij)
independente do paradigma de programao utilizado.
Porm, livros com contedos nesta rea geralmente so complexos, utilizando
recursos das linguagens de programao que envolvem um grande nmero de conceitos
e regras de sintaxe, o que dificulta sua aplicao didtica em sala de aula. Por exemplo,
para que seja possvel desenhar uma imagem na tela (recurso essencial no
desenvolvimento de jogos) em Java preciso conhecer conceitos complexos como
herana e sobrecarga de mtodos.
A partir disto, percebe-se que o suporte ao desenvolvimento de jogos em fases
iniciais do ensino de programao exige o auxilio de ferramentas que tornem mais fcil o
desenvolvimento de recursos como uso de sons, imagens e cenrios.
Duas solues atuais foram encontradas, a primeira, um ambiente de programao
denominado Greenfoot (Klling, 2010) desenvolvido para permitir o ensino de
programao com interao e visualizao, permitindo uma incluso rpida e fcil de
imagens, sons e posicionamento de elementos em um cenrio. A segunda, o conjunto
de bibliotecas denominado JavaLib (Proulx, 2010), cujo objetivo permitir que o
estudante mantenha o foco no projeto do jogo, no seu comportamento e na representao
de cada cena atravs de formas geomtricas simples. Mais recentemente a biblioteca foi
ampliada para permitir o ensino de OO atravs da arte de escrever e tocar msicas com
abstraes de notas e arranjos musicais.
Para este projeto, foi escolhida uma abordagem prxima a de Proulx pois como
relata Xinogalos - que utilizou e ainda utiliza o ambiente BlueJ parcialmente em sua
metodologia - importante preparar os estudantes para serem profissionais usando
ferramentas profissionais de desenvolvimento, manter o aluno por muito tempo em
ambientes especificamente voltados para o ensino pode torn-lo por demais acostumado
aos recursos didticos e limitadores destes ambientes, no desenvolvendo plenamente as
habilidades de programao e abstrao, necessrias a um profissional.
Outro fator favorvel ao uso de bibliotecas e frameworks no ensino deriva do fato
de ser muito comum no desenvolvimento de software o aprendizado de novas bibliotecas
e frameworks. Sendo necessrio ao profissional de programao o domnio das
habilidades de compreenso da documentao e utilizao de tais bibliotecas e
frameworks.
Observa-se tambm que alguns conceitos como Interfaces e classes abstratas tem
sua aplicao observada mais frequentemente em frameworks, sendo a extenso de um
framework uma possvel forma de estudo de tais conceitos.
Deste modo, considera-se essencial para este trabalho o desenvolvimento de um
framework cuja responsabilidade abstrair as funes bsicas necessrias para jogos 2D
como construo de cenrios, execuo de sons, animaes, desenho de imagens e
demais necessidades dos jogos 2D de modo que o aluno possa se concentrar, no projeto
e construo das classes e de suas interaes.
A proposta da metodologia deve conter elementos de plano de aula, carga horria,
atividades prticas e avaliaes de modo que possa ser reproduzida em cursos
introdutrios de Programao Orientada a Objetos com durao de 72 horas/aula.
Tambm sugerida uma atividade prtica de longa durao a ser desenvolvida em
laboratrio com o auxlio do professor para cursos com uma carga horria mais extensa.
Por fim, justifica-se a escolha da linguagem Java em unssono com Feij que
caracteriza cinco vantagens para esta linguagem: 1) Permite aplicaes em um grande
nmero de plataformas; 2) Roda em mais de um Sistema Operacional e conta com um
bom ambiente de programao gratuito (NetBeans); 3) O Java uma linguagem
Orientada a Objetos; 4) Java um ponto de partida para a programao para internet; e
5) A prxima gerao de linguagens orientadas a objetos ser uma evoluo natural do
Java.
1.2 Objetivo Geral
Criar uma metodologia de ensino de Orientao a Objetos atravs do
desenvolvimento de jogos 2D.
1.3 Objetivos Especficos
Documentar a experincia do autor com ensino de orientao a objetos baseada
em jogos anterior a este estudo;
Apresentar e analisar algumas das principais metodologias de ensino de
programao orientada a objetos ressaltando seus pontos fortes e fracos segundo
a experincia do autor;
Definir diretrizes para o desenvolvimento da metodologia a partir das metodologias
estudadas e da experincia anterior do autor;
Elencar elementos pedaggicos que auxiliem a construo da metodologia;
Construir um framework Orientado a Objetos que atenda as principais
caractersticas de jogos 2D e esteja de acordo com as diretrizes definidas;
Documentar uma metodologia que atenda a um curso introdutrio de programao
orientada a objetos de 72 horas aula;
Definir uma atividade de longa durao a ser desenvolvida pelos estudantes em
perodo de aula para disciplinas cujo ano letivo seja superior 72 horas/aula;
1.4 Metodologia de Pesquisa
nicia-se com a fundamentao terica de alguns elementos considerados
essenciais ao trabalho como programao orientada a objetos, jogos em duas dimenses,
frameworks orientados a objeto e elementos pedaggicos para a cincia da computao.
Aps, considera-se essencial a documentao da metodologia utilizada para o
ensino de orientao a objetos baseados em jogos 2D na experincia que deu origem ao
tema do presente trabalho, de modo que as dificuldades e pontos fortes do ensino anterior
fortalea a nova metodologia que ser desenvolvida.
Aps, ser realizada uma pesquisa nas metodologias para ensino de orientao a
objetos, sendo escolhidas para detalhamento as consideradas pelo autor como mais
relevantes ao desenvolvimento deste trabalho. A partir deste detalhamento sero
definidas diretrizes para o ensino de OO que devero ser contempladas nesta
metodologia.
Com as diretrizes definidas, bem como os elementos de jogos em duas dimenses,
ser proposto um framework que atenda a estes elementos.
Em seguida, proposta a metodologia de ensino utilizando os elementos
apresentados nos captulos anteriores. Neste ponto, o framework poder ser revisto
diversas vezes at atingir uma verso final que suporte as diretrizes propostas.
1 2ndamenta!)o 3erica
Este captulo apresenta alguns elementos bsicos ao trabalho sem, entretanto,
apresentar um estrutura lgica sequencial entre estes elementos, de modo que servem
como base para os demais captulos e discusses.
2.1 Prograa!"o Orie#tada a Objetos
Biologia e matemtica. Esta era a formao base de Alan Kay quando ele criou a
Smalltalk, reconhecida como a primeira linguagem totalmente orientada a objetos, no
famoso laboratrio da Xerox PARC em Palo Alto, no final dos anos 60.
Observamos a influncia desta formao em dois dos princpios iniciais que
nortearam sua pesquisa, o primeiro era que ele inicialmente pensava em objetos como
clulas biolgicas e/ou computadores individuais em uma rede, apenas habilitados a se
comunicarem atravs de mensagens.. O segundo, que pode ter sido uma das origens s
modernas classes, derivado de sua raiz matemtica, que lhe fez perceber que cada
obeto poderia ter certas !lgebras relacionadas a ele, e "ue poderiam haver fam#lias
destas !lgebras, o "ue seria muito $til.
Alm disso, foi fortemente influenciado pela Sketchpad, Simula, Lisp, o projeto da
ARPAnet e a (segundo ele), quase inacreditvel arquitetura dos discos rgidos B500 da
Burroughs.
Estes princpios so compatveis com Boratti que coloca sobre o paradigma de
Programao Orientada a Objetos:
Esse paradigma procura abordar a resoluo de um problema atravs de uma
construo que represente, da melhor forma possvel, como as coisas acontecem no
mundo real.
O mundo real constitudo por entidades que interagem entre si. Uma entidade pode
ser definida como alguma coisa que tenha sua prpria e!ist"ncia, caractersticas e que
apresente alguma funo no mundo real...uma entidade pode ser denominada ob#eto e,
consequentemente a identificao do paradigma de programao orientada a ob#etos$.
Portanto Programao Orientada a Objetos corresponde um modo de programar no
qual so construdos objetos (entidades, clulas), pertencentes classes, que interagem
entre si (atravs de mensagens) e possuem caractersticas prprias.
1.1.1 4onceitos POO
Os conceitos relacionados POO que sero abordados pela metodologia foram
selecionados principalmente a partir da metodologia de Barnes. Para uma melhor
organizao, estes foram organizados em dois nveis de dificuldade segundo a
experincia do autor:
5&vel Bsico 5&vel Avan!ado
Classe;
Mtodos de acesso e mtodos
modificadores;
Variveis e Tipos;
Notao de ponto;
Varivel de nstncia / atributo;
Objetos / nstncias / instanciao de
objetos;
Parmetros;
Construtores;
Abstrao;
Encapsulamento / Modificadores de
acesso;
Associao / Composio;
Listas / terao;
Herana / Especializao /
Generalizao;
Classes abstratas;
nterfaces;
Polimorfismo: Variveis polimrficas /
Polimorfismo de mtodo;
Sobrescrita de mtodo;
Modificador static: contantes de classe /
mtodos estticos;
Tratamento de Erros / Try... Catch;
Design de responsabilidade, Princpio
da Responsabilidade nica;
Coeso, acoplamento e refatorao;
%abela &' (onceitos )OO
1.1.1 Estrtras Bsicas de Programa!)o em 6ava
De modo a permitir o uso desta metodologia em cursos introdutrios de
programao se faz fundamental o ensino de conceitos de determinadas estruturas
bsicas de controle e de repetio. as estruturas e conceitos bsicos que sero
abordadas na metodologia sero:
Estruturas condicionais (if, else e else if);
Estruturas de repetio (while, for);
Arrays / Matrizes unidimensionais e bimensionais;
nstruo de atribuio (%, &%, '%, etc);
Variveis Locais;
Comentrios;
Enum;
2.2 Jogos 2$
Esta seo apresenta os principais conceitos utilizados na arquitetura de jogos em
duas dimenses a partir do material desenvolvido por Perucia e que acompanha um
framework desenvolvido na linguagem de programao C++ para o desenvolvimento
destes jogos. Um jogo desenvolvido com este framework, pode apresentar, dentre outros
recursos:
Menu principal e de opes;
Personagem animado controlvel por teclado;
Cenrios com profundidade;
tens especiais de jogo;
nterao do personagem com cenrio e itens;
nimigos e interao do personagem com estes inimigos;
Controle de pontos de vida do personagem;
Execuo de sons;
A arquitetura de um jogo pode envolver diversos subsistemas, um jogo 2D sempre
apresentar pelo menos alguns dos subsistemas abaixo:
nterface grfica (menus, botes, controle, etc);
Tratador de eventos de teclado e/ou joystick;
Gerenciador de dados (fases, grficos, etc);
Gerenciador de fsica (velocidade, movimento, coliso, etc);
(ngine grfica (exibio de imagens, rotao, efeitos especiais, etc);
Engine sonora;
Engine lgica (o corao do jogo);
Camadas de abstrao de hardware;
Sistema de configurao do jogo (opes, nvel de dificuldade, salvamento, etc);
Sistema de menus;
Sistema de ajuda;
Sistema de msica;
A partir de )erucia et al, dos exemplos tratados por Feij e da experincia pessoal do
autor foram selecionados os principais conceitos envolvendo a arquitetura de jogos e que
sero indispensavelmente cobertos pelo framework que oferecer suporte a metodologia
1.1.1 7esen$o de imagens
O desenho de imagens na tela a partir de determinados arquivos-fonte uma
operao frequente e pode ser complementada com recursos desejveis como
transparncia, rotao, aumento ou reduo do tamanho original e espelhamento que
corresponde ao desenho da mesma imagem s que em posio invertida ou espelhada.
1.1.1 Anima!"es
Animaes so sequncias de imagens que se alternam em funo de um
determinado tempo. Em um jogo, importante que seja possvel aumentar e diminuir a
velocidade de uma animao (em casos por exemplo, da movimentao de um
personagem mais rpido ou devagar) e que assim como nas imagens, seja possvel
aplicar efeitos de transparncia, rotao, aumento ou reduo do tamanho e
espelhamento.
1.1.8 3iles e 4omposi!)o de 4enrios
*iles s+o imagens adicionadas em um cen!rio e divididas em peda,os iguais de
tamanho fi-o (Perucia et al). Tiles podem ser utilizados em conjunto com arquivos de
configurao para criar cenrios complexos. Segue abaixo uma demonstrao de
construo de um cenrio baseado em Tiles.
*lustrao &' (en+rio baseado em %iles
Na experincia de ensino de POO baseado em jogos, os alunos requisitaram em
vrios momentos recursos extras associados ao uso de cenrios com *iles, como por
exemplo: que os tiles possam ser escondidos e reexibidos (para casos por exemplo onde
existam passagens secretas), que possuam tratamento de coliso com o personagem e
demais objetos do jogo e que possam tambm serem movimentados
1.1.9 Pontos : Plano 4artesiano
Um jogo em duas dimenses ocorre em um plano cartesiano. importante que
existam abstraes para pontos neste plano e operaes entre estes pontos como calculo
da distncia e deteco de ponto mais prximo dentre um conjunto de pontos por
exemplo.
1.1.; (prites
"Sprites so estruturas com imagens prprias que permitem a criao de
animaes e o livre posicionamento na tela (Perucia). Uma sprite em geral
representada por um nico arquivo dividido em quadros de tamanho fixo, contendo cada
quadro uma imagem. A mesma sprite pode ser posicionada em um determinado ponto da
tela exibindo apenas um dos seus quadros internos por vez. A mudana da exibio
destes quadros ao longo do tempo resulta em uma animao.
1.1.< 7ispositivos de Entrada
A interao com o jogo ir ocorrer sempre atravs de um dispositivo. Os dois mais
comuns so teclado e mouse. No caso do teclado preciso que o desenvolver tenha
disponvel a informao de se uma (ou um conjunto) determinada tecla est ou no
pressionada em um determinado momento no tempo. No caso do mouse, as principais
necessidades so a posio do ponteiro do mouse e se o boto esquerdo foi pressionado.
Tambm importante que exista uma interface para um o.stick, ou seja, um
controle tradicional de video'game com 4 botes de ao e quatro botes direcionais.
*lustrao ,' E!emplo de uma -prite
1.1.= Exec!)o de sons
Os recursos de som disponveis para o desenvolvedor so apenas: 1)
carregamento dos arquivos de som; 2) tocar um som (com ou sem loop) e 3) parar um
som. O arquivo de udio pode ser no formato wave, comumente usado em jogos.
1.1.> 3axa de ?adros e ataliza!)o do +ogo
Representa o nmero de quadros de um jogo que uma aplicao consegue
executar em um segundo. O jogo ir sempre executar uma chamada de atualizao do
estado do jogo em loop. A taxa de quadros representa o nmero de repeties deste
quadro em um segundo.
1.1.@ Acmladores de 3empo
comum em jogos eletrnicos determinadas aes somente ocorrerem aps um
determinado tempo. Para realizar este clculo de tempo uma estrutura conhecida como
acumulador de tempo pode ser fornecida. Esta estrutura inicializa com o tempo que ir
controlar e, a cada atualizao do jogo, deve tambm ser atualizada. A estrutura fornece
uma interface para que o desenvolver identifique se o fim do tempo j chegou e a
possibilidade de reiniciar o acumulador.
1.1.1A Bravidade
A gravidade pode ser representada em um jogo por um nmero em pixels por
segundo que representa a acelerao da gravidade. Na vida real, a fora da gravidade
pode ser contrabalanceada pelo atrito com o ar. Em um jogo, ao invs de utilizar o atrito
com o ar, cada objeto recebe um nmero que representa a acelerao da gravidade sobre
ele. sso permite por exemplo, que um objeto passe a ter um salto maior, simplesmente se
a fora da gravidade sobre ele for diminuda.
No mundo real, existe um ponto em que o atrito com o ar se iguala a fora
gravitacional de modo que a velocidade de queda permanece constante. sto
reproduzido em um jogo, atravs de uma velocidade mxima que um objeto pode receber
quando est em queda.
1.1.11 7etec!)o e 3ratamento de 4olis"es
A deteco de colises ocorre verificando se duas formas geomtricas que
representam objetos do jogo, se tocam. Estas formas geomtricas so comumente
retngulos e/ou crculos, e a coliso ser verificada atravs de operaes matemticas
simples que verificam a interseco destas formas.
Aps a deteco ter ocorrido necessrio tratar a coliso. Ou seja, se o
personagem colidir com uma parede direita, ele no poder mais se mover para a
direita e dever ser reposicionado para o exato momento antes da coliso.
Uma das formas de dividir este tratamento tratando primeiro a coliso com o eixo
vertical e somente aps, com o eixo horizontal.
Tambm importante que o desenvolvedor tenha condies de saber para qual
direo ocorreu a coliso.
1.1.11 O Bame .oop
Todo jogo de computador ocorre dentro de um lao de repetio. Este lao realiza
trs operaes bsicas:
Entrada: onde so verificados os comandos emitidos pelos dispositivos de entrada,
mensagens via rede, etc;
Processamento: onde feito o clculo das posies dos objetos, coliso, etc;
7esen$o: onde os objetos so apresentados na tela do dispositivo.
1.1.18 ,ovimenta!)o e Bravidade nos cenrios
Os cenrios so um dos grandes ncleos do jogo. A grande maioria dos jogos
possuem cenrios grandes que podem ser percorridos por um jogador. Alm disso, o
efeito da gravidade deve parar de ocorrer quando um jogador encosta no cho,
geralmente definido em funo do cenrio.
2.3 %rae&or's Orie#tado a Objetos
Este captulo disserta sobre o desenvolvimento e uso de frameworks orientados a
objetos a partir do trabalho de Silva, esclarecendo as metodologias de desenvolvimento
existentes bem como as maneiras de document-la de modo a proporcionar o uso
adequado dos frameworks de acordo com as diferentes necessidades dos seus usurios.
1.8.1 2rameCorDs OO
Frameworks Orientados a Objetos correspondem a um conjunto de classes que se
adaptam ao desenvolvimento de aplicaes de um domnio especfico, oferecendo
estruturas flexveis para os pontos em que aplicaes de um mesmo domnio diferem
entre si.
Duas das principais caractersticas de um framework so alterabilidade e
extensibilidade:
Alterabilidade: Permite que os conceitos especficos das aplicaes sejam
suportados a partir de estruturas flexveis do framework;
Extensibilidade: Garante que o framework possa ser estendido no seu conjunto
de funcionalidades, ou seja, tenha sua manutenibilidade garantida;
Um framework sempre depende de outros artefatos de software para existir,
basicamente, as aplicaes especficas de um domnio que o originaram e as aplicaes
geradas a partir dele.
1.8.1 ,etodologias de 7esenvolvimento de 2rameCorDs OO
Muitos elementos do processo de desenvolvimento de um framework so comuns
diversas metodologias, podemos elencar estes elementos da seguinte forma:
Aqisi!)o de con$ecimento de dom&nio: A primeira etapa o estudo de
aplicaes desenvolvidas para o mesmo domnio do framework de modo a
identificar generalidades e especificidades dentro das aplicaes.
4onstr!)o da estrtra de classes: Aps a anlise, realizada a modelagem
de classes. Esta modelagem pode ser dividida em cinco etapas iterativas:
Beneraliza!)o: Criao de classes para as estruturas idnticas das aplicaes;
2lexibiliza!)o: Localizao das especificidades dos frameworks;
Aplica!)o de meta padr"es: Criao de mtodos template que podem ser
flexibilizados atravs de mtodos hooks para os pontos de flexibilizao
encontrados;
Aplica!)o de Padr"es de Pro+eto: ncluir classes de um padro (design
pattern) j catalogado e conhecido para uma determinada estrutura do
framework;
Aplica!)o de Princ&pios de OOE Aplicao de princpios especficos de
Orientao a Objetos como uso de herana e composio.
0mplementa!)o: Criao do framework em uma linguagem de programao;
Avalia!)o: O framework deve ser avaliado a partir do desenvolvimento de
aplicaes do domnio para o qual foi criado;
/efinamento: A partir do desenvolvimento de novas aplicaes, o conhecimento
sobre o domnio aumentar, possibilitando a melhoria do framework.
1.8.8 Fso de 2rameCorDs OO
Um framework deve facilitar o desenvolvimento de aplicaes de um domnio. Se
entender o framework for muito complexo, pode ser mais fcil desenvolver a aplicao
sem o framework.
Uma das formas de garantir uma documentao que atenda s necessidades dos
usurios do framework adaptando a documentao estas necessidades. Segue
abaixo uma proposta de documentao especfica para trs tipos de usurios comuns:
Tipo de 5su6rio Tipo de -ocumentao
!recisa decidir "ual frame.or/
utili7ar para o dese%volvime%to de
uma aplica#$o
+escri#$o do "ue pode e do "ue %$o pode ser feito com o
frame:or;.
!recisa descobrir como dese%volver
uma aplica#$o
Feceitas especficas de como utili7ar um determi%ado
recurso e2ou dese%volver uma aplica#$o ?'oo;boo;A.
!recisam co%-ecer em detal-es o
projeto do frame.or/ para o
dese%volvime%to de aplica#0es
comple5as
!odem ser utili7ados diaramasR descri#0es mais detal-adas
da estrutura das classesR c=dio fo%te e outras ferrame%tas.
/s "uest0es c-ave para este e%te%dime%to s$oN
7uais c0asses usar8 6uais classes co%cretas do
frame:or; podem ser utili7adas e "uais devem ser
criadas pelo dese%volvedorS
7uais m!todosN devem ser redefi%idos pelo
dese%volvedor ?mHtodos abstratosA e "uais devem
ser defi%idos pelo frame:or;. E%tra a"ui tambHm a
defi%i#$o dos mHtodos template0
$ 9ue os m!todos 4a:emN "ual o cmportame%to dos
mHtodos defi%idos pelo frame:or;.
%abela ,' 1ocumentao de frame.or/s
2.4 Padr(es Pedag)gicos
Como apoio s metodologias de ensino de programao orientada a objetos os
autores frequentemente recorrem padres pedaggicos que so projetados para
capturar as melhores prticas e a excelncia da arte de aprender e ensinar (THE
PEDAGOGCAL PATTERNS PROJECT) .
Para o ensino de cincias da computao, Joseph Bergin documentou catorze
padres pedaggicos. Os padres possuem vrios nveis de aplicao, desde a
organizao geral de uma disciplina at mesmo prticas em sala de aula. Os padres so
apresentados em ordem de escala, iniciando pelos que envolvem o planejamento de
cursos semestrais at atividades dirias em salas de aula.
1.9.1 O ,ais 0mportante Primeiro %EarlG Bird'
O curso organizado de modo que o mais importante deve ser apresentado
primeiro (e frequentemente), e caso isto seja impossvel, o quanto antes. Por exemplo, se
funes for mais importante que estruturas if, ensine funes primeiro, se objetos so
mais importantes que funes, ensine objetos primeiro.
Esta prtica importante porque os estudantes geralmente se lembram melhor do
que viram primeiro e importante que eles percebam desde o incio a ideia principal do
curso.
Alguns exemplos so:
Ensinar objetos primeiro;
Ensinar projeto primeiro;
Ensinar concorrncia primeiro em sistemas operacionais;
Ensinar requisitos de usurio primeiro em Banco de Dados;
Ensinar recurso antes de loops;
1.9.1 Espiral %(piral'
Quando um contedo trabalhado em sua ordem lgica, o instrutor precisa entrar
em muitos detalhes, tornando o ensino desgastante para os estudantes.
Uma soluo trabalhar os contedos em fragmentos que permitam que o
estudante resolva um determinado problema, posteriormente, mais fragmentos so
trabalhados de modo a resolver outros problemas, e assim, sucessivamente, trabalhando
o mesmo contedo mas em nvel de detalhe crescente.
Deste modo, desde cedo o estudante empoderado a construir aplicaes.
1.9.8 ,etfora 4onsistente %4onsistent ,atap$or'
Ao ensinar tpicos complexos, importante utilizar metforas cuja base seja
conhecida pelos estudantes, de modo que ele tenham clareza sobre como o sistema deve
se comportar e possam fazer conexes dos novos conceitos com conceitos que j so
bem conhecidos por eles.
1.9.9 4aixa de Brinqedos %3oG Box'
O objetivo deste padro permitir que desde cedo os estudantes possam entrar em
contato com o conhecimento da rea do curso atravs de ferramentas pedaggicas
ilustrativas, os brinquedos.
Estes brinquedos podem ser classes que abstraem parte da complexidade
envolvida no desenvolvimento de um software de maior escala, ferramentas que tornam a
programao mais acessvel, ou qualquer outro tipo de artefato que permita que os
estudantes desenvolvam projetos maiores e mais interessantes.
Um dos requisitos deste padro que os instrutores precisam preparar o material e
ter tempo disponvel para que os estudantes explorem os recursos disponibilizados.
1.9.; 4aixa de 2erramentas %3ool Box'
Desde o incio do curso os estudantes desenvolvem ferramentas que lhes sero
teis em fases avanadas do curso, funcionando tambm como ensino de reuso de
software.
Os exerccios do curso devem ter diversos nveis e nos nveis iniciais os estudantes
so estimulados a discutir e desenvolver seus componentes. importante tambm que o
projeto de software para reuso seja discutido e apresentado o quanto antes pelo instrutor.
Estes componentes desenvolvidos pelos alunos podem ser complementados por
bibliotecas fornecidas pelo instrutor. Um bom exemplo da aplicao deste padro o uso
de elementos construdos em disciplinas de estruturas de dados.
1.9.< 7isposi!)o do territrio %.aG of t$e .and'
Os estudantes devem examinar um artefato do domnio que esto estudando de
maior complexidade, de modo a ver a imagem real de um produto na sua rea de
atuao.
sto permite que eles faam conexes das diversas partes do sistema com os
conctedos que esto aprendendo, situando cada um deles no contexto de uma aplicao
real.
Exemplos podem ser:
Um software com vrias classes interagindo em Orientao a Objetos;
Um modelo entidade relacionamento com diversos relacionamentos em um curso
de bases de dados;
O projeto completo de um software em um curso de projeto orientado a objetos.
importante que o artefato seja algo semelhante ao que o instrutor deseja que o
estudante desenvolva ao final do curso. essencial tambm, que o artefato tenha um
design e utilize os conceitos do curso de forma excelente.
Assim, as diversas partes do artefato a suas interaes podem ser examinadas
pelos estudantes e posteriormente utilizadas como exemplo de um determinado conceito
do curso.
1.9.= 4orrigir para cima %2ixer Fpper'
Neste padro, um artefato de grande porte oferecido aos alunos com falhas
cuidadosamente preparadas. Este padro permite o ensino de novos conceitos e da
anlise e correo de erros.
As falhas devem ser bvias para a maioria dos leitores, contendo uma ou duas
falhas de maior complexidade.
A origem do nome do padro vem da expresso "Fixxer Upper que representa uma
casa vendida em condies ruins, de modo que o comprador precisar repar-la aps a
compra.
1.9.> ,aior qe a Hida %.arger t$an .ife'
Em cursos de literatura, sociologia e histria por exemplo, comum que os
estudantes trabalhem com textos que eles no teriam condies de criar.
E como ler mais fcil do que escrever, este padro fala sobre usar artefatos de
software de maior complexidade e bem escritos como exemplos a serem copiados.
Esta uma forma de estimular o conhecimento sobre o desenvolvimento de
softwares reais que os estudantes ainda no teriam condies de projetar e desenvolver.
Um exemplo so bibliotecas padro das linguagens de programao atuais.
1.9.@ (print de Pro+eto dos Estdantes %(tdent 7esign (print'
Ensinar a projetar softwares hoje reconhecido como necessidade por muitos
instrutores. Este padro sugere o uso de atividades que permitam que os estudantes
projetem solues para problemas, recebam feedback, projetem novamente, recebam
novo feedback, e assim sucessivamente.
Um exemplo de atividade separar os alunos em grupos de dois ou trs e solicitar
o projeto para um determinado problema. Ao final, so levantadas questes que no
podem ser respondidas com um design inadequado e os estudantes so organizados em
grupos de 4 ou 5 de modo que cada grupo tem pelo menos duas propostas de projeto.
Eles so desafiados a criarem uma nova proposta, ao final, mais questes podem ser
levantadas e alguns projetos discutidos. O processo pode continuar enquanto o professor
desejar.
1.9.1A Engano %,istaDe'
Os estudantes so estimulados a criarem artefatos com erros propositais, de modo
a ensin-los como reconhecer erros e suas consequncias.
Todos cometemos erros, profissionais experientes geralmente conseguem
reconhecer um erro quando visualizam as consequncias de um, estudantes no sabem
reconhecer estes erros.
1.9.11 4anal de 3este %3est 3be'
Tambm conhecido como "teste e veja, este padro fora que os estudantes
testem suas prprias perguntas para questes do tipo "O que aconteceria se eu... Desde
que exista acesso a um computador, eles podem testar suas hipteses.
importante que o instrutor fornea listas de exerccios levando em conta as
principais dvidas apresentadas colocando em diversos pontos questes do tipo "O que
aconteceria se voc....
sto pode ser usado para testar as regras de sintaxe de uma linguagem por
exemplo e/ou o uso de operadores.
Um bom exemplo o ensino de loops, onde a simples mudana de algumas
variveis podem gerar impresses na tela diferentes, de 1 at 10 ou mesmo um loop
infinito.
1.9.11 Preenc$a as .acnas %2ill in t$e BlanDs'
muito difcil e o tempo gasto seria muito alto para estudantes iniciantes
desenvolverem softwares complexos, porm, o que eles podem fazer com as habilidades
iniciais geralmente muito chato.
A soluo proposta disponibilizar um software complexo que os estudantes
possam analisar e deixar pequenas lacunas no software a serem implementadas pelos
alunos com os conhecimentos que possuem. Um exemplo simples uma definio de
classe em Java onde o corpo de um mtodo foi deixado em branco.
1.9.18 Estrela de Oro %Bold (tar'
Os estudantes devem ser recompensados pelo que eles fazem bem e jamais os
deprecia por ainda no terem atingido as competncias almejadas.
1.9.19 Avalie isto novamente *a %Brade it again (am'
Permita que trabalhos e atividades sejam enviados posteriormente para
reavaliao. sso estimula os estudantes a criarem erros e os motiva a melhorarem seus
trabalhos para melhorar suas notas.
8 ExperiIncia pr#via com ensino de POO e 6ogos
No primeiro semestre de 2012, no curso Tcnico em Programao articulado com o
Ensino Mdio do SENA So Jos em Santa Catarina, na disciplina de Programao
Orientada a Objetos , foi trabalhado um mdulo de desenvolvimento de jogos com Java.
A turma trabalhada possui 33 alunos entre 16 e 18 anos.
Esta disciplina est presente no terceiro semestre do curso. Os estudantes j
chegam a esta disciplina com uma base sobre alguns conceitos bsicos de OO como
construo de classes, mtodos, atributos e parmetros, bem como conceitos bsicos de
estruturas de programao como if, while, switch, dentre outros. Entretanto, por ser um
curso paralelo ao ensino mdio e pelo perfil do pblico, comum que eles cheguem na
terceira fase aps o perodo de frias sem se lembrar com exatido dos contedos
trabalhados nos semestres anteriores, sendo necessrio relembr-los.
Este mdulo teve durao de 76 horas/aula. Destas, 40 horas/aula foram utilizadas
para o ensino dos conceitos de Programao e Jogos 2D. As demais 28 horas foram
utilizadas pelos alunos em sala com orientao do professor para o desenvolvimento do
jogo.
3.1 +o#te,dos trabal-ados
O contedo foi dividido em duas categorias, Programao Orientada a Objetos
(foco da disciplina) e Jogos 2D. Alm destes contedos, questes como uso de controle
de verso e uma DE de programao tambm foram abordados, porm, por no fazerem
parte deste estudo, no sero citados.
Segue abaixo tabela com os contedos trabalhados e um identificador para cada
um:
2onte;dos #$$ 2onte;dos %o&os 2-
C1) Composio;
C2) Encapsulamento;
C3) Herana;
C4) Polimorfismo;
C5) sobrecarga e sobreescrita de mtodos e
construtores;
C6) Classes abstratas,
C7) nterfaces;
C8) Enum;
C9) Mtodos e atributos estticos
C10) Tratamento de Exceo
C11) Padres de desenvolvimento (frameworks);
C20) Sprites;
C21) TileMaps;
C22) Animao;
C23) Desenho 2D;
C23) Captura Eventos Teclado;
C24) Captura Eventos Mouse.
%abela 2' %abela demonstrando os conte3dos trabalhados na e!peri"ncia prvia com ensino de
orientao a ob#etos baseado em #ogos.
Para melhor entendimento, segue abaixo uma descrio breve de como cada um
dos contedos foi trabalhado:
41' 4omposi!)o: Para formar objetos de um jogo, como personagens de luta, era preciso
ter uma classe composta de outras que representassem imagens, 'magias' dos
personagens, etc;
41' Encapslamento: Alguns recursos como coliso de personagens com o cenrio foi
encapsulado pelo professor e fornecido atravs de classes, como forma de passar o
conceito, depois, no desenvolvimento do jogo e dos exemplos em aula eles foram sembre
lembrados de encapsular a lgica de alguns elementos do jogo dentro de sua respectiva
classe;
48' Jeran!a: Todos os objetos do jogo precisavam estender uma classe chamada
GameObject que j possua caractersticas bsicas de um objeto, como a posio inicial,
mtodos de acesso e mtodos modificadores a estes atributos;
49' Polimorfismo: comum termos itens em jogos 2D, estes itens podem aumentar a
vida do personagem, deix-lo mais rpido ou mais lento, dentre outras caractersticas.
Uma das formas de se trabalhar o polimorfismo foi com classes que representavam itens,
estas classes estendiam uma classe tem, e todos os itens, representados com subclasses
abstratas eram referenciados no projeto como objetos da classe tem, para permitir
extenso do software. Tambm foi visto polimorfismo de mtodo com mtodos de coliso
que podiam receber diferentes parmetros.
4;' (obrescrita de m#todos e constrtores: A maioria dos mtodos implementados
pelos estudantes eram da prpria classe ou abstratos. A sobrescrita foi trabalhada apenas
quando os estudantes estendiam uma classe que representava um objeto com gravidade.
A lgica responsvel por parar o objeto em caso de queda se ele colidisse com um cho
era um comportamento padro que os estudantes precisavam sobrescrever quando
haviam especificidades nos seus objetos, sempre lembrando de chamar o mtodo
sobrescrito da classe superior para no perder o efeito da gravidade;
4<' 4lasses abstratas: A classe GameObject, da qual todos os objetos do jogo devem
herdar, abstrata e exige a implementao de dois mtodos, um para execuo da lgica
do objeto e outro para desenh-lo.
4=' 4lasses 0nterface: Cada fase do jogo era representada por uma classe que
implementava uma interface. Esta interface apresentava mtodos para quando uma fase
iniciava, era carregada, desenhada ou estava em execuo;
4>' Enm: Quando foram trabalhados jogos de luta, um enum foi utilizado para controlar o
estado do personagem, ou seja, se ele estava pulando, apanhando ou em estado normal;
4@' ,#todos e atribtos estticos: O framework utilizado apresentava diversos mtodos
estticos, principalmente para recuperar a referncia aos objetos que capturam aes dos
perifricos e realizam operaes de desenho. Os atributos estticos foram trabalhados
para representar as teclas do teclado;
41A' 3ratamento de Exce!)o: Sempre que uma imagem era carregada para o jogo,
corria-se o risco dela no existir. Neste caso, uma exceo era gerada internamente pelo
software e o estudante deveria trat-la. nfelizmente neste ponto, apenas era exibida uma
mensagem de erro ao usurio e o tratamento de exceo no foi visto em sua plenitude,
quando o programador usa excees para manter o software funcionando mesmo em caso
de falhas.
411' Padr"es de desenvolvimento %frameCorDs': Foi utilizado durante toda a disciplina
o framework ava)la. (Feij et al), de modo que o conceito de framework foi trabalhado
constantemente;
41A' (prites: Em um jogo onde o jogador precisava mover uma nave pelo cenrio, foi
utilizada uma sprite com a imagem da nave em todas as direes. Como suporte, foi
fornecida uma classe que desenhava os quadros de uma sprite, adaptada do framework
ava)la.;
411' 3ile,aps: Cada cenrio era representado por um conjunto de *iles e um arquivo de
configurao que dizia como posicionar os tiles no cenrio. Uma classe que desenhava o
cenrio a partir do arquivo de configurao foi fornecida;
411' Anima!)o: Foi usado o efeito de bombas explodindo, onde a cada fatia de tempo era
preciso mudar a imagem da bomba desenhada na tela;
418' 7esen$o 17: Nos exemplos iniciais foram utilizados somente figuras geomtricas
simples como crculos e linhas. Todas desenhadas pela AP /raphics do prprio Java;
419' 4aptra de Eventos 3eclado: Atravs da classe 0e.board fornecida pelo framework
ava)la. com mtodos para saber se uma determinada tecla estava pressionada;
41;' 4aptra de Eventos ,ose: Atravs da classe 1ouse fornecida pelo framework
ava)la. com mtodos para saber se o boto esquerdo ou direito do mouse estava
pressionado e qual a posio do cursor na tela;
3.2 Metodologia
O principal elemento da metodologia foi o uso de exemplos, no qual era aplicado
um determinado conjunto de conceitos na construo de um jogo e, a seguir, atividades
prticas de melhoria do exemplo apresentado de modo a permitir que o estudante tivesse
um contato com o conceito e a sua implementao.
Apenas em um nico momento iniciaram o desenvolvimento com uma tela vazia,
neste caso, tinham em mos um script que os guiaria pelos conceitos e recursos bsicos
do ava)la..
Antes do incio deste mdulo com jogos houve uma reviso breve dos conceitos de
classe, mtodos, atributos, e outros conceitos bsicos de OO.
Todos os exemplos foram desenvolvidos tendo como base o framework ava)la.
(Feij). E, aps um perodo de aulas tericas, os alunos puderam desenvolver seu prprio
jogo, com tema livre. Seguem abaixo o relato dos exemplos utilizados:
8.1.1 Exemplo 1 K ,ovimentando ma bola
No primeiro momento, foi apresentado um exemplo de uma bola se movimentando
horizontalmente na tela a partir do movimento do teclado (Caminha, Exemplo 1). Esta
lio demonstrou o uso bsico do framework, como acessar o teclado e como criar um
objeto de jogo, no caso, a bola.
Aps a apresentao, os estudantes receberam a tarefa de permitir o movimento
vertical da bola no eixo vertical sem perder o movimento horizontal existente. Ao final, um
exemplo de um jogo mais complexo (Caminha, Exemplo 2) utilizando o objeto da bola foi
mostrado para exemplificar o potencial do que eles estavam aprendendo. Tambm foi
disponibilizado um tempo para que eles fizessem alteraes neste exemplo mais
complexo, agora porm, de forma livre.
*lustrao 2' 4ovimentando uma bola na tela
*lustrao 5' E!emplo mais comple!o utili6ando a bola criada
anteriormente
8.1.1 Exemplo 1 K 4onstrindo o primeiro +ogo
No segundo momento, era importante que os estudantes iniciassem o
desenvolvimento de um jogo simples, porm, passando por todas as etapas do processo
de desenvolvimento, j que na etapa anterior, haviam apenas realizado uma modificao.
Para auxili-los foi fornecido um roteiro de 10 passos (Caminha, javaPlay em 10
passos)que guiava a construo de um jogo (Caminha, Exemplo 3) no qual o personagem
controla um jogador em formato de bola (verde) que deve fugir de alguns inimigos (bolas
amarelas e vermelhas) at um elemento de chegada, uma estrela.
8.1.8 Exemplo 8 K -tens e fases
Passamos agora a melhorar o jogo desenvolvido com o auxlio do roteiro. A
primeira atividade foi o uso do framework para poder realizar a passagem de fases.
Ento, foi construdo um jogo com trs fases.
1. A primeira fase corresponde ao jogo j criado na etapa anterior;
2. Na segunda fase o personagem tambm pode capturar itens. Um dos itens
representado por um quadrado verde e aumenta a velocidade do jogador. O
segundo um quadrado vermelho e inverte a movimentao. Para a construo
dos itens foi criada uma classe abstrata que obriga o programador a implementar
um mtodo de ao quando o personagem tem coliso com alguns dos itens.
Antes de avanar para a terceira fase, os estudantes so orientados a criar um
novo tipo de item;
3. Na terceira fase, uma nica lista utilizada para armazenar os diversos itens do
jogo. Quando existe coliso com algum deles o mtodo definido na classe abstrata
*lustrao 7' %ela final do #ogo desenvolvido com o au!lio do roteiro
executado.
8.1.9 Exemplo 9 K Berra Especial
A partir deste ponto, iniciou-se o trabalhando com o uso de imagens e a criao de
novos objetos a partir de objetos j existentes. Decidi utilizar uma metfora similar aos
projetos anteriores e escolhi um jogo no qual o jogador controla uma nave que se move
pelo cenrio e precisa destruir as naves inimigas (Caminha, Guerra Espacial).
Como este projeto era complexo, ele foi divido em 4 etapas:
Etapa 1: apenas foi desenhada uma nave que se movimentava livremente pelo
cenrio, de modo a trabalhar o uso das classes para desenho de imagens;
Etapa 1: a nave foi capaz de atirar. Os tiros eram criados pela nave, de modo a
trabalhar que um objeto era capaz de criar outros objetos ao longo da execuo do
software. Estes tiros so armazenados em uma lista, trabalhando a capacidade
dinmica de armazenamento das listas;
Etapa 8: uma nave inimiga criada e o objetivo , com os tiros, eliminar a nave
inimiga. Este mdulo trabalha principalmente a interao entre trs objetos
diferentes em tempo de execuo. Tambm adicionada uma classe que gerencia
a exploso que ocorre quando o tiro acerta a nave.
Etapa 9: um segundo jogador adicionado e exploses especiais so adicionadas
quando uma nave inimiga atinge um dos jogadores. Vrias naves inimigas so
criadas e os tiros de ambos os jogadores podem acertar as naves. sto cria um
ambiente complexo que s pode ser gerenciado atravs do uso de listas. Cada
*lustrao 8' %erceira fase do e!emplo com diversos itens na tela
jogador construdo com uma classe de modo a estimular os estudantes na
identificao de cdigo duplicado e possibilidade de herana.
8.1.; K Personagens e 4enrios
Nesta etapa, era importante demonstrar os mesmos conceitos abordados em outro
contexto. Foi escolhido o contexto de jogos com cenrios e gravidade. Nestes jogos um
personagem se movimenta por um cenrio que possui uma estrutura considerada como
cho e pode saltar sobre obstculos, plataformas e outros. Como este projeto envolvia
grande complexidade, foi dividido em 2 etapas:
Etapa 1: Apenas um personagem (chamado Ryu) se movimentando por um
cenrio construdo a partir de um arquivo de configurao. Toda a coliso com o
cenrio feita por uma classe que encapsula a lgica. Os alunos no so
instrudos sobre a lgica utilizada pela classe devido a sua complexidade. Os
estudantes so instrudos sobre como controlar os pulos do personagem
(Caminha, Exemplo Ryu);
Etapa 1: Aps, so adicionados inimigos na fase representados por bolas
vermelhas que rolam em direo ao jogador, semelhante as naves inimigas no jogo
Guerra Espacial (Caminha, Exemplo Ryu 2).
*lustrao 9' :erso final do #ogo ;uerra Espacial
8.1.< K 6ogo de .ta
Como exemplo final foi trabalhado um jogo de luta utilizando o mesmo personagem
anterior contra outro personagem (chamado Vegeta). Neste jogo os personagens
possuem golpes e um deles pode atingir o outro. Este material serviu principalmente
como estmulo ao desenvolvimento dos jogos dos alunos no projeto final e demonstrou
comportamentos mais complexos de interao entre os objetos (Caminha, Ryu vs
Vegeta).
8.1.= K /evis)o
Ao final foi preparado um material de reviso de todos os conceitos relembrando os
tpicos abordados e todos os conceitos apresentados (Caminha, Reviso jogos 2D).
*lustrao <' )ersonagem saltando sobre um inimigo
representado por uma bola vermelha
*lustrao =' E!emplo #ogo de luta
3.3 .valia!"o e /esultados
A avaliao da disciplina foi feita atravs de conhecimentos e habilidades. Por
conhecimento entende-se as capacidades tericas, avaliadas com trs provas de curta
durao e uma de reviso sobre todo o contedo. Por habilidades entende-se a
capacidade prtica de desenvolver um jogo utilizando os conceitos aprendidos.
Para avaliar o nvel de motivao com a disciplina, principalmente ao trabalharmos
o tema de jogos, foram includas questes sem peso avaliativo e de resposta voluntria
nas provas tericas.
8.8.1 Avalia!)o 3erica
As trs primeiras provas avaliaram diferentes aspectos ao longo das 40 horas/aula
trabalhadas e ao final do contedo, houve uma prova com todo o contedo abordado
durante o ensino. As trs primeiras provas foram divididas em duas partes, a primeira
parte era sempre aplicada no incio das atividades e a segunda ao final. Segue a
descrio de cada uma e a mdia de pontuao obtida.
Primeira prova: foi aplicada logo aps a construo do primeiro jogo e abordou
conceitos complexos como classes abstratas, interface e herana. A mdia geral da
prova em uma escala de 0 a 100 foi de 66 pontos e meio (Caminha, Prova 2
a
e
Prova 2b).
(egnda prova: Aps este resultado baixo os mesmos conceitos foram
retrabalhados nos exemplos posteriores e a segunda prova foi aplicada aps o
exemplo com uso de itens e diversas fases, de modo que polimorfismo foi includo
com os demais contedos na prova. A mdia geral da turma foi de 90 pontos em
uma escala de 0 a 105 (Caminha, Prova 3
a
e Prova 3b).
3erceira Prova: A terceira prova teve como foco o reuso de cdigo com
composio e herana, acrescido de alguns poucos tpicos sobre jogos 2D. A
mdia geral foi de 73 em uma escala de 0 a 100 (Caminha, Prova 4a e 4b).
Prova de /evis)o: A prova reviso foi aplicada a todos os alunos aps a reviso
com o objetivo de verificar de forma ampla o entendimento terico da disciplina
aps todo o contedo trabalhado. Esta prova teve pelo menos um tpico sobre
cada contedo trabalhado e a mdia geral da turma foi de 72 pontos em uma
escala de 0 a 100 (Caminha, Prova de Reviso).
Aps a anlise da prova percebi que as questes envolvendo os conceitos de
herana, composio, polimorfismo, classes abstratas e classes interface foram
devidamente absorvidos.
Porm, tive ndice de erro de quase 50% em uma questo que envolvia a
identificao e classificao de algumas estruturas bsicas como atributos, mtodos e
construtores (questo 3 da prova de reviso). Porm, no momento de correo da prova
praticamente todos percebiam e compreendiam o erro aps este ter sido identificado.
A hiptese levantada que esta dificuldade ocorreu poque foi trabalhado muito com
estruturas bsicas j prontas que eles apenas copiavam, colavam e modificavam para a
sua necessidade, at mesmo quando era criada uma aplicao do zero, eles tinham um
roteiro com cdigos fonte de apoio.
Como trabalhamos neste modelo por dois meses e a disciplina anterior de
Orientao a Objetos havia sido ministrada no ano anterior, acredito que eles acabaram
esquecendo o nome de algumas estruturas simples.
8.8.1 Avalia!)o da ,otiva!)o
Na primeira prova, logo aps a construo do primeiro jogo os estudantes foram
perguntados se estava sendo interessante aprender Orientao a Objetos com Jogos.
82% disseram que sim, 9% no responderam e 9% disseram que no fazia diferena.
Havia uma opo para o caso de no estar gostando, nenhum estudante marcou esta
opo.
Ficou claro tambm na relao de convivncia que o interesse havia aumentado
muito em relao disciplina de Programao Orientada a Objetos onde havamos
trabalhado com softwares Desktop e com exemplos proposto por Barnes.
Ao final, pelo menos 5 alunos demonstraram grande interesse em seguir a carreira
de programador de jogos.
8.8.8 Avalia!)o Prtica
Ao final das 40 horas aula tericas, os estudantes tiveram 28 horas aula para
desenvolver o prprio jogo. Os 33 alunos se organizaram em 8 grupos e desenvolveram
os seguintes trabalhos:
3.3.3.1 Grupo 1 0 Po&erMusic
Jogo similar ao popular GuitarHero onde o jogador simula que est tocando uma
guitarra no acompanhamento da msica e deve pressionar os botes correspondendo a
nota da guitarra no momento exato indicado por uma animao na tela.
3.3.3.2 Grupo 2 0 +-apio#s %ig-ter
Jogo de luta como o apresentado no exemplo para a turma com personagens
clssicos de diferentes desenhos animados e jogos de vdeo-game. Cada personagem
pode dar socos, chutes e alguns contm um especial.
3.3.3.3 Grupo 3 0 G-oai#e
Jogo de luta como o apresentado no exemplo para a turma com personagens
clssicos de diferentes desenhos animados e jogos de vdeo-game com o diferencial de
cada personagem contm de 2 3 ataques especiais especficos.
3.3.3.4 Grupo 4 0 1ce +ro&# +itadel
Jogo com muitas fases onde trs jogadores unem habilidades distintas para
derrotar diversos inimigos. Cada inimigo representa uma fase no jogo.
3.3.3.2 Grupo 2 0 Moluscatio#
Um personagem criado pelos estudantes deve percorrer um cenrio pulando por
obstculos e bombas. A cada fase possvel ganhar alguns poderes especiais.
3.3.3.3 Grupo 3 0 4errorist *trateg5
Jogo no estilo do clssico Bomberman onde dois personagens disputam entre si
lanando bombas em um cenrio com obstculos.
3.3.3.6 Grupo 6 0 God of 7ors
Disputa entre duas minhocas realizado em turnos. Cada minhoca, no seu turno,
pode lanar um tiro sobre a outra escolhendo um ngulo e uma fora.
3.3.3.8 Grupo 8 0 *ai Gae
Jogo similar a um futebol de boto no qual cada personagem um crculo que
precisa acertar uma bola e jog-la para dentro do gol adversrio.
8.8.9 /esltado avalia!)o prtica
A avaliao tcnica do jogo contou com diversos critrios para verificar se os
conceitos de Orientao a Objetos foram aprendidos corretamente, segue abaixo os
critrios, o respectivo ndice de acerto mdio dos grupos e o nmero de grupos que
atenderam perfeitamente ao critrio:
2rit!rio #orcenta&em de
<certo
=;mero de >rupos com
acerto m6ximo
Uso de Composio ,.T 4
Uso de Herana (1T 4
Uso de Polimorfismo 3(T 3
Classes Enum 3(T 3
Classes Abstratas 3(T 3
Uso de Listas (ArrayList) ((T 5
%abela 5' >ndice de acerto em cada um dos critrios de avaliao do #ogo ,1
A avaliao mostrou de forma clara que os estudantes no conseguiram identificar
em seus projetos oportunidades para uso de recursos mais avanados de programao
como polimorfismo e classes abstratas.
Foi identificado na maioria dos projetos oportunidades do uso destes recursos, de
modo que as restries no foram decorrentes dos jogos projetados.
Outros conceitos mais bsicos como herana e composio foram absorvidos com
tranquilidade e implementados com qualidade pela maioria dos grupos. No caso de
herana, apesar de todos terem utilizado pelo menos alguma classe com herana,
existiam muitos lugares no cdigo onde a herana seria adequada e o grupo no
percebeu. Por isso que apenas metade dos grupos atingiram aproveitamento perfeito
neste quesito, tendo, todos os outros, aproveitamento parcial.
8.8.9 4oncls)o ao final do mdlo
Ficou evidente o grande aumento da motivao dos alunos, principalmente pela
qualidade de muitos dos jogos apresentados ao final da disciplina.
Porm, a nfase em um grande conjunto de cdigos previamente elaborados que
eles apenas modificavam acabou por gerar dificuldade em reconhecer quando e como
aplicar um determinado conceito aprendido para um problema novo. Por exemplo, eles
tinham facilidade em entender quando usar herana para os casos semelhantes aos
apresentados em sala, mas no em casos diferentes.
Acredito que a metodologia aqui adotada carece de maturidade na elaborao de
atividades e exemplos que permita aos estudantes adquirirem maturidade no processo de
desenvolvimento e identificarem adequadamente onde cada conceito pode ser aplicado.
9 Ensino de Programa!)o Orientada a Ob+etos
O ensino de programao em Java implica em grandes desafios para o ensino de
programao orientada a objetos. segundo Barnes, um programa mnimo em java possui
numerosos obstculos de sintaxe tas como: escrever uma classe; escrever um mtodo
main; a criao de um objeto utilizando a palavra-chave new2 uma atribuio a uma
varivel, a declarao de uma varivel, incluindo o tipo; uma chamada de mtodo;
utilizando a notao de ponto; possivelmente, uma lista de parmetros.
Podemos somar a isso o excesso de conhecimento necessrio para realizar
operaes bsicas de input e output, o grande nmero de termos como instncia,
herana, mtodo com os quais os estudantes no esto familiarizados e a dificuldade
adicional para os estudantes cuja lngua nativa no o ingls (Clark).
Por fim, alguns autores (Barnes, Feij) identificaram a necessidade de ensinar
atravs de projetos, para que os conceitos possam ser vistos em aplicaes reais.
Esta seo visa apresentar algumas metodologias para o ensino de Orientao a
Objetos com Java e extrair ao final, um conjunto de diretrizes guia para o presente
trabalho.
4.1 Metodologias para E#si#o OO
Para a elaborao deste trabalho foram escolhidas cinco metodologias de ensino
de Orientao a Objetos. Os critrios para a escolha foram a sua relevncia entre os
instrutores de programao e a experincia prtica do autor deste trabalho com cada
metodologia.
A primeira metodologia a desenvolvida pelo professor do Departamento de
nformtica e Estatstica da Universidade Federal de Santa Catarina, sais Camilo Boratti.
Metodologia responsvel pelo primeiro contato do autor com Orientao a Objetos.
A segunda a de maior abrangncia internacional, principalmente por ter sido a
primeira metodologia a vir acompanhada de um livro texto e de uma ferramenta que
oferecesse suporte total a ela. a metodologia construda por David J. Barnes e Michael
Kolling utilizando o BlueJ como ambiente de programao. Esta metodologia foi utilizada
parcialmente pelo autor para um curso de Programao Orientada a Objetos de 90 horas
aula.
A terceira escolhida foi a metodologia de introduo cincia da computao com
jogos que deu origem ao curso apresentado no captulo trs, baseada no trabalho de
Bruno Feij do VisionLab da PUC do Rio de Janeiro.
A quarta, a metodologia desenvolvida por Stelios Xinogalos ao longo de quatro
anos de ensino de programao orientada a objetos. Xinogalos tambm trabalhou com a
metodologia de Barnes e Kolling, porm com o tempo, passou a adot-la apenas
parcialmente no projeto do seu curso, utilizando um conjunto mais abrangente de
ferramentas.
Por fim, para atender uma necessidade observada pelo autor deste trabalho, foi
adotada a metodologia de Caspersen, que trabalha com uma abordagem baseada na
modelagem do problema a ser resolvido antes de trabalhar como produzir o cdigo para
um determinado problema.
Para cada metodologia apresentada a sequencia de sees da metodologia com
os respectivos contedos e exemplos trabalhados. Aps, feita uma descrio geral do
mtodo, uma anlise dos pontos fortes e fracos de cada metodologia e uma reviso final.
9.1.1 0saias 4amilo Boratti
Esta metodologia foi vivenciada pelo autor como aluno no primeiro semestre de
2007, no curso de Sistemas de nformao da Universidade Federal de Santa Catarina,
na disciplina de Programao Orientada a Objetos .
A disciplina foi ministrada pelo prprio professor saias Camilo Boratti que, no
mesmo ano, em agosto, publicou o livro que documenta a metodologia intitulado
"Programao Orientada a Objetos em Java.
O livro est organizado em oito captulos conforme tabela abaixo:
'aptulo E5emplos de !rojetos +ese%volvidos !ri%cipais 'o%ceitos abordados
'aptulo 1 ?enhum pro#eto desenvolvido
Fela#$o !OO com o mu%do
realS
!rocesso de /bstra#$oS
Opera#0es de /bstra#$o.
'aptulo 2 ?enhum pro#eto desenvolvido
Objetos e 'lassesS
Feprese%ta#$o visual de objetos
e classesS
8i%uaem JavaS
'aptulo 3
>mprimir %a tela uma li%-a de te5toS
'alcular a soma de dois %CmerosS
Escrever um prorama "ue determi%e a *rea
de um crculoS
MHtodo mai%S
>de%tificadoresS
1ipaem de valoresS
Bari*veisS
'ria#$o de objetosS
3tri% 2 se"uO%cia de caracteresS
+eclara#$o de atributosS
+eclara#$o de mHtodosS
'o%strutoresS
!arUmetros e /rume%tosS
'ompila#$o JavaS
!rocesso de modelaem de um
soft:are a partir de um problemaS
'aptulo 4
Escrever uma aplica#$o "ue determi%e a
distU%cia e%tre dois po%tosS
>mpleme%ta#$o de mHtodosS
MHtodos de acesso e mHtodos
modificadoresS
>mpleme%ta#$o de co%strutoresS
EscopoS
'ome%t*riosS
!arUmetrosS
>mpleme%ta#$o de objetos 2
referO%cia para um espa#o de
mem=riaS
1ipaem de valoresS
/tribui#$oS
'o%vers$o e5plcita de tipoS
E5press0es aritmHticasS
E5press0es 8=icasS
'aptulo 5
Escrever um prorama "ue determi%e a
idade mHdia de um rupo de pessoasS
Escrever um prorama "ue determi%e a
mHdia de idade das pessoas do se5o masculi%o e
tambHm a mHdia de idade das pessoas do se5o
femi%i%o de um rupo de pessoasS
'lasse /lu%oS
'lasse 1riU%uloS
!rocessos de repeti#$o 2 loopsS
!rocessos de tomada de decis$o.
E5N ifR s.itch0
E%capsulame%toS
Modificadores de acessoS
!alavra c-ave thisS
Berificar se um %Cmero H primoS
'aptulo 4
+ese%volver uma aplica#$o "ue fa#a uma
a%*lise do desempe%-o de alu%os em
determi%ada discipli%a. / aplica#$o deve
determi%arR para cada um dos alu%osR a sua
mHdia fi%alR ju%tame%te com uma i%forma#$o
di7e%do se o alu%o foi aprovado ou %$o.
'o%siderar "ue o alu%o te%-a reali7ado trOs
avalia#0esR todas com o mesmo pesoS
Em um determi%ado joo de dados
participam dois joadores. 'ada joador deve
la%#ar o dado e computar para si os po%tos
obtidos. 3er* co%siderado ve%cedor o joador
"ue ati%ir um total de 1.. po%tos ou mais.
3empre "ue %o la%#ame%to do dadoR o joador
obter o valor 1 ou 4R este ter* direito a um %ovo
la%#ame%toS
Modelaem das classes @uncionarioR (hefe
e ApoioR se%do as duas Cltimas subclasses de
@uncionarioS
Modelaem da classe abstrata 'o%tribui%te e
das subclasses @isico e Buridico.
Vera%#aS
/ palavraMc-ave superS
Feutili7a#$o de c=dioS
3obreposi#$o de mHtodosS
!olimorfismoS
!olimorfismo de mHtodoS
3obrecara de mHtodosS
'lasses abstratasS
'aptulo &
W+ese%volver uma aplica#$o "ue avalie o
desempe%-o de um rupo de estuda%tes em
determi%ada discipli%a..."ue prevO a reali7a#$o
de v*rios testes e uma prova fi%al...a mHdia dos
testes ter* peso de 4.T e a prova fi%al peso de
4.T.... X
/rra%jos 2 ArraCs0
ArraCs Multidime%sio%aisS
Opera#0es com arraCs.
'aptulo (
/tributos de classeS
MHtodos de classeS
MHtodos da classe 4athS
Ma%ipula#$o de 3tri%sS
'lasse (haracterS
%abela 7' (onte3dos e E!emplos da metodologia de Doratti
4.1.1.1 .#9lise Geral do M:todo
A metodologia inicia demonstrando que o mundo real constitu#do por entidades
"ue interagem entre si, e que tais entidades possuem caractersticas e funes, podendo
tambm serem chamadas de objetos.
Dessa forma, a construo de um software orientado a objetos passa pelo processo
de identificao dos objetos envolvidos e de como estes objetos iro se relacionar entre si
para a resoluo de um determinado problema.
A partir disto, Boratti conduz o estudante pelo conceito de abstrao, que
corresponde:
Wao processo utili7ado %a a%*lise de determi%ada situa#$oR atravHs da "ual observaMse
uma realidadeR te%doMse por objetivo a determi%a#$o dos aspectos e fe%Pme%os
co%siderados esse%ciaisR e5clui%doMse todos os aspectos co%siderados irreleva%tes.X
E a partir de problemas simples como determinar o raio de um c#rculo demonstra
como o problema pode ser modelado em termos de objetos com caractersticas e funes
interagindo entre si, modela as classes que representam estes objetos e apresenta sua
respectiva implementao em Java.
Os conceitos chave so demonstrados na medida em que so teis para resolver
problemas mais complexos e sub sees complementares se encarregam de
determinados aspectos da linguagem Java como operadores matemticos e detalhes de
sintaxe, sem necessariamente, serem parte da soluo dos problemas apresentados.
Ao final de cada seo, apresentado um resumo dos conceitos e conhecimentos
trabalhados, uma lista de exerccios, geralmente extensa e abrangente, nos casos que
apresentem contedo prtico, diversos exerccios resolvidos tambm so fornecidos.
Por fim, ressalta-se que todos os cdigos construdos por Boratti so em lngua
portuguesa e sempre que apresentam recursos novos, so comentados com descries
detalhadas do seu comportamento.
4.1.1.2 Po#tos %ortes
9.1.1.1.1 Opera!"es de Abstra!)o
No captulo introdutrio da metodologia, Boratti traz o conceito de operaes de
abstrao que mostram como o ser humano mentali3a, organi3a e modela o mundo ao
seu redor. Estas operaes so teis na medida em que definem uma taxionomia para
as interaes entre as entidades no mundo real e podem ser representadas diretamente
atravs de cdigo orientado a objetos. Logo, o processo de analisar uma interao entre
entidades no mundo real e o cdigo que deve ser construdo para resolver problemas
envolvendo esta interao pode ser mais adequadamente identificado.
As Operaes de abstrao so demonstradas utilizando representaes parecidas
com o utilizado pelo diagrama de classes da UML para as classes identificadas.
Segue abaixo as quatro operaes de abstrao:
4lassifica!)o : 0nstancia!)o: Classificao corresponde a determinar um
conjunto de caractersticas de um determinado grupo de objetos de modo a
classific-los em uma categoria ou classe. nstanciao o processo inverso, no
qual exemplos (instncias) de determinadas categorias so ressaltados. Por
exemplo a Classe 4arro e nstncia carro vermelho do os;
Beneraliza!)o e Especializa!)o: Generalizao ocorre quando determinamos
caractersticas comuns a conjunto de classes e assim, criamos uma classe mais
genrica. Especializao o inverso, quando a partir de uma classe genrica,
determinamos classes especialistas. Por exemplo, a classe genrica 1dico
poderia ser especializada em 5bstetra, )ediatra e 5rnitolaringologista;
Agrega!)o : 7ecomposi!)o: A Agregao caracterizada pela relao de "
composto por entre duas classes. A decomposio quando dizemos que um
objeto " parte de outro objeto. Por exemplo, a classe 4arro composta por
objetos da classe 1otor. J um objeto da classe Motor parte de um objeto da
classe 4arro;
Associa!)o: Ocorre quando dois objetos possuem algum tipo de ligao entre si
mas podem existir independentemente do outro, Por exemplo, na relao que
ocorre entre objetos das classes Professor e Aluno.
9.1.1.1.1 Processo de ,odelagem
Boratti coloca que o modelo de resoluo de um problema, ou seja, o software, o
resultado de um processo de abstrao que em orientao a objetos corresponde
identificao dos objetos com suas caractersticas e funes e a respectiva modelagem
das suas classes.
9.1.1.1.8 /epresenta!)o Hisal de Ob+etos
Aps a identificao dos objetos necessrio represent-los visualmente pelo
projetista de software. A visualizao proposta por Boratti utiliza um crculo para
representar um objeto com um texto dentro representando o identificador deste objeto.
*lustrao &E' A (onstruo do modelo. @onte' Doratti
Quando um objeto composto por outros objetos estes so representados como crculos
dentro do crculo maior. No caso de atributos simples de um objeto como nmeros e
textos, estes objetos so representados com um retngulo.
9.1.1.1.9 0mplementa!)o de Ob+etos
Recordo, como estuante do professor saas Boratti, que fortaleceu muito o meu
aprendizado no momento que compreendi que cada objeto ocupava um espao na
memria e que uma varivel, na verdade, era um apontador para este espao na
memria.
Este aspecto da implementao de objetos tratada na seo 4.8 onde Boratti
coloca que a identifica,+o de um obeto constitui'se em uma posi,+o na memria
6portanto, uma vari!vel7 "ue arma3ena o endere,o do espa,o de memria ocupado por
a"uele obeto.
Para exemplificar este conceito o seguinte cdigo apresentado:
Ponto umPonto, outroPonto; // Um ponto contm um atributo inteiro x e um y
umPonto = new Ponto();
outroPonto = new Ponto();
outroPonto.redefina_se(2., !.); // este mtodo a"tera os #a"ores de x e y
E a partir do cdigo acima, utilizada uma adaptao da visualizao de objetos
demonstrando que as variveis so apenas apontadores para os objetos:
*lustrao &&' Fepresentao :isual de Ob#etos. @onte' Doratti. Adaptado por Galu (aminha
9.1.1.1.; /epresenta!)o Hisal de m ArraG
Arranjos, como so chamados os tradicionais Arrays por Boratti so "elementos que
armazenam vrios valores. Para facilitar o ensino foi criado um modelo visual para o uso
de arrays. Para exemplificar o modelo usaremos o seguinte cdigo:
int$% numeros = new int$&%;
int cont = 2;
numeros$'% = !(;
numeros$cont% = ');
numeros$cont*'% = numeros$cont% + ';
O cdigo acima apresentaria a seguinte representao visual:
4.1.1.3 Po#tos %racos
9.1.1.8.1 0n&cio pelo m#todo main com Jello Lorld
Aps os dois primeiros captulos de introduo, com uma explicao detalhada e
abrangente sobre orientao a objetos e o processo de modelagem, o primeiro programa
mostrado tem como problema "mprimir uma linha na tela e o seguinte cdigo-fonte:
*lustrao &,' *mplementao de Ob#etos. @onte'
Doratti. Adaptado por Galu (aminha
*lustrao &2' Fepresentao :isual de um
ArraC. @onte' Doratti. adaptado por Galu
(aminha
pub"ic c"ass Pro,rama'
-
//.ec"ara/0o do mtodo main
pub"ic static #oid main(1trin,$% parametro)
-
1ystem.out.print"n(2Primeiro Pro,rama34);
5
5
O programa que resolve este problema no envolve a criao de nenhum objeto, e
o nico mtodo chamado um mtodo acessado atravs de um atributo esttico da
classe System, usando notao de ponto.
E isto feito dentro do mtodo main, um mtodo esttico que exige como
parmetro um array de strings, contedos que somente sero trabalhado nos captulos
sete e oito.
evidente que esta abordagem se torna necessria na medida em que Boratti, por
no adotar nenhuma ferramenta que suporte a execuo de cdigo sem a criao do
mtodo main, no tem sada a no ser iniciar por ele.
Esta abordagem porm, no interessante pois a primeira poro de cdigo que o
estudante enxerga algo absolutamente incompreensvel para ele, devido a grande
quantidade de conceitos envolvidos (Kolling e Rosemberg).
9.1.1.8.1 Primeiro o cdigo* depois o conceito
Em diversos exemplos, certas regras de sintaxe so apresentadas, cujos conceitos
envolvidos somente so trabalhados em sees ou captulos posteriores.
Um exemplo a primeira classe com a qual os alunos tem contato. A classe
4#rculo, apresentada como o terceiro trecho de cdigo com o qual os estudantes tem
contato.
pub"ic c"ass 6ircu"o
-
//.ec"ara/0o do atributo
protected doub"e raio;
//.ec"ara/0o dos mtodos
pub"ic 6ircu"o()
-
raio = .;
5
pub"ic doub"e fornece7rea()
-
doub"e area;
area = !.'(')8raio8raio;
return area;
5
pub"ic #oid receba9a"or:aio(doub"e #:aio)
-
raio = #:aio;
5
5
Esta classe apresenta mais de 10 conceitos: comentrios, declarao de atributos,
tipagem de variveis, declarao de mtodo com retorno, declarao de mtodo sem
retorno, declarao de um construtor, assinatura de classe, parmetros, atribuies,
operaes matemticas e uso de modificadores de acesso.
A maioria destes conceitos s sero trabalhados posteriormente, por exemplo,
atribuies sero detalhadas no captulo 4 enquanto modificadores de acesso somente
sero vistos no captulo 5.
Percebe-se que esta abordagem tem como inteno demonstrar a modelagem
completa de uma classe adequadamente escrita para resolver um problema. sto fica
claro pelo uso de modificadores de acesso desde o incio, com a inteno de evitar que
estudantes declarem atributos como pblicos.
sto causa, porm, uma sobrecarga de conceitos apresentados sem a devida
possibilidade do estudante experimentar cada um deles e suas consequncias para o
programa, sem saber qual a funo de cada palavra-chave.
9.1.1.8.8 ,#todos estticos desde o in&cio
Para complementar o exemplo do captulo 3 no qual preciso determinar a rea de
um crculo a partir do seu raio, apresentada uma classe chamada nterface (que no
tem nenhuma relao com o conceito de interfaces em Java) responsvel por solicitar ao
usurio um nmero que ir representar o raio do crculo.
O principal mtodo desta classe chamado "pegaValorRaio contm 4 linhas,
conforme apresentado abaixo:
;
1trin, #a"or<ido;
#a"or<ido = =optionPane.s>ow?mput.ia"o,(2.i,ite o raio@ 4);
doub"e #a"or = .oub"e.parse.oub"e(#a"or<ido);
return #a"or;
;
O problema deste mtodo que as principais instrues so mtodos estticos de
classes especficos da biblioteca do Java. sso nada ensina sobre orientao a objetos,
sendo necessrios apenas para que o programa seja minimamente interessante.
Construes como esta so utilizadas em outros pontos como no captulo 4 com o
uso do mtodo s"rt da classe 1ath, responsvel por recuperar a raiz quadrada de um
nmero.
A grande crtica a esta abordagem que mtodos e atributos estticos so
ensinados apenas no captulo 8, de modo que o estudante precisa simplesmente ignorar
o fato da sintaxe ser diferente de outros objetos com os quais ele trabalha.
O autor j presenciou, como professor, estudantes que foram ensinados sob
metodologias parecidas chamando mtodos diretamente das classes, sem diferenciar se
um mtodo era ou no esttico.
4.1.1.4 +o#clus"o
A metodologia se mostra muito interessante ao tornar claro para o estudante o
processo de construo de um software, a sua respectiva modelagem de objetos e
classes e as diversas representaes visuais do programa.
Tambm se mostra interessante a forma de abordar os conceitos sempre que
possvel a partir de problemas do mundo real. Observa-se porm que a complexidade dos
problemas tratados muito pequena como por exemplo, calcular a mdia de um grupo de
alunos ou determinar a rea de um crculo.
Um dos motivos para o uso de exemplos triviais a dificuldade em utilizar recursos
avanados de programao em funo da complexidade destes recursos conforme
apresentado pela linguagem Java. De forma mais clara isto visto na modelagem da
classe nterface que para recuperar um valor digitado pelo usurio precisa de mtodos
estticos logo no incio da metodologia.
Este ponto ressalta que alguns dos pontos fracos observados na metodologia
poderiam ser melhor trabalhados com o apoio de um ferramental adequado como um
editor que no exigisse a criao de um mtodo main para executar cdigo ou uma
ferramenta que permitisse executar mtodos diretamente dos objetos.
9.1.1 7avid 6. Barnes e ,ic$ael MNlling
"Partindo de Objetos em Java. Esta a primeira frase do livro-texto para a
metodologia. A metodologia utiliza o ambiente de programao BlueJ e possui como
algumas de suas linhas guia:
Fma abordagem iterativa: A partir do uso do padro "Early Bird, documentado na
seo 2.4 os principais conceitos so apresentados primeiro de uma forma
simplificada para que um determinado problema seja resolvido. Posteriormente no
curso, os mesmos conceitos so retomados segundo outro ponto de vista e o
conhecimento aprofundado;
(em completa cobertra da lingagem: em funo do foco do livro ser em POO,
detalhes especficos da linguagem java no so abordados a menos que sejam
necessrios para a resoluo de um determinado problema;
Abordagem baseada em pro+eto: ao invs de introduzir uma nova construo e
ento fornecer exerccios para aplicar a construo aprendida, primeiro fornecido
um objetivo e um problema. A anlise do problema determina o que ser
necessrio e ento, os recursos da linguagem e os conceitos so apresentados;
(eqencia dos conceitos em vez de constr!"es de lingagem: prefervel,
sempre que existe conflito entre trabalhar construes de linguagem ou os
conceitos, trabalhar os conceitos e o mnimo possvel das construes de
linguagem que auxiliem a implementar o conceito.
A metodologia est organizada em duas partes: 1) Fundamentos da Orientao a
Objetos e 2) Estruturas de aplicao. Na primeira parte so abordados os conceitos
bsicos como classes, objetos, mtodos, etc. Na segunda, conceitos importantes para o
desenvolvimento de aplicaes e reuso como herana, polimorfismo e interfaces so
abordados.
O livro-texto da metodologia possui 13 captulos, sendo os 7 primeiros reservados
para a primeira parte e os seis ltimos para a segunda. O ltimo captulo reservado para
um estudo de caso de uma aplicao de maior porte.
Segue abaixo descrio dos exemplos e contedos trabalhados em cada captulo:
'aptulo E5emplos de !rojetos +ese%volvidos !ri%cipais 'o%ceitos
abordados
2ap?tu0o 1
Objetos e
'lasses
+ese%-os simples de alumas formas
eomHtricasS
E5emplo utili7a%do um objetos do projeto
a%terior para dese%-ar uma fiuraS
E5emplo simples com classes de alu%os "ue
participam de aulas de laborat=rio.
ObjetosS
'lassesS
MHtodosS
!arUmetros.
2ap?tu0o 2
E%te%de%do as
defi%i#0es de
classe
3imula#$o uma m*"ui%a de ve%der bil-etes
de tremS
/rma7e%ame%to de i%forma#0es sobre um
livro.
'amposS
'o%strutoresS
!arUmetrosS
MHtodos de acesso e
modificadoresS
/tribui#$o e i%stru#$o
co%dicio%al.
2ap?tu0o 3
>%tera#$o e%tre
objetos
>mpleme%ta#$o de um mostrador de um
rel=io diital com -oras e mi%utosS
<ma simula#$o simples de um correio
eletrP%ico.
/bstra#$oS
Modulari7a#$oS
'ria#$o de objetoS
+iaramas de objetoS
c-amadas de mHtodoS
depuradores.
2ap?tu0o '
/rupa%do
objetos
>mpleme%ta#$o simples de um bloco de
a%ota#0es eletrP%icoS
<m sistema de leil$oS
<m a%alisador de reistros de acesso a uma
p*i%a :eb.
>teradoresS
'ole#0esS
/rra@sS
8oops.
2ap?tu0o *
'omportame%to
mais sofisticado
>mpleme%ta#$o de um prorama de di*loo
semel-a%te ao Eli7a utili7ado para for%ecer um
Wsuporte tHc%icoX para clie%tesS
/%ima#$o r*fica com bolas "ue "uicam.
<tili7a%do classes de
bibliotecaS
8e%do a docume%ta#$oS
Escreve%do a
docume%ta#$o.
2ap?tu0o .
Objetos bemM
comportados
Est*ios i%iciais de um di*rio "ue arma7e%a
compromissosS
>mpleme%ta#$o de uma calculadora de mesaS
1estesS
+epura#$oS
/utoma#$o de testes.
2ap?tu0o 7
+esi% de
'lasses
<m joo iterativo de ave%tura baseado em
te5toS
+esi% baseado %a
respo%sabilidadeS
/coplame%toS
'oes$oS
Fefatora#$o.
2ap?tu0o 1
Vera%#a
<m ba%co de dados de '+s e vdeosS Vera%#aS
3ubtipaemS
3ubstitui#$oS
Bari*veis polim=rficas.
2ap?tu0o @
'o%ti%ua#$o do joo iterativo do captulo &S !olimorfismo de mHtodoS
Mais sobre
-era%#a
'o%ti%ua#$o do ba%co de dados de '+s e
vdeos do captulo (S
tipo est*tico e di%UmicoS
3obrescri#$oS
Escol-a di%Umica de
mHtodo.
2ap?tu0o 10
1Hc%icas
adicio%ais de
abstra#$o
<ma simula#$o de ca#adorMca#a co%-ecida como
WraposaMcoel-oX.
'lasses abstratasS
>%terfaces.
2ap?tu0o 11
1ratame%to de
erros
>mpleme%ta#$o de um cat*loo de e%dere#osS !rorama#$o defe%sivaS
8a%#ame%to e tratame%to
de e5ce#$oS
>%forme de erroS
!rocessame%to de
ar"uivos simples.
2ap?tu0o 12
+esi% de
aplica#0es
3istema de reserva de luares em um ci%emaS +escobri%do classesS
'art0es 'F'S
!adr0esS
+esi% de i%terfaces.
2ap?tu0o 13
Estudo de caso
'ombi%a#$o de um sistema de reserva de
t*5is com um sistema de ere%ciame%to e de
simula#$o.
+ese%volvime%to i%teral
de aplica#$o.
%abela 8' (onte3dos e e!emplos da metodologia de Darnes
4.1.2.1 $iretri;es
De forma complementar, para que obtenha uma boa compreenso da metodologia,
segue-se o trabalho de KLLNG e ROSENBERG, que, a partir da experincia com o
desenvolvimento de diversos cursos utilizando o ambiente BlueJ elencaram oito diretrizes
adequadas para o ensino de programao orientada a objetos:
9.1.1.1.1 Ob+etos primeiro
consenso entre muitos professores de Programao Orientada a Objetos que
melhor ensinar a criar e manipular objetos antes de qualquer outra coisa. Esta atividade,
porm, difcil nos ambientes tradicionais, pois para executar o mtodo de um objeto
preciso:
1. Uma classe contendo um mtodo main esttico com um arra. de Strings como
parmetro;
2. Uso de uma varivel tipada;
3. Uma atribuio de um objeto uma varivel;
4. A instanciao de um objeto;
5. A sintaxe de chamada de um mtodo;
6. A visualizao do resultado da chamada do mtodo.
Com BlueJ a primeira atividade abrir um projeto existente e criar objetos a partir
das classes, em seguida, os estudantes podem chamar mtodos destes objetos e
visualizar seu estado. Tudo isso sem escrever nenhuma linha de cdigo.
9.1.1.1.1 5)o inicie com ma tela em branco.
Um dos maiores erros em programao OO iniciar com uma tela vazia.
Escrever projetos OO envolvem a definio de quais classes o programa ter e
quais mtodos cada classe dever ter, e este, um exerccio extremamente difcil para
estudantes novatos.
Ao invs disso, pode-se iniciar com pequenas modificaes e adies em cdigo
existente.
9.1.1.1.8 .eia cdigo
Muitos estudantes so forados a comear a programar sem terem lido
praticamente nenhum cdigo. sso no acontece em nenhuma outra disciplina.
Estudantes aprendem mais quando tem acesso a cdigos bem escritos que eles
possam utilizar como base para os seus projetos.
9.1.1.1.9 Fse pro+etos grandes
Programas curtos dificilmente deixam claro as vantagens em se utilizar Orientao
a Objetos.
A sugesto que sejam utilizados programas bem escritos com um nmero maior
de classes e mtodos que permitam aos estudantes compreenderem as vantagens do
uso de OO, assimilarem a importncia de um cdigo limpo e comentado, pratiquem a
leitura de cdigo e estudem a interao entre as classes.
9.1.1.1.; 5)o inicie com o m#todo main
O mtodo main exige muitos conceitos para ser compreendido. O ideal que os
estudantes s sejam apresentados a ele aps terem se envolvido com os conceitos
principais como a criao de objetos e chamada de mtodos.
9.1.1.1.< 5)o se OJello CorldP
Para se fazer um "Hello World em Java preciso iniciar do mtodo main, que por
sua vez significa: 1) construir uma classe da qual nenhum objeto criado. 2) construir um
mtodo (o main) que no age sobre um objeto.
sso no Programao OO e fere outras diretrizes j apresentadas.
9.1.1.1.= ,ostre a estrtra do programa
Classes e seus relacionamentos so muito importantes. essencial que os
estudantes possam visualizar a estrutura dos programas nos quais trabalham.
O BlueJ exibe a estrutura do programa em um diagrama semelhante ao diagrama
de classes da UML. Quando o BlueJ no estiver sendo utilizado importante que o
professor encontre meios de mostrar claramente esta estrutura.
9.1.1.1.> 3en$a cidado com a interface do srio
importante ensinar uma forma de realizar a interface com o usurio para
fornecimento de parmetros e para a impresso de resultados do software.
Em Java, podemos fazer isso com 8pplets, com a AP de entrada e sada ou com
frameworks GU como o 9wing.
Porm, nenhuma destas alternativas simples o suficiente para ser utilizada em
cursos introdutrios. So sugeridos ento, dois caminhos para lidar com este problema:
1. Especfico no BlueJ, so as janelas pop-up que solicitam ao usurio os valores
para os parmetros dos mtodos e as janelas que exibem os retornos dos
mtodos;
2. Um projeto maior com classes que encapsulem a interface com o usurio e que os
estudantes apenas precisem aprender a utilizar seus mtodos.
4.1.2.2 .#9lise geral do :todo
No sem mrito que esta metodologia est sendo adotada por um grande nmero
de instrutores de programao orientada a objetos em todo o mundo. Sem dvida que a
metodologia trouxe grandes contribuies e dentre os pontos fortes podemos destacar: 1)
a abordagem baseada em projetos que permite ao estudante aprender a resolver
problemas; 2) a priorizao do conceito antes das estruturas de construo da linguagem,
dando sentido ao que o aluno est aprendendo; 3) O rico acervo de projetos trabalhados,
trazendo diversas dimenses importantes da computao; 4) O uso do Bluej que permite
que se inicie a tarefa de ensinar diretamente atravs de objetos e escrita de seus
mtodos.
Alm destes, na prtica com a metodologia foi possvel perceber que os estudantes
que em geral possuem mais dificuldade com programao se sentiam mais seguros e
confiantes ao verem os objetos na tela e poder manipul-los. visvel que muitos alunos
no se sentem a vontade quando se deparam diariamente nas aulas de programao
com telas repletas de cdigo-fonte, sem outras representaes visuais do trabalho que ele
est realizando.
4.1.2.3 Po#tos fracos
Apesar do inmero sucesso, importante ressaltar algumas dificuldades geradas
pela metodologia. Estas dificuldades foram percebidas em prtica do autor com a mesma
e atravs da pesquisa de Xinogalos.
9.1.1.8.1 Qnfase nas t#cnicas de visaliza!)o e manipla!)o direta do Ble6
Em funo do BlueJ disponibilizar interface grfica para instanciao de objetos e
chamada de mtodos, alguns alunos ficam por demais "acomodados a esta maneira de
trabalhar, o que gera dificuldades com instanciao de objetos e chamadas de mtodos
direto do cdigo-fonte. sso porque no BlueJ, a diferena entre a forma de manter objetos
em variveis e chamar mtodos destas variveis (lustrao 14) muito diferente da
forma como a mesma ao feita no BlueJ (lustrao 15).
*lustrao &7' Ob#etos na bancada de ob#etos Hem
vermelhoI e chamada de mtodo de um ob#eto
*lustrao &5' *nstanciao de ob#eto e chamada de
mtodo em cdigo
Outra crtica a que mtodos que possuem retorno so chamados da mesma
forma que mtodos sem retorno. Esta questo causa confuso ao tentar passar
para os estudantes que mtodos com retorno devem ser sempre atribudos a uma
varivel. Mtodos com retorno, no BlueJ, imprimem o valor retornado na tela.
Quando, posteriormente o autor trabalhou mtodos com retorno sem o uso do
BlueJ, uma das dvidas apresentas foi questionando se, quando se retornava um
valor, este valor no deveria ser impresso na tela?
9.1.1.8.1 Qnfase em pro+etos existentes
Em funo da utilizao de projetos com uma boa quantidade de cdigo pronto, a
dificuldade em iniciar projetos do zero se mostrou muito maior. Alm disso, mtodos get e
set, bem como construtores, so geralmente fornecidos pelos projetos e os alunos
raramente os implementam.
9.1.1.8.8 Ensino posterior do m#todo ai#E
O ensino apenas no final do curso do mtodo main exige que os alunos utilizem
apenas o BlueJ para testar cdigo, potencializando as dificuldades comentadas no item 1.
4.1.2.4 +o#clus"o
Percebe-se que o BlueJ apesar de suas inmeras qualidades, no pode ser visto
como a nica soluo, pois, em concordncia com Xinogalos, "mais de uma ferramenta
necessrio para suportar as diferentes necessidades cognitivas no ensino de
programao, de modo que esta metodologia apesar de sua qualidade, pode ser
complementada com atividades e prticas em ambientes profissionais de
desenvolvimento.
9.1.8 Brno 2ei+ et al
A metodologia apresentada por Feij visa segundo ele prprio apresentar os
conceitos e os bons h!bitos da arte de programar. Seu material aborda no apenas a
programao orientada a objetos mas tambm a programao estruturada e brevemente
a programao guiada a eventos.
Apesar do foco no ser orientao a objetos, sua metodologia e o framework que o
acompanha serviram de base e inspirao para a metodologia descrita no captulo trs e
consequentemente, base e inspirao para o presente trabalho.
O livro-texto da metodologia apresenta 9 captulos que segundo sugesto da
metodologia poderia ser trabalhado em uma disciplina de 64 h/aula em 16 aulas de 4
h/aula cada, conforme modelo abaixo:
Semana 1: apresentao e captulo 1;
Semana 2: Captulo 2;
Semana 3: Captulo 3;
Semana 4 a 6: Captulo 4;
Semana 7: Captulo 5;
Semana 8: Captulo 6;
Semanas 9 a 11: Captulo 7;
Semanas 12 a 14: Captulo 8;
Semanas 15 e 16: Captulo 9;
Segue abaixo organizao dos captulos, exemplos e contedos apresentados.
'aptulo E5emplos de !rojetos +ese%volvidos !ri%cipais 'o%ceitos
abordados
2ap?tu0o 1
'omputadores
?enhum e!emplo trabalhado0
2ap?tu0o 2
Bari*veisR 1ipos
de +ados e
E5press0es
!e"ue%os e5emplos did*ticos demo%stra%do
os co%ceitosS
'ome%t*riosS
Bari*veisS
E%trada de +adosS
3ada de +adosS
E5press0esS
2ap?tu0o 3
'o%troles de
9lu5o por
coma%dos de
sele#$o
!e"ue%os e5emplos did*ticos demo%stra%do
os co%ceitosS
estruturas de tomada de
decis$o ifMelse e s:itc-.
2ap?tu0o '
MHtodos e
3olu#0es
!e"ue%os e5emplos did*ticos demo%stra%do
os co%ceitosS
MHtodosS
MHtodos Est*ticosS
3obrecara de mHtodosS
8oops.
2ap?tu0o *
+ados
compostos como
vetores
!e"ue%os e5emplos did*ticos demo%stra%do
os co%ceitosS
Betores u%idime%sio%aisS
Betores bidime%sio%aisS
2ap?tu0o .
<sa%do mais
objetos e classes
simples
Joo similar ao tradicio%al !o%S 'lassesS
3tri%sS
8eitura e rava#$o de
ar"uivosS
'lasses abstratas e
i%terfaces.
2ap?tu0o 7
'lassesR objetosR
-era%#a
'o%ti%ua#$o do joo similar ao tradicio%al
!o%S
'lasses e objetosS
Modificador staticS
E%capsulame%toS
Vera%#aS
'lasses abstratas.
2ap?tu0o 1
!rorama#$o
Gr*fica
Joo especfico dese%volvido para o livro e
co%ti%ua#$o do joo similar ao tradicio%al po%S
'o%ceitos de joos 2+S
2ap?tu0o @
!rorama#$o
uiada a eve%tos
Joo especfico dese%volvido para o livro. 'aptura de dados do
teclado e do mouse.
%abela 9' (onte3dos e e!mplos da metodologia de @ei#
4.1.3.1 .#9lise geral do :todo
A proposta muito abrangente, segundo Feij, pretende-se do captulo 1 ao 6
trabalhar com programao estruturada, no 7 e no 8 orientao a objetos e no captulo 9,
programao guiada a eventos.
Em funo at mesmo deste grande conjunto de paradigmas, o livro no oferece
um bom suporte para os conceitos de orientao a objetos, os exemplos so poucos,
muito limitados e as explicaes dos conceitos no acompanham boas referncias
visuais.
Em contrapartida, oferece um rico material sobre como unir conceitos de jogos em
duas dimenses com tcnicas de programao, tanto estruturada quanto orientada a
objetos.
Um grande mrito est no uso do framework para trabalhar classes abstratas e
interfaces, pois, para que o aluno possa criar uma fase, deve implementar uma interface e
para criar um objeto no jogo, deve estender uma classe abstrata que j fornece os
atributos de posicionamento de um objeto na tela.
9.1.9 (telios Rinogalos
Ao fim de 4 anos de avaliaes e modificaes, Xinogalos chegou a uma
metodologia que utiliza trs ambientes de programao: objectKarel (Satratzemi ), BlueJ e
Jcreator (um ambiente profissional de programao simplificado). O material didtico
utilizado baseado no material que acompanha o objectKarel e na metodologia de
Barnes com o BlueJ, descrita na seo 2.4.2.
O curso estruturado por Xinogalos possui 12 lies de 4 horas aula semanais, duas
tericas e duas em laboratrio. As aulas so divididas na seguinte estrutura:
<u0a Temas tra(a0Aados <m(iente
1 Ob#etos, classes, heranaN objetoR co%stru#$o e i%iciali7a#$o de um
objetoR me%sae%s2mHtodosR atributos e comportame%tos de um
objetoR -era%#aR superclasseR subclasseR -ierar"uia de -era%#aR
diarama de classe <M8
ob#ectGarel
2 Jerana em v+rios nveis, polimorfismo e sobrescrita. ob#ectGarel
3 1efinio de (lasseN camposR co%strutoresR mHtodos de acessoR
mHtodos modificadoresR estrutura de retor%oR parUmetrosR escopo de
vari*veisR estruturas co%dicio%ais.
DlueB
4 *nterao com ob#etoN abstra#$oR modulari7a#$oR objetos cria%do
objetosR mCltiplos co%strutoresR diarama de classeR diarama de
objetosR tipos primitivosR tipos de objetosR c-amadas de mHtodos
i%ter%os e e5ter%os.
DlueB
5 4todos est+ticosN mHtodos de i%stU%cia vs mHtodos de classeR o
mHtodo mai%R e5ecu#$o sem o )lueJR b@te codeR Java Birtual
Mac-i%e.
DlueB, B(reator
4R & Agrupando ob#etos em coleKesN 'ole#0es de tama%-o fle5vel
?/rra@8istAR cole#0es de tama%-o fi5o ?arra@sAR classes e%HricasR
iteradoresR loops ?:-ileR forR forMeac-A.
DlueB, B(reator
( Usando bibliotecas de classeN 'lasses padr$o do JavaR leitura de
docume%ta#$oR i%terface vs impleme%ta#$o de uma classeR e5plora%do
e usa%do classes ?Vas-MapR Fa%domR Vas-3etAR modificadores de
acesso ?publicR privateAR i%forma#0es esco%didasR vari*veis de classe
?est*ticasA.
DlueB, B(reator
, )ro#eto de (lassesN acoplame%toR coes$oR e%capsulame%toR duplica#$o
de c=dioR projeto diriido Q respo%sabilidadeR reuso de c=dio.
DlueB, B(reator
1. 4elhorando a estrutura com heranaN -ierar"uia de classesR
superclasseR subclasseR co%strutor da superclasseR subtCping$R
substitui#$oR autobo!ing$.
DlueB, B(reator
11 )olimorfismo, sobrescrita' tipos di%Umicos e est*ticosR busca
di%Umica de mHtodoR superR acesso proteido.
DlueB, B(reator
12 (lasses abstratas e *nterface. DlueB, B(reator
%abela <' (onte3dos e ambiente de programao na metodologia de Linogalos
4.1.4.1 O <so de abie#tes de prograa!"o
A escolha do ambiente de programao que ser utilizado difcil e importante.
Ambientes profissionais so inadequados para trabalhar aspectos introdutrios,
ambientes de micro-mundos como o objectKarel so interessantes para trabalhar
conceitos mas no uma linguagem especfica, j ambientes educacionais so
interessantes para transferir os conceitos para uma determinada linguagem, porm, sem
a transio para uma DE profissional os estudantes ficam condicionados s
caractersticas especficas das ferramentas educacionais.
A dinmica de 4 anos no curso apresentado mostrou que mais de uma ferramenta
necessria para que os diversos aspectos cognitivos possam ser trabalhados. Esta
dinmica gerou as seguintes diretrizes sobre o uso de ambientes de programao:
Fse m ambiente de microSmndo para ma introd!)o crta dos principais
aspectos de programa!)o orientada a ob+etos: o ambiente escolhido deve
suportar o ensino dos principais conceitos de OO sem preocupaes com a
sintaxe. O conceito de objeto deixa de ser abstrato pois agora os objetos podem
ser manipulados, os estudantes tambm ganham confiana na sua capacidade de
programao;
Fse m ambiente edcacional para apresentar os conceitos vistos no microS
mndo para a sa implementa!)o em 6ava: a transio para um ambiente
educacional mais suave do que para um ambiente profissional pois ambientes
especficos para o ensino eliminam a complexidade permitindo que os estuantes
possam se dedicar a sintaxe dos conceitos fundamentais. essencial que estes
ambientes tenham ferramentas de visualizao e manipulao direta de classes e
objetos e permitam a invocao dinmica de mtodos. O tempo com o um
ambiente educacional no deve se estender muito para evitar falsas percepes,
principalmente sobre os aspectos dinmicos da Orientao a Objetos.
Fse m ambiente profissional para preparSlos para o ftroE inevitvel que
esta transio acontea, a maior preocupao deve ser quando realiz-la. Neste
curso foi decidido realizar esta transio na quinta lio dando nfase para as
caractersticas destes ambientes que poderiam ajudar os estudantes como 1)
Viso das classes em rvore; 2) Navegao rpida dentro de uma classe; 3) auto-
completar de cdigo; 4) o destaque de sintaxe. Ao realizar esta transio os
estudantes se sentem mais confiantes com o seu conhecimento.
4.1.4.2 $iretri;es para o E#si#o das li!(es propostas
As lies so baseadas como j mencionado no livro-texto que acompanha o
BlueJ., seguindo suas principais diretrizes.
Concomitantemente, utilizada a abordagem "modelo primeiro de Bennedsen e
Caspersen (2004) conforme documentada na seo 4.1.5.
Abaixo, seguem as diretrizes relacionadas a cada lio trabalhada. As lies
utilizam projetos do livro-texto que acompanha o BlueJ.
9.1.9.1.1 .i!)o 1E Ob+etos* classes e $eran!a no ob+ectMarel
Na primeira lio, so apresentados os conceitos bsicos de classe, objeto e
mtodo. Os estudantes iniciam criando um novo objeto da classe "Robo com a ajuda da
interface Grfica (lustrao 16), depois, devem utilizar os mtodos do rob (como
"mover, "virar para a esquerda, etc) para realizar tarefas especficas como completar um
determinado percurso.
O programa vai sendo construdo a partir de botes onde o estudante seleciona os
mtodos que ir executar, criando uma sequencia que no objectKarel chamada de
tarefa (lustrao 17).
*lustrao &8' *nstanciao de um ob#eto no ob#ectGarel com a a#uda da interface gr+fica
Aps, podem executar o programa e observar qual o comportamento do rob para
cada mtodo e o que isso significa na linguagem dos robs (por exemplo, virar para a
esquerda significa mudar a frente do rob em 90 graus negativos.), estas informaes so
fornecidas na forma de texto no rodap do ambiente (lustrao 18).
Em uma segunda atividade, problemas mais complexos so apresentados de modo
que necessrio utilizar herana para a criao de uma nova classe com mtodos que
iro facilitar a realizao da tarefa.
Xinogalos ressalta que essencial durante o processo explicar que cada mtodo
muda o estado interno do objeto (mesmo que os alunos no possam ver as variveis de
instncia). Tambm importante utilizar exemplos que utilizem vrios objetos da mesma
*lustrao &9' (riao de uma tarefa a partir dos mtodos de um
robM
*lustrao &<' E!ecuo de um programa. N direita a visuali6ao do robM, N esquerda a lista de
tarefas e abai!o a descrio do que ocorre no interior do mtodo em e!ecuo.
classe para evitar que os estudantes considerem os dois conceitos como a mesma coisa.
9.1.9.1.1 .i!)o 1E Jeran!a em vrios n&veis* polimorfismo e sobrescrita.
A didtica se mantm a mesma e agora os problemas apresentados exigem a
construo de uma hierarquia de classes. Tambm so utilizados exemplos que
trabalhem a necessidade da sobrescrita de mtodos como por exemplo, robs mais
velozes que no mtodo "move, andam mais rpido que os robs utilizados nos exerccios
anteriores. O polimorfismo, tambm trabalhado com cuidado por se uma das principais
dificuldades observadas nos estudantes.
9.1.9.1.8 .i!)o 8E 7efini!)o de classe
A definio de uma classe apresentada aos alunos utilizando o exemplo de uma
mquina de vender bilhetes (TicketMachine no livro texto que acompanha o BlueJ). Os
estudantes criam instncias desta classe, chamam seus mtodos, observam a
implementao em Java da classe e por fim, tem a oportunidade de realizar pequenas
modificaes nela.
No primeiro ano do curso foram identificadas as dificuldades mais comuns
referentes ao ensino do paradigma de POO, importante que o instrutor esteja atento a
elas desde o incio do ensino para reforar o entendimento destes tpicos. Segue abaixo
as principais dificuldades encontradas:
A compreenso e uso de mltiplos construtores;
O uso do this de difcil compreenso e em geral os estudantes o evitam;
A inicializao dos campos no construtor;
Costumam declarar o tipo de retorno de mtodos "set;
Tentam acessar valores de campos privados diretamente, sem o uso de mtodos
get;
Outras dificuldades so atribudas mais especificamente ao uso dos recursos do
BlueJ, so elas:
5)o declara!)o do tipo das variveis qe armazenam os ob+etos. sso pode
ser trabalhado dando nfase na janela de instanciao de um objeto varivel
onde o objeto ser armazenado e o tipo desta varivel. O BlueJ j apresenta estas
informaes, porm, comumente passam despercebidas.
4$amada de m#todos. Frequentemente mtodos com retorno so chamados da
mesma maneira que mtodos void. No BlueJ, possvel chamar ambos os tipos de
mtodos da mesma forma, de modo qque o resultado de mtodos com retorno
frequentemente interpretado como "impresso do valor na tela;
Por fim, essencial verificar se os conceitos aprendidos no objectKarel foram
efetivamente transportados para o Java. sso pode ser feito solicitando que os estudantes
representem em Java os modelos dos robs criados nas ltimas duas lies.
9.1.9.1.9 .i!)o 9E 0ntera!)o entre ob+etos
Estudantes so apresentados aos conceitos de modularizao, abstrao e
interao entre objetos utilizando o exemplo de um relgio digital com duas classes, uma
representando um relgio digital e outra que representa um mostrador de dois nmeros. O
Relgio composto por dois mostradores, um para as horas e outro para os minutos.
As dificuldades observadas nesta etapa foram:
Os estudantes no tem certeza onde devem inicializar os campos;
No sabem como manipular este novo tipo;
Tem dificuldades com a notao de ponto.
Para estas dificuldades recomendado o uso de diagramas de objetos e atividades
onde os estudantes identifiquem chamadas de mtodo internas e externas;
9.1.9.1.; .i!ao ;E O m#todo main
nesta aula apresentado como executar cdigo Java sem o :lueJ. Uma introduo
sobre uso de mtodos estticos versus mtodos de instncia feita utilizando o :lueJ.
Aps, os estudantes criam seu prprio mtodo main no Jcreator para um projeto
que eles j tenham conhecimento como o TicketMachine.
Esta lio tambm aproveitada para falar sobre compilao, "byte code e
mquina virtual.
As principais dificuldades encontradas foram:
Uso de parmetros formais da chamado do construtor (Ex: neC 4lasse%3Gpe param'T );
O tipo das variveis dos objetos so esquecidos;
Esquecem argumentos em chamadas de mtodos;
Esquecem os parnteses em chamadas de mtodos sem argumentos;
Para lidar com estas questes sugerido:
Atividades que so de alguma forma "silenciadas pelo BlueJ como o tipo das
variveis que armazenam os objetos so demonstrados utilizando as caixas de
dilogo do BlueJ e seu paralelo em sintaxe Java;
Exemplos e tarefas so realizados em cima de projetos j conhecidos;
Um programa contendo erros comuns apresentado e os estudantes so
ensinados a reconhecer os erros e trat-los.
9.1.9.1.< .i!)o <E Agrpando ob+etos em m ArraG.ist
Uso de colees em programao comum e necessrio mesmo em programas de
baixa complexidade. Alguns autores j colocam o uso de ArrayList como prioridade sobre
Arrays por ser uma estrutura mais adequada para representar listas continuas.
Durante os quatro anos de curso os autores identificaram diversas dificuldades
envolvendo o uso de ArrayList`s e chegaram s seguintes concluses:
1. O uso dos diagramas de objetos so fundamentais desde o incio do projeto. Os
estudantes so estimulados a criar um diagrama de objetos para um dado
programa e simular operaes de remoo e incluso no diagrama de objetos.
2. So oferecidos exerccios para com cdigo incompleto para que os estudantes
preencham os espaos vazios com determinados comandos.
3. Aps, so construdos programas do zero.
9.1.9.1.= .i!)o =E Agrpando ob+etos em cole!"es %ArraG.ist vs ArraG'
O uso de Arrays apresentado e o mesmo projeto no qual foi trabalhado o uso de
ArrayList agora modificado para funcionar com Arrays.
9.1.9.1.> .i!)o >E Ftilizando bibliotecas de classe
Nesta aula os estudantes so apresentados documentao das classes Java,
com nfase nas classes String e HashMap. A aula tambm apresenta a estrutura de
pacotes.
9.1.9.1.@ .i!)o @E Pro+eto de 4lasses
O projeto de classes algo difcil de ser realizado e a simples exposio dos
principais conceitos tericos para uma soluo bem projetada no causa um grande
impacto no aprendizado. importante que os estudantes entendam atravs de uma
aplicao os problemas de um mau projeto de classes.
A maior dificuldade encontrada foi a limitao do tempo que impossibilita o
desenvolvimento de uma soluo completa, na qual, o entendimento dos principais
conceitos de um bom projeto de classes seria trabalhado.
9.1.9.1.1A .i!)o 1AE ,el$orando a estrtra com Jeran!a
O projeto desta lio uma biblioteca multimdia de CD's e DVD`s. A primeira
verso do projeto no usa herana, de modo que muito cdigo acaba sendo duplicado.
Quando os alunos so perguntados sobre como resolver o problema, eles se
recordam da apresentao feita com o objectKarel e facilmente compreendem o uso de
herana.
A maior dificuldade percebida a chamada do construtor da superclasse atravs da
subclasse. Uma sugesto utilizar o debugger para ver a execuo do cdigo passo a
passo e os campos sendo preenchidos.
9.1.9.1.11 .i!)o 11E Polimorfismo e (obrescrita
Atravs de uma continuao do exemplo visto anteriormente, realizado um
exemplo onde cada subclasse sobrescreve o comportamento de um mtodo na classe
pai.
9.1.9.1.11 .i!)o 11E 4lasses abstratas e 0nterface
Nesta aula o uso de classes abstratas e interface so utilizados para expandir a
simulao de um ambiente com raposas e coelhos para conter diversos tipos de animais.
Percebeu-se que no difcil para os estudantes compreenderem o conceito e o
implementarem, porm, demonstram grande dificuldade em perceber quando uma classe
deve ser declarada como concreta, abstrata ou interface.
4.1.4.3 .#9lise Geral do :todo
As duas principais concluses de Xinogalos so 1) a necessidade de avaliao
continua dos cursos de modo a validar as pesquisas e dar continuidade aos processos de
melhoria e que 2) mais de uma ferramenta necessrio para suportar as diferentes
necessidades cognitivas no ensino de programao.
O artigo tambm clarifica como integrar alguns dos diferentes tipos de ambientes
de ensino de programao desenvolvidos at o momento de modo a garantir um ensino
eficaz ao mesmo tempo em que prepara os estudantes para o mercado.
muito rica a descrio detalhada de todas as aulas realizadas e das principais
dificuldades em cada tema, de modo que o instrutor, sabendo de antemo as dificuldades
mais comuns, pode atac-las logo no incio das atividades.
A partir do material apresentado no foi possvel identificar pontos fracos na
metodologia proposta por Xinogalos, na medida em que copia os pontos fortes da
metodologia de Barnes e adiciona ela o aspecto de modelagem e uso de ferramentas
profissionais de programao.
9.1.; ,ic$ael 4aspersen
Caspersen prope um mtodo baseado muito no fornecimento aos estudantes do
modelo conceitual, antes de iniciar a codificao, bem como em um processo sistemtico
de transformao de um modelo para cdigo-fonte.
Segundo Caspersem, modelagem conceitual a definio de caractersticas de
orientao a objetos e prov uma perspectiva unificada e uma aproximao pedaggica
com foco sobre o aspecto de modelagem da orientao a objetos.
Esta viso contempla um dos papis da linguagens de programao segundo
Knudsen & Madsen (1988, citado por Caspersen) que justamente o uso da linguagem
de programao para expressar conceitos e fenmenos.
Para que seja possvel a sistematizao do processo de desenvolvimento, foram
identificadas tcnicas para a criao sistemtica de programas orientado a objetos em 4
diferentes nveis de abstrao:
Domnio do Problema U modelagem conceital: Criar um diagrama de classes
UML do domnio do problema, focando nas classes e nas relaes entre as
classes;
Domnio do problema U modelagem dinVmica: Criar um diagrama de estados
UML que captura a dinmica do comportamento;
Modelagem conceitual e modelagem dinmica U modelagem da especifica!)o:
Propriedades especficas e distribuio das responsabilidades entre as classes;
Modelagem da especificao implementa!)o:
0mplementa!)o das estrtras entre as classes: cria um esqueleto para o
programa utilizando padres de cdigo para as diferentes relaes entre as
classes;
0mplementa!)o da estrtra interna das classes: Cria estruturas de classe
descrevendo os elementos internos que tem de ser estabelecidos antes e
depois de cada chamada de mtodo;
0mplementa!)o dos m#todos: Uso padres de algoritmo para os problemas
tradicionais de algoritmo por exemplo varredura e busca.
A modelagem do software pode ser vista em diferentes nveis de detalhes
caracterizados por diferentes degraus de formalidade:
um um modelo conceitual informal descrevendo os conceitos chave do domnio do
problema e suas relaes;
um modelo de classes mais detalhado dando uma viso mais detalhada da
soluo;
e a implementao em uma linguagem orientada a objetos.
Este foco na perspectiva da modelagem conceitual, enfatiza que orientao a
objetos no meramente um conjunto de solues e tecnologias, mas uma forma de
entender, descrever e comunicar sobre o domnio de um problema e uma implementao
concreta deste domnio.
4.1.2.1 .s etapas da etodologias
Na primeira metade do curso, de forma grosseira, o foco paralelamente sobre o
entendimento e uso de um modelo conceitual como um "blue print para programao
real. Na segunda metade do curso o foco primrio na qualidade interna do software.
Codificar e entender o modelo o conceitual so feitos de mos dadas, de forma que
o modelo sempre vem primeiro, trazendo o cdigo-fonte. A ntroduo s diferentes
construes da linguagem so subordinadas s necessidades da implementao de um
dado conceito do modelo conceitual.
*lustrao &=' (riao sistem+tica de um programa orientado a ob#etos
4.1.2.2 O %rae&or' co#ceitual
So trabalhados com nfase trs modelos conceituais bsicos: 1) associao, 2)
composio e 3) especializao. O ponto de partida uma classe, propriedades desta
classe e o relacionamento entre a classe e os objetos criados a partir dela. Uma das
propriedades de uma classe pode ser uma associao com outra classe;
consequentemente o prximo tpico associao. sto correlacionado com o fato que
uma associao (referncia) o tipo mais comum de estrutura entre classes (objetos).
Composio um caso especial de associao, sendo trabalhado logo em seguida
A ltima estrutura a ser coberta especializao. Especializao faz a ponte com a
segunda metade do curso onde o foco a qualidade do projeto onde especializao
frequentemente utilizada como um modo de obter projetos mais flexveis.
4.1.2.3 O i#cio
Os estudantes iniciam por aprenderem os conceitos bsicos de classes e objetos
bem como noes bsicas de modelagem atravs de um diagrama de classes
semelhante ao diagrama da UML. Depois de terem usado classes e objetos, ns nos
voltamos para uma viso interna e comeamos a escrever classes; ns fazemos isso
introduzindo o primeiro padro de cdigo: mplementao de uma classe.
4.1.2.4 Padr(es de +)digo
Um padro de cdigo uma descrio geral da implementao de um elemento do
framework conceitual.
Atravs de um nmero progressivo de exemplos ns mostramos que uma
associao uma propriedade de uma classe, uma classe tem mais que uma associao
e uma relao dinmica.
O ensino inicia com associaes recursivas de cardinalidade 1. Para poder
implementar estas associaes, os estudantes precisam aprender sobre referncias e o
valor null, bem como a chamada de mtodos entre diferentes objetos.
A partir de diversos exemplos (1) e dos conceitos trabalhados construda uma
abstrao (2) que corresponde ao modelo conceitual trabalhado. Para esta abstrao,
apresentado um padro de codificao (3) que permite transform-la em cdigo fonte
funcional.
Este mesmo processo utilizado para composio e especializao, dando
confiana e instrumentos para que os estudantes passem a identificar e implementar os
mesmos conceitos em seus projetos
4.1.2.2 Outros elee#tos da etodologia
Ns usamos BlueJ como ferramenta de programao.
O foco em um modo sistemtico de programar. sto implica em trs coisas 2)
alguns exemplos so exibidos para os estudantes; 2) uso explcito da UML e 3) um foco
no processo de programao.
Uma vez que ns percebemos a importncia do foco no processo de programao
e no apenas no produto final, ns passamos a usar muita codificao ao vivo. O
propsito disto mostrar aos estudantes como um profissional de programao ataca os
problemas.
4.1.2.3 .#9lise Geral da Metodologia
As duas grades contribuies de Caspersen so o processo sistemtico de
desenvolvimento de software e o framework conceitual e suas respectivas abstraes. Em
contrapartida, no possvel avaliar outros aspectos da metodologia apenas com o
material consultado.
4.3 $iretri;es para o E#si#o de OO
A partir dos trabalhos acima, foram identificadas e definidas 10 diretrizes base para
guiar o presente trabalho, so elas:
9.8.1 Princ&pios baseados na prtica com o Ble6
A metodologia deve seguir todos os princpios e diretrizes que servem como base
para a metodologia de Barnes que so:
Abordagem iterativa;
Abordagem baseada em projetos;
Sequencia dos conceitos em vez de construes de linguagem;
Sem cobertura completa da linguagem.
Alm destes quatro princpios, so norteadoras tambm as 8 diretrizes
apresentadas por KLLNG e ROSENBERG, documentadas na seo 4.1.2.1
9.8.1 /epresenta!"es visais para todas as estrtras e conceitos
trabal$ados
Todos os exemplos desenvolvidos e apresentados aos estudantes devem vir
acompanhados de suas respectivas visualizaes. Estas visualizaes devem utilizar a
UML como base, com nfase para o diagrama de classes e diagrama de objetos.
Estruturas de controle e repetio podem se valar de diagramas de atividades e
estruturas que no possuam uma representao adequada na UML, como o caso dos
arrays, pode ser utilizada uma outra representao especfica, como por exemplo, a
sugerida por Boratti e documentada na seo 4.2.1.2.5.
9.8.8 Opera!"es de abstra!)o e frameCorD conceital
Sempre que um novo conceito de relao entre dois ou mais objetos deve ser
acompanhado de sua respectiva operao de abstrao segundo Boratti e do modelo
conceitual conforme Caspersen. Estas representaes devem ser utilizadas com
frequncia de modo que os estudantes aprendam a enxerg-las nos problemas com
facilidade.
9.8.9 Ambiente edcacional W Ambiente profissional
At a metade do curso, os estudantes devem ser guiados do ambiente educacional
BlueJ para um ambiente de desenvolvimento profissional de preferncia do instrutor.
necessrio entretanto, que pelo menos uma aula seja dedicada exclusivamente ao uso do
novo ambiente, com exerccios e prticas que demonstrem as vantagens do novo
ambiente.
9.8.; Processo sistemtico de desenvolvimento
Desde as primeiras aulas os estudantes devem ser guiados sobre as etapas do
processo de desenvolvimento de software, atravs de mtodos sistemticos de
desenvolvimento e tambm "live coding, que corresponde ao professor resolver
problemas e tarefas de codificao ao vivo diante dos estudantes (Caspersen).
9.8.< A partir do zero.
To logo os estudantes adquiram confiana com um determinado conjunto de
recursos e conceitos, estes devem ser colocados em situaes de resoluo de
problemas a partir de uma tela vazia ou de um projeto em branco. nclusive o processo de
buscar classes de bibliotecas utilizadas em outros projetos importante para o
desenvolvimento profissional.
9.8.= 3odos os recrsos sados devem ser explicados
Todos os recursos utilizados pelos alunos devem ser previamente trabalhados,
mesmo que de forma breve. Desde modo, importante que sejam evitados o uso de
mtodos e/ou atributos estticos logo no incio do projeto sem uma devida explicao.
Esse tipo de abordagem pode causar confuso sobre a possibilidade de chamar um
mtodo diretamente da classe ou do objeto.
9.8.> Estilo de 4digoSfonte
Estudantes geralmente no se preocupam com nomes de classes e variveis, bem
como edentao. importante que desde o incio o estilo do cdigo seja padronizado pois
conforme observaes do autor, os prprios estudantes acabam por se perderem em
cdigos mal formatados e variveis e classes sem diferenciao de maisculas e
minsculas.
9.8.@ .ista abrangente de exerc&cios e desafios
Cada aula deve vir acompanhada de uma lista abrangente de atividades em nveis
crescentes de dificuldade para estimular s estudantes e permitir a aplicao dos conceitos
vistos em contextos diferentes.
9.8.1A 3odos os exemplos devem envolver +ogos
Todos os exemplos desta metodologia devem envolver jogos, de preferncia, com
regras amplamente conhecidas, de modo que no seja necessrio investir tempo para
explicar regras de um jogo ao invs de programao orientada a objetos. sto tambm
objetiva criar um acervo de atividades cujos estudantes geralmente se motivam a
desenvolver.
; 2rameCorD 6ava para 6ogos 17
Esta seo apresentar os conceitos bsicos de construo de um framework e o
desenvolvimento do framework utilizado no tutorial.
2.1 .quisi!"o do +o#-ecie#to de $o#io
Para realizar o estudo do domnio, sero utilizados os oito jogos produzidos na
primeira verso da disciplina conforme apresentado anteriormente. Os temas dos jogos
foram escolhidos livremente e classes foram desenvolvidas pelo professor para auxiliar o
desenvolvimento.
A primeira verso da disciplina j utilizava um framework base, de modo que muito
se aprendeu sobre o domnio e as necessidades de jogos 2D a partir do desenvolvimento
dos exemplos e das necessidades dos estudantes.
2.2 Modelage do %rae&or'=
Para a definio do framework foi utilizado o processo conforme demonstrado por
Silva (2000).
;.1.1 Beneraliza!)o
As principais generalidades dos projetos pesquisados foram identificadas e
agrupadas em pacotes lgicos. Algumas das generalidades apresentadas eram
solicitaes dos estudantes que no puderam ser atendidas na primeira verso do curso:
Pacote Entrada:
Uso de informaes de teclas pressionadas do teclado;
Uso de informaes do mouse;
Captao de informaes do usurio com campos de texto como nome,
nmeros, etc.
Pacote (a&da:
Desenho de formas geomtricas e imagens em janelas;
Criao de animaes a partir de uma sequencia de imagens;
Execuo e pausa de sons;
Pacote ,otor:
Criao de cenrios complexos;
Coliso com o cenrio;
Coliso com outros objetos;
Troca de fases;
Uso dos mesmos objetos em fases distintas;
Comunicao entre objetos de uma mesma fase;
Mapa de navegao de fases;
Menus de opes;
Pacote Fsica:
Acelerao, gravidade, fora e vetores.
;.1.1 2lexibiliza!)o
De forma geral, existem os seguintes pontos de flexibilizao nos jogos
pesquisados.
2ases: Os jogos apresentaram fases onde jogadores realizam uma luta, saltam
sobre objetos, atiram uns nos outros baseado em turnos e outros. Na verso
anterior do framework, o conceito de fase tambm era utilizado para mapas de
navegao em um cenrio e menus de opes.
Ob+etos do 6ogo: Objetos de um jogo so todos os elementos que exercem
influncia direta sobre o jogo como inimigos, o prprio jogador, obstculos na tela,
itens para recuperao de vida, fora ou energia, pontos de chegada, tiros, golpes
especiais, etc.
4enrios: Muitos cenrios apresentavam necessidades especificas como exibir ou
esconder determinados blocos como por exemplo para liberar uma passagem
secreta, plataformas mveis e outros.
;.1.8 ,odelagem das 4lasses
Apresentar aqui propostas de diagramas de classes para as questes de
generalizao e flexibilizao acima aplicando metapadres, padres de projeto e
princpios de Orientao a Objetos.
%(e!)o ainda incompleta* a ser desenvolvida aps o relatrio 1'
2.3>alida!"o
%(e!)o ainda incompleta* a ser desenvolvida aps o relatrio 1'
2.4 $ocue#ta!"o
%(e!)o ainda incompleta* a ser desenvolvida aps o relatrio 1'
< ,etodologia de Ensino
%(e!)o ainda incompleta* a ser desenvolvida aps o relatrio 1. (egem
abaixo apenas algmas ideias ainda imatras'
A Metodologia proposta baseada em projetos. Os estudantes so guiados para
nveis cada vez mais complexos de conceitos OO em trs mdulos distintos, produzindo
ao final de cada mdulo um produto adequado ao nvel de complexidade trabalhado:
1. Ob+etos Primeiro: Na primeira etapa, realizada no ambiente BlueJ, os estudantes
devem criar um objeto da classe Jogo2D e executar os mtodos deste objeto. Em
um segundo momento, os estudantes criam diversas instncias de uma mesma
classe pertencente a um projeto previamente desenvolvido de modo a
compreender o conceito de instncia, de variveis e mtodos de instncia. Ao final,
os estudantes criam a sua primeira classe que ir representar um jogo simples.
2. ,iniSgame: Nesta etapa, os estudantes desenvolvem seu primeiro jogo ainda
utilizando o BlueJ, construindo seus prprios objetos de jogo, aprendendo a usar
os mtodos que envolvem receber informaes do teclado e a desenhar imagens e
animaes. Esta seo dever utilizar o livro de receitas do framework. Este
projeto deve envolver pelo menos um classe para o jogo e mais duas classes para
representar objetos do jogo;
3. 6ogo17: Desenvolvimento de um jogo 2D com mais de uma fase e uso de
recursos avanados de orientao a objetos como polimorfismo, herana e classes
interface. Esta etapa ir usar a documentao detalhada do framework e deve ser
desenvolvida em um ambiente profissional de programao. Este projeto deve
possuir no menos que trs fases e 5 objetos de jogo diferentes.
Segue detalhamento de cada mdulo da metodologia.
3.1 M)dulo 1= Objetos Prieiro
Classe representando um jogo no BlueJ
2ar&a Aor6ria terica 3 -oras2aulas
2ar&a Aor6ria pr6tica 4 -oras2aula
#roduto <ma 'lasse Feprese%ta%do um Joo
=o"os 2onceitos $$ Classe; mtodo; varivel de instncia / atributo; objetos /
instncias; parmetros; construtores; abstrao;
<m(iente de #ro&ramao )lueJ
3.2 M)dulo 2= Mi#i?Gae
Tutorial apresentando um jogo bsico.
2ar&a Aor6ria terica K -oras2aulas
2ar&a Aor6ria pr6tica 2K -oras2aula
#roduto <m joo co%te%do pelo me%os 3 classes
=o"os 2onceitos $$ Encapsulamento; composio; coeso; design de
responsabilidade.
<m(iente de #ro&ramao )lueJ

3.3 M)dulo 3= Jogo 2$
Tutorial apresentando um jogo mais avanado com recursos como polimorfismo...
2ar&a Aor6ria terica Y -oras2aulas
2ar&a Aor6ria pr6tica 2Y -oras2aula
#roduto <m Joo com pelo me%os 3 fases e 5 classes represe%ta%do objetos
do joo.
2onceitos $$ Herana; composio; classes abstratas; classes interface;
polimorfismo / variveis polimrficas; mtodos sobrescritos;
modificador static; tratamento exceo;
<m(iente de #ro&ramao /mbie%te profissio%al
3.4 .valia!"o da Metodologia
O ideal que a metodologia seja avaliada a partir de sua aplicao em um
semestre de programao orientada a objetos em cursos introdutrio. Em funo do
tempo disponvel para o TCC no foi possvel validar a metodologia at o momento,
sendo esta atividade, uma recomendao para trabalhos futuros.
= 4oncls)o
Concluso...
6.1 4rabal-os %uturos
Ensino de Biologia, Qumica, Fsica, etc atravs da programao com o auxlio de
frameworks...
> Bibliografia
8.1 @ivros
Feij, Bruno e Clua, Esteban. 0ntrod!)o X ciIncia da compta!)o com +ogos: aprendendo a programar
com entretenimento. Rio de Janeiro. Elsevier, 2010.
BARNES, David J.; KOLLNG, Michael. Programa!)o Orientada a Ob+etos com 6ava: Uma introduo
prtica usando o BlueJ. So Paulo: Pearson Prentice Hall, 2004. 368 pg.
KLLNG, Michael. 0ntrodction to Programming Cit$ BreenfootE Object-Oriented Programming in Java
With Games and Simulations. Upper Saddle River, New Jersey: Prentice Hall, 2010. 190 p.
BORATT, saias Camilo. Programa!)o Orientada a Ob+etos com 6ava. Florianpolis: Visual Books, 2007.
308 p.
8.2 .rtigos e $ocue#tos acadAicos
KAY, Alan. 7r. Alan MaG on t$e ,eaning of OOb+ectSOriented ProgrammingP. Email de 23 de julho de
2003. Disponvel em: <http://www.purl.org/stefan_ram/pub/doc_kay_oop_en>. Acesso em: 24 jun. 2012.
PROULX, Viera K.(2010). ,sic in 0ntrodctorG Ob+ect Oriented ProgrammingE Music and sound library
for a novice Java programmer.. Constructionism 2010. Disponvel em:
<http://www.ccs.neu.edu/home/vkp/Papers/Music-Constructionism2010.pdf>. Acesso em: 20 jun. 2012.
PROULX, Viera K. (2009).3$e PedagogG of Program 7esignE Design Recipe throughout BOOTSTRAP,
TeachScheme!, ReachJava.. DDNFO 2009. Disponvel em:
<http://www.ccs.neu.edu/home/vkp/Papers/PPD-didinfo2009.pdf>. Acesso em: 20 jun. 2012.
PROULX, Viera K.(2003). Ob+ects 2rom t$e Beginning S Lit$ BF0sE nteractive GU-based labs for
introducing objects first.. TiCSE 2003. Disponvel em: <http://www.ccs.neu.edu/home/vkp/Papers/GUs-
iticse2002.pdf>. Acesso em: 20 jun. 2012.
CASPERSEN, M.E. e Christensen, H.B. (2008): 4(1E Betting (tartedE Reflections on the Teaching of
Programming, LNCS 4821, Springer-Verlag, 2008, pp. 130-141.
BENNEDSEN, J.B. e Caspersen, M.E. (2008): ,odelS7riven Programming: Reflections on the Teaching of
Programming, LNCS 4821, Springer-Verlag, 2008, pp. 116-129.
KLLNG, Michael e ROSENBERG, John. 2001. Bidelines for teac$ing ob+ect orientation Cit$ 6ava. n
Proceedings of the 6th annual conference on nnovation and technology in computer science education
(TiCSE '01). ACM, New York, NY, USA, 33-36. DO=10.1145/377435.377461
http://doi.acm.org/10.1145/377435.377461
XNOGALOS, Stelios (2009). Bidelines for 7esigning and 3eac$ing an Effective Ob+ectSOriented
7esign and Programming 4orse, Advanced Learning, Raquel Hijn-Neira (Ed.), SBN: 978-953-307-010-0,
nTech, Disponvel em: http://www.intechopen.com/books/advanced-learning/guidelines-for-designing-and-
teaching-an-effective-object-oriented-design-and-programming-course. Acesso em 20 de junho de 2012.
M. Satratzemi, and S. Xinogalos, and V. Dagdidelis. An environment for teaching object-
oriented programming: ObjectKarel. Proceedings of The 3rd IEEE International conference on
Adanced !earning Technologies "I#A!T $3), 3%&''3%3.
THE PEDAGOGCAL PATTERNS PROJECT (Org.).Pedagogical Patterns. Disponvel em:
<http://www.pedagogicalpatterns.org/>. Acesso em: 24 jun. 2012.
Clark, David; MacNish, Cara and Royle, Gordon F.. 6ava as a teac$ing langage S opportnities* pitfalls
and soltions, in Proceedings of the Third Autralasian Conference on Computer Science Education, ACM,
Brisbane, Australia, July 1998.
8.3 Bibliografia para c)digo?fo#te e ateriais did9ticos
dese#volvidos pelo autor
4digoSfonte
CAMNHA, Kalu. Exemplo 1: movimentando uma bola. Disponvel em:
<https://github.com/kaleucaminha/javaPlay2Examples/tree/master/src/exemplo1>. Acesso em: 24 jun. 2012.
CAMNHA, Kalu. Exemplo 1: um primeiro jogo com o framework javaPlay. Disponvel em:
<https://github.com/kaleucaminha/javaPlay2Examples/tree/master/src/exemplo2>. Acesso em: 24 jun. 2012.
CAMNHA, Kalu. Exemplo 8: jogo que acompanha o roteiro de 10 passos sobre o javaPlay. Disponvel em:
<https://github.com/kaleucaminha/javaPlay2Examples/tree/master/src/exemplo3>. Acesso em: 24 jun. 2012.
CAMNHA, Kalu. Berra Espacial. Disponvel em: <https://github.com/kaleucaminha/Guerra-Espacial>.
Acesso em: 24 jun. 2012.
CAMNHA, Kalu. Exemplo /G: Etapa 1. Disponvel em: <https://github.com/kaleucaminha/Ryu-Versus-
Vegeta/tree/master/src/ryuversusvegeta_2>. Acesso em: 24 jun. 2012.
CAMNHA, Kalu. Exemplo /G 1: Etapa 2. Disponvel em: <https://github.com/kaleucaminha/Ryu-Versus-
Vegeta/tree/master/src/ryuversusvegeta_3>. Acesso em: 24 jun. 2012.
CAMNHA, Kalu. Exemplo /G vs Hegeta. Disponvel em: <https://github.com/kaleucaminha/Ryu-Versus-
Vegeta/tree/master/src/ryuversusvegeta_final>. Acesso em: 24 jun. 2012.
,aterial didtico
CAMNHA, Kalu. 6avaPlaG em 1A passosE Tutorial para desenvolvimento de um jogo simples utilizando o
framework javaPlay. Disponvel em: <http://www.slideshare.net/kaleu/tutorial-1-javaplay-em-10-passos>.
Acesso em: 24 jun. 2012.
CAMNHA, Kalu. /evis)o 6ogos 17E Orientao a Objetos com Jogos 2D. Disponvel em:
<http://www.slideshare.net/kaleu/conceitos-de-oo-aplicados-ao-desenvolvimento-de-jogos-2d>. Acesso em:
24 jun. 2012.
Provas
CAMNHA, Kalu. Prova 1a. Disponvel em: <http://www.slideshare.net/kaleu/prova-2a>. Acesso em: 24 jun.
2012.
CAMNHA, Kalu. Prova 1b. Disponvel em: <http://www.slideshare.net/kaleu/prova-2b-2012>. Acesso em:
24 jun. 2012.
CAMNHA, Kalu. Prova 8b. Disponvel em: <http://www.slideshare.net/kaleu/prova-3a-2012>. Acesso em:
24 jun. 2012.
CAMNHA, Kalu. Prova 8b. Disponvel em: <http://www.slideshare.net/kaleu/prova-3b>. Acesso em: 24 jun.
2012.
CAMNHA, Kalu. Prova 9a. Disponvel em: <http://www.slideshare.net/kaleu/prova-4>. Acesso em: 24 jun.
2012.
CAMNHA, Kalu. Prova 9b. Disponvel em: <http://www.slideshare.net/kaleu/prova-4b>. Acesso em: 24 jun.
2012.
CAMNHA, Kalu. Prova de /evis)o. Disponvel em: <http://www.slideshare.net/kaleu/prova-de-reviso>.
Acesso em: 24 jun. 2012.
8.4 Bibliografia +o#sultada
Esta seo corresponde ao conjunto de materiais que no compe o ncleo do
trabalho, mas que contriburam, de forma menor, para a realizao deste trabalho.
6ava
ALVES, William Pereira. 6ava 1E Programao Multiplataforma. So Paulo: rica, 2006. 286 p.
MECENAS, van. 6ava 1 S 2ndamentos* (Cing e 67B4E Programao Multiplataforma. 2. ed. Rio de
Janeiro: rica, 2006. 306 p.
DETEL, Harvey; DETEL, Paul. 6ava 4omo Programar. 6. ed. So Paulo: Pearson Prentice Hall, 2005.
1100 p.
HORSTMANN, Cay S.; L., Gary Cornell. 4ore 6avaE Holme 0 K 2ndamentos. 7. ed. Rio de Janeiro: Alta
Books, 2005. 568 p.
HORSTMANN, Cay S.; L., Gary Cornell. 4ore 6avaE Holme 00 S /ecrsos Avan!ados. So Paulo:
Pearson Prentice Hall, 2003. 823 p.
?alidade de (oftCare
MARTN, Robert C.. 4digo .impoE Habilidades Prticas do Agile Software. So Paulo: Alta Books, 2009.
440 p.
KOSCANSK, Andr; SOARES, Michel Dos Santos. ?alidade de (oftCareE Aprenda as metodologias e
tcnicas mais modernas para o desenvolvimento de software. 2. ed. So Paulo: Novatec, 2007. 394 p.