Prólogo
- Sobre o
Greenfoot
Este tutorial é uma
introdução ao Mundo de Objetos do Greenfoot.
O Greenfoot é uma
ferramenta de software
concebida para permitir que iniciante adquira experiência com
programação orientada a objeto. Ele suporta o
desenvolvimento de aplicações gráficas
na
Linguagem de Programação Java™.
O Greenfoot foi concebido e
implementado na
Universidade de Kent, Inglaterra e na Universidade Deakin, Melbourne,
Austrália.
Mais
informação a respeito do Greenfoot
está disponível em www.greenfoot.org.
- Escopo e
audiência
Este tutorial é
dirigido para pessoas
que querem se familiarizar com o Greenfoot. Ele pretende ser breve,
porém completo e focar na funcionalidade do ambiente do
Greenfoot. Ele não tenta ensinar Java. Ele supõe
que o
leitor já conheça um pouco de Java ou que
está
buscando algum suporte enquanto trabalha com a segunda metade desse
tutorial.
Todas as atividade descritas
aqui
supõem
trabalhar com um cenário existente e discutir como usar e
fazer
modificações naquele cenário.
Usuários que querem
construir seus
próprios cenários ou produzir grandes
modificações em cenários existentes
devem ler
também o Manual do Programador do Greenfoot.
- Copyright,
licenciamento e redistribuição
O sistema do Greenfoot e este
tutorial
está disponível 'no estado', livre de encargos
para
qualquer um usar e redistribuir comercialmente. A desmontagem
deste sistema é proibida.
Nenhuma parte do sistema do
Greenfoot ou sua
documentação pode ser vendida ou
incluída em um
pacote que seja vendido sem a autorização escrita
dos
autores.
O copyright ©
do
Greenfoot pertence a Poul Henriksen e Michael Kölling.
Este tutorial foi traduzido para
o
português por Heródoto Bento-DeMello F.,
Universidade
Estadual do Centro-Oeste, Guarapuava, Paraná, Brasil.
Instalação
The
Greenfoot software can be downloaded from www.greenfoot.org.
Três diferentes
versões
estão disponíveis: uma para Windows, uma para
MacOS X e
uma para os demais sistemas.
Pré-requisitos
Você deve ter o Java 5
(conhecido como
JDK 1.5) ou posterior instalado no seu sistema para utilizar o
Greenfoot. Geralmente, atualizar a última versão
estável (não beta) da
liberação do
Java é recomendável. Se você
não tem o JDK
instalado, você pode baixá-lo no
endereço da SUN na
Internet em http://java.sun.com/j2se/.
Não baixe uma versão denominada "JRE" (Java
Runtime Environment) – o JRE não
é suficiente. Você precisa de uma
versão que é denominada JDK.
NO MacOS X, uma
versão
recente do J2SE está
pré-instalada – você mesmo
não precisa instalá-la.
- Instalando
no Windows
Para sistemas Microsoft
Windows, baixe a
versão Windows do instalador. Dê um duplo clique
no
arquivo instalador e siga as instruções. A
instalação segue um processo padrão de
instalação.
- Instalando
no Mac OS X
Para o Mac OS X, baixe a
versão Mac OS
do software. O arquivo de download está no
format zip. Seu
navegador deve descompactar automaticamente este arquivo para
você. Se isso não ocorrer, dê um duplo
clique no
arquivo zip para descompactá-lo.
A pasta resultante
contém a
aplicação Greenfoot e cenários
exemplificativos.
Ambos podem ser colocados em qualquer lugar que desejar. Uma
arrumação comum é colocar a
aplicação Greenfoot na pasta de Applications e os
'cenários' na pasta Documents.
- Instalando
em outros sistemas
O Instalador para todos os
outros
sistemas
é um arquivo executável jar. Você pode
executar o
instalador abrindo um linha de comando e digitando
java -jar greenfoot-installer-XX.jar
(one XX é o
número de
versão do arquivo de instalação). Rm
alguns
sistemas, um duplo clique no arquivo jar também pode
funcionar.
(Observe que este comando supõe que o comando 'java' esteja
no
caminho do seu comando. Caso contrário, instale e configure
o
java primeiro.)
- O cenário
WOMBATS
Este tutorial
utiliza dois
cenários, denominados 'wombats' e wombats2'. Eles
são
distribuídos juntos com este tutorial. Cada
cenário vai
aparecer em um pasta no seu sistema de arquivos.
Figura 1: O
cenário
Wombat no Greenfoot
Execução
- Abra um
projeto Greenfoot
Você pode ter aberto
este tutorial a
partir de uma aplicaçãoGreenfoot. Legal. Caso
contrário, então você precisa iniciar
o Greenfoot agora.
O processo de
instalação instalou
uma aplicação chamada 'greeenfoot'. Execute ela.
(Em
sistemas Linux e Unix, ‘greenfoot’é uma
shell script
executável.)
Assim que o Greenfoot
está executando e
se o cenário Wombats não abriu automaticamente,
selecione
'Open...' no menu 'Project' e selecione o cenário 'wombats'
a
partir dos cenários exemplificativos do Greenfoot.
A grande
área quadriculada que cobre a maioria da janela é
denominada "o
mundo". Como temos um
cenário aqui que tem a ver com wombats (veja Nota de Rodapé 1),
nós vemos um mundo wombat. No lado direito da janela
está o painel
das classes. Aqui
você pode ver todas as classes Java envolvidas no projeto.
As classes
“World” and
“Actor” estarão sempre lá
– elas
vêm com o sistema Greenfoot. As outras classes pertencem ao
cenário wombat e serão diferentes se
você utilizar
cenários diferentes.
Abaixo do mundo
estão os Controles
de Execução
(a área com os butões
‘Act’ e ‘Run’ e cursor).
- Pesquise
sobre o cenário
No canto direito superior da
janela está
um botão rotulado "Project Information". Na maioria dos
cenários, quando você clica neste
botão, vai exibir
alguma informação relativa ao cenário.
Esta
informação tipicamente vai lhe dizer sobre o
propósito do cenário, como executá-lo,
o que
você pode fazer com ele e talvez algumas sugestões
sobre
como você mesmo poderia modificá-lo.
- Coloque
objetos no mundo
Nós agora vamos
colocar
alguns objetos no mundo.
Clique com o botão
direito (no Mac: Control-click)
na classe Wombat no painel de classe. Você verá um
menu de
contexto. Selecione 'New Wombat()'. Aí, clique em qualquer
lugar
no mundo. Você acabou de criar um wombat (em termos do Java:
um
objeto) e o colocou no mundo.
Wombats comem folhas, assim
vamos
colocar
também algumas folhas no mundo. Clique com o
botão
direito na classe Leaf e coloque a folha.
Existe um atalho para colocar
vários
objetos de forma um pouco mais rápida: clique pressionando
simultaneamente a tecla Shift no mundo. Certifique-se de que a classe
Leaf esteja selecionada, então libere a tecla Shift e clique
no
mundo várias vezes. Você adicionará um
objeto da
classe selecionada a cada clique.
- Torne ativos os objetos
Clique no botão 'Act'
nos controles de
execução. Cada objeto agora
age – isto
é: cada objeto faz o que quer que queira fazer.
O que os objetos querem fazer
depende de como eles estão definidos
– we’ll
get to that a little later. No nosso exemplo, folhas são
definidas para não fazer nada, ao passo que wombats andam
para
frente. Se você não fez isso, ponha dois wombats
no mundo
e aperte Act, de novo. Ambos vão se movimentar.
Wombats também gostam
de comer folhas. Se acontecer deles irem em
direção a uma folha, eles a comem.
- Execute um
cenário
Clique o botão 'Run'.
Isso é
equivalente a cllicar no botão Act repetidamente, muito
rapidamente. Você vai notar que o botão Run se
transforma
em um botão 'Pause'. Clicando-o, interrompe-se a
demonstração inteira.
O cursos próximo aos
botões Act e
Run configuram a velocidade. Clique Run e aí modifique a
posição do curso e você
entenderá que eu
quero dizer.
- Invoque
métodos diretamente
Em vez de executar todo o
cenário,
você também pode invocar métodos
isolados. Um
método é uma ação isolada
que um objeto
pode realizar.
Certifique-se que você
tem um wombat no
mundo e que o cenário não está sendo
executado.
Então, clique com o botão direito no wombat e
você
verá que objetos no mundo também tem um menu
contextual.
(Figura 2).
Figura 2: Um menu contextual
de
objeto
Você pode selecionar
quaisquer
métodos mostrados aqui para solicitar ao wombat para fazer
algo.
Tente, por exemplo, turnLeft(). Selecioná-lo no
menu diz
para o wombat virar para sua esquerda. Tente move().
Alguns métodos lhe
devolvem uma resposta. getLeavesEaten(), por exemplo, vai lhe dizer
quantas folhas este wombat já comeu até aqui.
Experimente-o.
Você também
vai notar um
método chamado 'act()'.Este método é
chamado toda
vez que você clicar o botão Act. Se você
quer que
apenas um objeto aja ao invés de todos os objetos no mundo,
você pode fazer isso invocando diretamente este
método de
objeto.
- Crie um novo mundo
Se você tem muitos
objetos que não
quer mais no mundo e você quer começar tudo de
novo,
existe uma opção fácil: descarte o
mundo e crie um
novo.
Faça isto clicando
com
o botão
direito na classe WombatWorld e selecione 'novo WombatWorld()'.
Você vai conseguir um novo mundo vazio. O velho mundo
é
descartado (e com ele todos os objetos que estiverem nele)–
você pode ter apenas um mundo de cada vez.
- Invoque um
método do mundo
Você tem visto que
objetos no mundo tem
métodos os quais você pode invocar
através de um
menu contextual. O mundo em si é também um objeto
com
métodos que você pode invocar.
Nós vimos na
seção
anterior como você pode criar novos mundos. Agora,
nós
queremos invocar um método do objeto mundo.
Acima do painel do mundo existe
um
título que apresenta o nome do mundo –
“WombatWorld” no nosso caso. Clique que o
botão
direito neste título e você verá o menu
do mundol.
Um dos métodos neste
menu é
'populate()'. Experimente-o. É um método que cria
diversas folhas e wombats e os coloca no mundo. Você pode
então executar o cenário.
Um outro método do
mundo é 'randomLeaves(int howMany)'.
Este método coloca algumas folhas no mundo em
posições aleatórias. Observe que este
método tem algumas palavras entre o parênteses
depois do
seu nome: int
howMany.
Isso se chama um 'parâmetro'. Ele significa que
você deve
especificar alguma informação adicional quando
invocar
este método. O termo 'int' nos diz que um número
inteiro
é esperado e 'quantos' sugere que você deve
especificar
quantas folhas você quer.
Invoque este
método. Uma caixa de
diálogo vai ser exibida para você digitar um valor
para
este parâmetro. Entre um número –
digamos: 12 – e clique Ok.
(Você pode notar, se
você contar,
que algumas vezes parece como se um número menor de folhas
tivesse sido criado. Isso é porque algumas folhas podem ter
a
mesma posição e estar superpostas uma sobre a
outra).
Okay, pode ser que
você
tenha conseguido wombats suficientes executando em círculos
indefinidamente –
vamos avançar para as coisas realmente interessantes:
programar
comportamento mais interessante para os seus próprios
wombats!
Programação
A partir daqui este tutorial
assume que os
leitores estejam familiarizados com o básico de
programação Java. Ele não foi
concebido como
primeira atividade para estudantes iniciantes.
- Modifique o
comportamento de um objeto
Você pode programar
seus
próprios
objetos – wombats ou qualquer outra coisa que desejar
–
escrevendo algum código Java para a classe do objeto. Isso
é o que faremos agora.
Dê um clique duplo na
classe Wombat no
painel de classes. Um editor de classes se abre e
você vai ver o código fonte Java para a
classe
Wombat.
A primeira coisa que
nós queremos fazer
é mudar o comportamento do wombat de forma tal que, quanto
ele
não pode ir para frente, gire em uma
direção
aleatória, ao invés de sempre virar para a
esquerda. Para
conseguir isso, nós primeiro incluímos um
método
'turnRandom()'. Inclua o seguinte método à classe
Wombat:
/**
* Vire para um direção
aleatória.
*/
public void turnRandom()
{
// gera um número
aleatório entre 0 e 3...
int turns =
Greenfoot.getRandomNumber(4);
// ...e vira para a esquerda este
número de vezes.
for(int i=0; i<turns; i++) {
turnLeft();
}
}
Então nós
modificamos 'act()'
para fazer uso do turnRandom. O método act atualmente
está assim:
public void act()
{
if(foundLeaf()) {
eatLeaf();
}
else if(canMove()) {
move();
}
else {
turnLeft();
}
}
Substitua a chamada para
'turnLeft()' no final por uma chamada para 'turnRandom()'.
Okay, nós fizemos.
Agora, vamos
experimentá-lo. Clique o botão 'Compila' no
editor. Se
algum erro for informaddo, conserte-o e compile novamente. Repita isso
até que a classe compile sem erros. Agora, você
já
pode fechar o editor.
- Compile o seu projeto
Antes de você poder
executar, você
deve compilar seu projeto. Você pode fazer isso a partir do
editor ou a partir da janela principal do Greenfoot.
Assim que você
compilou
com sucesso,
você pode criar os objetos de novo. A
compilação
(se bem sucedida) automaticamente instancia um mundo de
objetos.
- Modificando imagens
Existem duas maneiras de como
você pode
mudar a imagem de objetos: Você pode mudar a imagem de uma
classe, a qual vai mudar a imagem default de todos os objetos daquela
classe. Ou, um objeto pode mudar sua imagem via
programação, o que vai modificar apenas o objeto
individual. Cada objeto pode modificar sua imagem tantas vezes quantas
se desejar.
Para especificar a
imagem de uma classe,
selecione 'Set Image...' a partir do menu contextual da classe.
Você poderia tentar isso com a classe
Leaf – modifique
a imagem para, digamos, uma banana e o wombat vai colecionar bananas
(provavelmente isso não é o que o
zoológo local
poderia recomendar, mas isso é porque nós estamos
fazemos
uma simulação...). O Greenfoot tem uma biblioteca
de
imagens própria que você pode utilizar ou
você
poderia carregar suas próprias imagens na pasta 'images'
dentro
da pasta do cenário ('wombats') e aí
usá-las.
A segunda possibilidade
é deixar um
objeto modificar sua própria imagem como parte de
sua ação programada. Pode-se facilmente
fazer isso
invocando o método 'setImage' herdado de Actor. Existem
duas versões de 'setImage': uma espera um
parâmetro
do tipo GreenfootImage, a outra faz uso do nome de um arquivo (e
aí lê essse arquivo de imagem para um
GreenfootImage
e o configura).
Nós vamos utilizar a
variação que lê uma imagem de um
arquivo. A tarefa
que queremos realizar é que wombats não
apareçam
de cabeça para baixo, quando andarem para a esquerda. O
projeto
'wombats' já contém um arquivo chamado
'wombat-left.gif'
na sua subpasta 'images'. Este é um arquivo de imagens no
formato GIF que mostra uma imagem espelhada do wombat, que
nós
já vimos aqui: um wombat olhando para a esquerda.
Nós podemos modificar
a
imagem do wombat para a versão virada para a esquerda
escrevendo:
setImage("wombat-left.gif");
Nós vamos usar este
método quando
o wombat muda de direção. Para fazer isso
nós
precisamos editar o método 'setDirection(int Direction)' de
Wombat. Encontre-o no código fonte de Wombat.
Nós vamos acrescentar
algumas linhas
aqui para configurar a imagem correta e a rotação
correta, quando nós especificamos uma
direção.
Nós vamos usar a imagem 'wombat-left' quando o wombat rumar
para
oeste e norte e a imagem 'wombat' original quando estiver indo para
leste ou sul. Observe que a imagem 'wombat-left' é orientada
para leste por default – ela não precisa
ser girada quando rumamos para oeste.
Aqui está a nova
versão de 'setDirection':
/**
* Determina a direção para
onde
estamos olhando.
*/
public void setDirection(int direction)
{
this.direction = direction;
switch(direction) {
case SOUTH :
setImage("wombat.gif");
setRotation(90);
break;
case EAST :
setImage("wombat.gif");
setRotation(0);
break;
case NORTH :
setImage("wombat-left.gif");
setRotation(90);
break;
case WEST :
setImage("wombat-left.gif");
setRotation(0);
break;
default :
break;
}
}
Isso funciona
bastante bem do jeito que
está. Se isso fosse feito mais seriamente, nós
carregaríamos os objetos imagem a partir do arquivo apenas
uma
vez (no construtor) e as armazenaríamos em campos do tipo
GreenfootImage. Então, nós podemos usar dois
objetos
imagem para modificar a imagem repetidamente.
Talvez,
nós
pudéssemos agora acrescentar imagens separadas para
movimento ascendente e descendente –
nós deixamos isso para o leitor entusiasta.
- Pesquise sobre classes
do Greenfoot
Para provocar
mudanças
no comportamento
do objeto, você frequentemente precisa fazer uso de algumas
classes padrão do Greenfoot. O Greenfoot provê
quatro
classes importantes sobre as quais você deve
conhecer:
World, Actor, GreenfootImage e Greenfoot.
As duas primeiras são
visíveis na
interface e formam as superclasses o mundo e as classes de objetos do
cenário. GreenfootImage é usada para trabalhar
com
imagens e Greenfoot provê acesso à plataforma do
Greenfoot
em si.
O modo mais fácil de
aprender sobre
estas classes é examinar a
documentação online do
Greenfoot. Você encontra em
http://www.greenfoot.org/doc/javadoc/
A partir dessa
página, você pode ter acesso a uma
versão online das descrições de classe
do
Greenfoot (chamadas de "APIs do Greenfoot") e você pode
baixar a
descrição em um único documento
imprimível.
- Inspecione um objeto
Invoca a
função 'Inspect' do menu
de qualquer wombat no mundo. Isso possibilita que você
examine o
interior do objeto e inspecione o valor de seus campos. Isso pode ser
útil para o teste, enquanto as classes estiverem sendo
desenvolvidas.
Você vai perceber que
você vê
alguns campos definidos na classe Wombat (tal como'leavesEaten') e
algumas que não estão definidas no
Wombat. Os
campos adicionais (como x, y e rotação)
são
herdados de Actor e estão presentes em todos os objetos
Greenfoot.
Se um valor é exibido
como um
símbolo de seta, então o campo contém
um
referência para um outro objeto, o qual por sua vez pode ser
inspecionado (selecionando e clicando 'Inspect').
- Crie uma nova classe
Tá na hora de tornar
a
vida nos nossos
wombats um pouco mais desafiadora adicionando alguns
obstáculos
(Nós vamos fazer as rochas tão grandes que os
wombats
não poderão escalá-las).
Para fazer isso, nós
criamos uma nova
classe ator. Selecione 'New subclass' no menu contextual de Actor. Isso
vai criar uma nova classe como uma subclasse de Actor. Quando for
solicitado um nome de classe, digite 'Rock'. Você
também
será solicitado a selecionar uma imagem para a classe.
Você poderia encontrar
(o Google é
seu amigo!) ou construir (em um programa gráfico qualquer)
uma
imagem e colocá-la na pasta de 'imagens' do projeto, antes
de
criar a classe. Ela seria então apresentada neste
diálogo. Neste caso, nós já colocamos
um arquivo
de imagem denominado 'rock.gif' no projeto para você para
tornar
as coisas um pouco mais rápidas.
Selecione a imagem, clique Ok e
uma nova classe chamada Rock é criada.
Agora, abra o editor para esta
classe.
Você vai observar que um esqueleto fonte é gerado
automaticamente. De fato, nós não temos que
escrever
nenhum código agora. ( Rocks não tem qualquer
comportamento específico).
Feche o editor, compile e teste
(crie um objeto). Surpresa – suas rochas existe!
Agora, popule um pouco o
cenário e teste
os wombats (você poderia usar os métodos
'populate' e
'ramdonLeaves' do mundo e aí acrescentar algumas rochas
manualmente). Você vai perceber que você tem
rochas, mas os
wombats ainda através por dentro delas. Oh
sim – mais trabalho a fazer.
- Construa seus
próprios cenários
A
realização
de
modificações importantes ou cenários
completamente
novos não é contemplada neste tutorial. Se
você
quer fazer isso, você tem duas escolhas: Você
poderia
examinar cenários ou poderia ler o Manual do Programador do
Greenfoot.
(Observação:
De fato, você
não pode. Atualmente, o Manual do Programador ainda
não
existe... lamento).
Evidentemente, você
também precisa
ter a documentação de classes do Greenfoot (a API
do
Greenfoot) disponível, como discutimos acima.
A última coisa que
fazemos aqui, para
dar a você uma impressão rápida,
é fazer
mais uma modificação para impedir que wombats
atravessem
rochas.
Abra o editor para a classe
Wombat
e encontre o
método 'canMove'. Atualmente, este método
verifica se
nós estamos nos deparando com a borda do mundo.
Nós
precisamos modificá-lo de forma que ele também
retorne
false quando existe uma rocha em frente de nós.
substitua o último
comando return, que atualmente tem a forma
return true;
pelo seguinte:
List rocks = myWorld.getObjectsAt(x, y,
Rock.class);
if(rocks.isEmpty()) {
return true;
}
else {
return false;
}
Este fragmento de
código obtém
uma lista de todas as rochas da célula em frente a
nós.
Se essa lista está vazia, nós podemos ir adiante,
caso
contrário não podemos.
O projeto 'wombats2', que
está
incluído no download com este tutorial, inclui todas as
modificações discutidas aqui.
- E, agora?
Abra algum dos
cenários
que forama
instalados juntos com o seu software Greenfoot. Veja quais interessam a
você e aí veja como eles são feitos.
Vá pra o
endereço na Internet do Greenfoot e procure por mais
cenários.
Antes de tudo: converse com
outros
usuários Greenfoot.
Existem duas maneiras de saber
mais sobre o Greenfoot e ter contato com a comunidade do Greenfoot:
