Documentos de Académico
Documentos de Profesional
Documentos de Cultura
BLUMENAU
PROFESSORES:
Mauro Marcelo Mattos
Adilson Vahldick
Marcel Hugo
2
Figura 40- Termos de Licença do Software. .............................................................................................................. 114
Figura 41- Opções para o download. ........................................................................................................................ 114
Figura 42- Andamento do download. ....................................................................................................................... 115
Figura 43- Site do NetBeans > download. ................................................................................................................. 115
Figura 44-Licença de Uso do Software. ..................................................................................................................... 116
Figura 45- Configuração da Instalação. ..................................................................................................................... 116
Figura 46- Configuração da Instalação. ..................................................................................................................... 117
Figura 47- Instalação Completa. ............................................................................................................................... 117
3
1. INTRODUÇÃO
E
sse é um documento de apoio das disciplinas de programação dos cursos de
Bacharelado em Ciências da Computação, de Sistemas de Informação e de
Licenciatura em Computação da FURB.
O documento foi produzido a partir de uma compilação de várias fontes, particularmente a
partir de:
documentação produzida nas sucessivas versões do FURBOT produzidas pelo Prof.
Adilson Vahldick;
apostila desenvolvida pelo Prof. Maurício Capobianco Lopes (fundamentação de OO e
algoritmos);
da apostila desenvolvida pelo Prof. Marcel Hugo (interfaces gráficas com o usuário) e
pelas contribuições dos monitores Fernanda Gums (tutorial de instalação do Netbeans,
Eclipse e JDK) e Eduardo Coelho (geração de gabaritos de exercícios propostos).
4
FIGURA 1- AMBIENTE DO FURBOT.
Uma aplicação Furbot possui 1 requisito importante: o nome do arquivo .xml deve ser o
mesmo nome do arquivo .java. No exemplo, o arquivo de especificação do modelo de
mundo denomina-se Exercicio1.xml e o arquivo que especifica a lógica de funcionamento
do robô denomina-se Exercicio1.java. A Figura 4 apresenta o exercício já carregado no
ambiente Netbeans.
3. Dentro do método main, deve haver somente a declaração que inicializa o mundo
segundo a especificação contida no arquivo xml que é informado entre aspas
conforme exemplo no quadro abaixo:
MundoVisual.iniciar(“Exercicio1.xml”);
Atendidos estes requisitos, o ambiente está pronto para ser utilizado. Neste primeiro
momento, você poderá modificar o comportamento do furbot alterando o método
inteligencia() conforme exemplificado na Figura 3. Para tanto lançamos mão de uma das
primitivas de movimentação do Furbot: andarDireita().
Considerando que o mundo é modelado como uma grade de 8 x 8 células e que o robô
nasce na posição 0,0 (canto superior esquerdo) , para que ele atenda a especificação,
que é andar até a parede direita, basta que construamos a seguinte seqüência de
comandos:
7
public class Exercicio1 extends Furbot {
public void inteligencia() throws Exception {
andarDireita();
andarDireita();
andarDireita();
andarDireita();
andarDireita();
andarDireita();
andarDireita();
andarDireita();
diga(“Cheguei!”);
}
public static void main (String[] args) {
MundoVisual.iniciar(“Exercicio1.xml”);
}
}
Como você pode ver, programar o furbot consiste em desenvolver uma seqüência finita
de comandos válidos que fazem com que o furbot execute uma determinada tarefa. Em
linhas gerais, esta é a definição de um algoritmo e é o que iremos desenvolver ao longo
deste semestre.
8
3. FURBOT: COMANDOS
Nesta seção são descritos os comandos que afetam o comportamento do furbot.
São eles:
andarDireita():void : Faz com que o robô ande uma célula à direita. Se houver um
obstáculo ou for o fim do mundo, o robô explode
andarEsquerda():void : Faz com que o robô ande uma célula à esquerda. Se houver
um obstáculo ou for o fim do mundo, o robô explode.
andarAcima():void : Faz com que o robô ande uma célula para cima. Se houver um
obstáculo ou for o fim do mundo, o robô explode.
andarAbaixo():void : Faz com que o robô ande uma célula para baixo. Se houver um
obstáculo ou for o fim do mundo, o robô explode.
Um exemplo de uso destes comandos é apresentado no quadro abaixo:
public class Exercicio1 extends Furbot {
public void inteligencia() throws Exception {
andarDireita();
andarDireita();
andarAbaixo();
andarEsquerda();
andarAcima();
}
public static void main (String[] args) {
MundoVisual.iniciar(“Exercicio1.xml”);
}
}
9
diga (String):void : Faz com que a mensagem enviada como parâmetro seja
apresentada na tela. Toda mensagem deve ser escrita entre os parêntesis e grafada
entre aspas duplas
diga (Object):void : Permite que seja passado como parâmetro um objeto que contém
a mensagem a ser apresentada na tela. Este recurso é avançado e você só vai utilizá-
lo mais adiante.
limparConsole():void : Limpa a área de mensagens do mundo. Geralmente utilizamos
para facilitar a visualização de mensagens importantes.
Um exemplo de uso destes comandos é apresentado no quadro abaixo:
public class Exercicio1 extends Furbot {
public void inteligencia() throws Exception {
diga (“este é um exemplo de mensagem”);
String msg = “Este é um objeto que contém a msg a ser apresentada na tela”;
diga (msg);
limparConsole();
}
public static void main (String[] args) {
MundoVisual.iniciar(“Exercicio1.xml”);
}
}
10
public class Exercicio1 extends Furbot {
public void inteligencia() throws Exception {
if (eVazio(DIREITA) )
diga (“A célula a direita está vazia!”)
else
diga (“A célula a direita está ocupada!”);
if (eFim(DIREITA) )
diga (“Encontramos o fim do mundo a direita!”)
else
diga (“Podemos andar para a direita!”);
}
public static void main (String[] args) {
MundoVisual.iniciar(“Exercicio1.xml”);
}
}
ESQUERDA
DIREITA
ACIMA
ABAIXO
AQUIMESMO
Observe que as mesmas são grafadas com todas as letras em maiúsculo.
Para que seja possível obter as coordenadas da posição atual do furbot utilizam-se os
seguintes comandos:
getX():int : Retorna um valor inteiro contendo o número da coluna em que está o robô.
Lembre-se de que a primeira coluna é ZERO.
getY():int: Retorna um valor inteiro contendo o número da linha em que está o robô.
Lembre-se de que a primeira linha é ZERO.
11
Para tornar possível a interação entre estes objetos e viabilizar ações de detecção de
colisões entre objetos, remoção de objetos, movimentação de objetos entre outros, os
seguintes comandos são disponibilizados:
No exemplo do quadro acima é declarada uma variável do tipo boolean que será
inicializada com o valor de retorno da chamada do método ehObjetoDoMundoTipo. Essa
linha verifica se existe um objeto do tipo "Alien" na célula acima de onde está o robô. Se
existir retorna true.Não existe uma restrição fixa do que pode ser passado no primeiro
parâmetro. Entretanto, atualmente (versão 0.6) podem ser usados as Strings "Alien",
"Parede" e "Numero".
12
ehDependenteEnergia():boolean : Retorna true se o robô precisa de energia para
executar os métodos;
getMaxEnergia():int :Retorna a quantidade máxima de energia que pode ser armazena
no robô.
getEnergia():int : Retorna a quantidade atual de energia.
esperar(segundos:int):void : O robô espera a quantidade de segundos passado como
parâmetro antes de executar o próximo método.
esperarAlguem():ObjetoMundo : O robô espera até algum objeto cruzar a mesma
célula em que ele está, e retorna esse objeto. Caso se passem 5 segundos e nenhum
objeto ter cruzada a célula, então retorna null.
getVelocidade() : Retorna a velocidade do robô
setVelocidade() : Altera a velocidade do robô
sortear() : Sorteia um valor entre 0 e o valor máximo passado como parâmetro
jahExplodiu() : Retorna true se o robô já explodiu.
adicionarObjetoNoMundoEmbaixo()
ehBloqueado() : Verifica se o objeto é bloqueado ou não.
bloquear() : Bloqueia um objeto
desbloquear() : Desbloqueia um objeto
getSouDoTipo() : Retorna o tipo do objeto.
13
4. EXERCÍCIOS RESOLVIDOS
Exercícios:
1) Faça o robô andar até a ultima posição da linha. Lembre-se de que as
coordenadas sempre serão fornecidas como (x, y). A primeira coluna e linhas são a
de numero ZERO.
2) Faça o robô andar ate a ultima posição na mesma coluna. Lembre-se de que as
coordenadas sempre serão fornecidas como (x, y). A primeira coluna e linhas são a
de numero ZERO.
3) Faça o robô andar ate uma posição de linha e coluna diferente da linha e coluna
iniciais. Lembre-se de que as coordenadas sempre serão fornecidas como (x, y). A
primeira coluna e linhas são a de numero ZERO.
4) Faça o robô andar ate os extremos do mundo retornando a posição inicial. Cada
vez que o robô atingir um dos extremos, faça informar que ele chegou ate aquela
posição. Lembre-se de que as coordenadas sempre serão fornecidas como (x, y).
A primeira coluna e linhas são a de numero ZERO.
5) Faça o robô chegar ate a coluna 4 na mesma linha em que ele nasceu. Se ele
encontrar um obstáculo deve desviar por baixo. É garantido que não exista um
obstáculo na ultima linha. A primeira coluna e linhas são a de numero ZERO.
6) Faça o robô andar ate uma posição de linha e coluna diferente da linha e coluna
iniciais. Lembre-se de que as coordenadas sempre serão fornecidas como (x, y). A
primeira coluna e linhas são a de numero ZERO.
14
4.2.1. LISTA 1 – EX1 - MODELO DE MUNDO EM XML
<furbot>
<enunciado>
Exercicio 1. <br>
Faca o robo andar ate a ultima posicao da linha. <br> Lembre-se de que as coordenadas sempre
serao fornecidas como (x, y). <br> A primeira coluna e linhas sao a de numero ZERO.
</enunciado>
<mundo>
<qtdadeLin>8</qtdadeLin>
<qtdadeCol>8</qtdadeCol>
<explodir>true</explodir>
</mundo>
<robo>
<x>0</x>
<y>0</y>
</robo>
</furbot>
15
<furbot>
<enunciado>Exercicio 2. <br>
Faca o robo andar ate a ultima posicao na mesma coluna. <br> Lembre-se de que as coordenadas
sempre serao fornecidas como (x, y). <br> A primeira coluna e linhas sao a de numero
ZERO.</enunciado>
<mundo>
<qtdadeLin>8</qtdadeLin>
<qtdadeCol>8</qtdadeCol>
<explodir>true</explodir>
</mundo>
<robo>
<x>0</x>
<y>0</y>
</robo>
</furbot>
16
<enunciado>Exercicio 3. <br>
Faça o robô andar ate uma posicao de linha e coluna diferente da linha e coluna iniciais. <br>
Lembre-se de que as coordenadas sempre serao fornecidas como (x, y). <br>
A primeira coluna e linhas sao a de numero ZERO.</enunciado>
<mundo>
<qtdadeLin>8</qtdadeLin>
<qtdadeCol>8</qtdadeCol>
<explodir>true</explodir>
</mundo>
<robo>
<x>0</x>
<y>0</y>
</robo>
</furbot>
17
Faca o robo andar ate os extremos do mundo retornando a posicao inicial. <br>
Cada vez que o robo atingir um dos extremos, faca-o informar que ele chegou ate aquela posicao. <br>
Lembre-se de que as coordenadas sempre serao fornecidas como (x, y). <br>
A primeira coluna e linhas sao a de numero ZERO.</enunciado>
<mundo>
<qtdadeLin>8</qtdadeLin>
<qtdadeCol>8</qtdadeCol>
<explodir>false</explodir>
</mundo>
<robo>
<x>0</x>
<y>0</y>
</robo>
</furbot>
A solução para este problema utilizou o recurso ehFim (direção). Este recurso retorna
verdadeiro se a posição indicada por “direção” encontra-se fora do mundo. Portanto
executando a operação de repetição while ( ! ehFim(DIREITA)) denota que: enquanto não
for encontrado o fim do mundo na próxima posição a direita podemos deslocar o robô
para a próxima posição a direita de onde ele esta.
Observe que o símbolo ! denota negação da expressão que está sendo testada.
import br.furb.furbot.Furbot;
import br.furb.furbot.MundoVisual;
public class Exercicio4 extends Furbot{
public void inteligencia() throws Exception {
diga("exercicio4");
while (!ehFim(DIREITA)) { //anda até o canto superior direito
andarDireita();
};
diga ("cheguei no canto superior direito");
while (!ehFim(ABAIXO)) { //anda até o canto inferior direito
18
andarAbaixo();
};
diga ("cheguei no canto inferior direito");
while (!ehFim(ESQUERDA)) { //anda até o canto inferior esquerdo
andarEsquerda();
};
diga ("cheguei no canto inferior esquerdo");
while (!ehFim(ACIMA)) { //anda até o canto superior esquerdo
andarAcima();
};
diga ("retornei ao inicio");
}
public static void main(String[] args) {
MundoVisual.iniciar("Exercicio4.xml");
}
}
19
4.2.5.1. LISTA 1 – GABARITO DO EXERCÍCIO 5
Lembre-se que a especificação em XML <qtdadeLin>5</qtdadeLin> implica que haverão
5 linhas (numeradas de 0 a 4) e que <qtdadeCol>5</qtdadeCol> denota que teremos 5
colunas (numeradas de 0 a 4). Portanto, deslocar-se até a linha 4 (significa o mesmo que
ir até a última coluna.
A solução para este problema utilizou o recurso ehVazio(direção). Este recurso retorna
verdadeiro se a posição indicada por “direção” encontra-se ocupada por algum objeto
(Parede, Alien, Número, etc).
Foi utilizado também o recurso getX() o qual retorna um valor numérico indicando a
coordenada x em que o furbot se encontra.
Também foi utilizado o recurso ehFim (direção) o qual, como explicado anteriormente,
retorna verdadeiro se a posição indicada por “direção” encontra-se fora do mundo.
Observe que o símbolo ! denota negação da expressão que está sendo testada.
import br.furb.furbot.Furbot;
import br.furb.furbot.MundoVisual;
public class Exercicio5 extends Furbot{
public void inteligencia() throws Exception {
diga("exercicio5");
while (getX()<5) { //enquanto a coordenada em que o furbot encontra-se for menor que 5 (0..4)
if (ehVazio(DIREITA)){ //se a posição a direita for vazia
if (!ehFim(DIREITA)) //e se a posição a direita não for fim do mundo
andarDireita(); //desloca-se para a direita
}
else { // significa que a posição a direita estava ocupada, portanto
andarAbaixo(); // desloca-se uma posição abaixo
andarDireita(); //desloca-se uma posição a direita
andarDireita(); //desloca-se outra posicao a direita
andarAcima(); //retorna para a posição seguinte ao obstáculo caracterizando o desvio
}
};
20
diga ("cheguei na coluna 4");
}
public static void main(String[] args) {
MundoVisual.iniciar("Exercicio5.xml");
}
}
21
andarDireita();
}
}
else {
if (ehVazio(ABAIXO)){
while (!ehVazio(DIREITA)) {
if (!ehFim(ABAIXO)) {
andarAbaixo();
}
else { //eh fim abaixo
//tem que mudar a direcao para cima
while (!ehVazio(DIREITA)){
if (!ehFim(ACIMA)) {
andarAcima();
}
}//while
}
};//while
}
else
diga ("estou encurralado!!!");
};
}
diga ("cheguei na coluna 4");
}
public static void main(String[] args) {
MundoVisual.iniciar("Exercicio6.xml");
}
}
22
4.3. LISTA DE EXERCÍCIOS 2
A segunda lista de exercícios tem por objetivo ampliar o seu domínio sobre os recursos do
furbot.
Exercícios:
1) Faça o robô andar até a última coluna contando os aliens. No final o robô deve
falar a quantidade de aliens encontrados. Atenção: não se esqueça do tratamento
do singular e plural. Se for mais que um Alien, o robô deve dizer “aliens”;
2) Faça o robo andar ao redor do mundo e contar os alines que ele encontrou no
caminho. No final ele deve falar a quantidade de aliens encontrados;
3) Faça o robô andar ao redor do mundo e contar os alines que ele encontrou no
caminho. O robô deve voltar a célula de nascença para então falar a quantidade de
aliens;
4) Faça o robô andar ao redor do mundo e contar os aliens que ele encontrou no
caminho. O robô deve voltar a célula de origem para então falar a quantidade de
aliens encontrados, respectivamente, no total, na coluna zero, na última coluna e
na última linha;
5) Faça o robô andar até a célula (0,0). Em seguida o faça andar pelo mundo todo
contando os aliens que encontra pelo caminho. Quando ele alcançar a última célula
deve falar a quantidade de aliens encontrados;
6) Faça o robô andar ao redor do mundo e contar os aliens que ele encontrou pelo
caminho. O robô deve voltar a célula de origem para então falar a quantidade de
aliens encontrados, respectivamente, no total, nas linhas pares, nas linhas
ímpares, nas colunas pares e nas colunas ímpares.
23
</objeto>
<objeto class="br.furb.furbot.Alien">
<random limiteInfX="1" />
<bloqueado>false</bloqueado>
</objeto>
<objeto class="br.furb.furbot.Alien">
<random limiteInfX="1" />
<bloqueado>false</bloqueado>
</objeto>
<objeto class="br.furb.furbot.Alien">
<random limiteInfX="1" />
<bloqueado>false</bloqueado>
</objeto>
<objeto class="br.furb.furbot.Alien">
<random limiteInfX="1" />
<bloqueado>false</bloqueado>
</objeto>
</furbot>
24
<explodir>true</explodir>
</mundo>
<robo>
<x>0</x>
<y>0</y>
</robo>
- <!-- aliens -->
<objeto class="br.furb.furbot.Alien">
<random />
<bloqueado>false</bloqueado>
</objeto>
<objeto class="br.furb.furbot.Alien">
<random />
<bloqueado>false</bloqueado>
</objeto>
- <objeto class="br.furb.furbot.Alien">
<random />
<bloqueado>false</bloqueado>
</objeto>
<objeto class="br.furb.furbot.Alien">
<random />
<bloqueado>false</bloqueado>
</objeto>
<objeto class="br.furb.furbot.Alien">
<random />
<bloqueado>false</bloqueado>
</objeto>
<objeto class="br.furb.furbot.Alien">
<random />
<bloqueado>false</bloqueado>
</objeto> </furbot>
25
while (!ehFim(ESQUERDA)) {
if (!ehVazio(ESQUERDA)) {
qtdAliens++;
}
andarEsquerda();
}
if (qtdAliens == 1) {
diga ("1 alien encontrado");
} else {
diga (qtdAliens + " aliens encontrados");
}
}
public static void main(String[] args) {
MundoVisual.iniciar("Lista1Exercicio2.xml");
}
}
26
4.3.4. LISTA 2 – EX3 - GABARITO DO EXERCÍCIO 3
import br.furb.furbot.Furbot;
import br.furb.furbot.MundoVisual;
public class Lista1Exercicio3 extends Furbot {
public void inteligencia() throws Exception {
diga("Exercicio 3");
int qtdAliens = 0;
int inicialX = getX();
int inicialY = getY();
while (!ehFim(ESQUERDA)) {
andarEsquerda();
}
while (!ehFim(ABAIXO)) {
if (!ehVazio(ABAIXO)) {
qtdAliens++;
}
andarAbaixo();
}
while (!ehFim(DIREITA)) {
if (!ehVazio(DIREITA)) {
qtdAliens++;
}
andarDireita();
}
while (!ehFim(ACIMA)) {
if (!ehVazio(ACIMA)) {
qtdAliens++;
}
andarAcima();
}
while (!ehFim(ESQUERDA)) {
if (!ehVazio(ESQUERDA)) {
qtdAliens++;
}
andarEsquerda();
}
// volta a celula inicial
int linhaAtual = 0;
while (linhaAtual < inicialY) {
if (!ehVazio(ABAIXO)) {
qtdAliens++;
}
andarAbaixo();
linhaAtual++;
}
int colunaAtual = 0;
while (colunaAtual < inicialX) {
andarDireita();
colunaAtual++;
}
if (qtdAliens == 1) {
diga ("1 alien encontrado");
} else {
diga (qtdAliens + " aliens encontrados");
}
}
public static void main(String[] args) {
MundoVisual.iniciar("Lista1Exercicio3.xml");
27
}
}
28
4.3.5.1. LISTA 2 - GABARITO DO EXERCÍCIO 4
import br.furb.furbot.Furbot;
import br.furb.furbot.MundoVisual;
public class Lista1Exercicio4 extends Furbot {
public void inteligencia() throws Exception {
diga("Exercicio 4");
int qtdAColuna0, qtdaLinha0, qtdAUltimaColuna, qtdAUltimaLinha, qtdACantos, total;
qtdAColuna0 = qtdaLinha0 = qtdAUltimaColuna = qtdAUltimaLinha = qtdACantos = total = 0;
int inicialX = getX();
int inicialY = getY();
while (!ehFim(ESQUERDA)) {
andarEsquerda();
}
while (!ehFim(ABAIXO)) {
if (!ehVazio(ABAIXO)) {
qtdAColuna0++;
}
andarAbaixo();
}
if (!ehVazio(AQUIMESMO)) {
qtdACantos++;
qtdAUltimaLinha++;
}
while (!ehFim(DIREITA)) {
if (!ehVazio(DIREITA)) {
qtdAUltimaLinha++;
}
andarDireita();
}
if (!ehVazio(AQUIMESMO)) {
qtdACantos++;
qtdAUltimaColuna++;
}
while (!ehFim(ACIMA)) {
if (!ehVazio(ACIMA)) {
qtdAUltimaColuna++;
}
andarAcima();
}
if (!ehVazio(AQUIMESMO)) {
qtdACantos++;
qtdaLinha0++;
}
while (!ehFim(ESQUERDA)) {
if (!ehVazio(ESQUERDA)) {
qtdaLinha0++;
}
andarEsquerda();
}
if (!ehVazio(AQUIMESMO)) {
qtdACantos++;
qtdAColuna0++;
}
int linhaAtual = 0;
29
while (linhaAtual < inicialY) {
if (!ehVazio(ABAIXO)) {
qtdAColuna0++;
}
andarAbaixo();
linhaAtual++;
}
int colunaAtual = 0;
if (total == 1) {
diga ("Total: 1 alien");
} else {
diga ("Total: "+total+" aliens");
}
if (qtdAColuna0 == 1) {
diga ("Coluna0: 1 alien");
} else {
diga ("Coluna0: "+qtdAColuna0+" aliens");
}
if (qtdaLinha0 == 1) {
diga ("Linha0: 1 alien");
} else {
diga ("Linha0: "+qtdaLinha0+" aliens");
}
if (qtdAUltimaColuna == 1) {
diga ("UltColuna: 1 alien");
} else {
diga ("UltColuna: "+qtdAUltimaColuna+" aliens");
}
if (qtdAUltimaLinha == 1) {
diga ("UltLinha: 1 alien");
} else {
diga ("UltLinha: "+qtdAUltimaLinha+" aliens");
}
}
public static void main(String[] args) {
MundoVisual.iniciar("Lista1Exercicio4.xml");
}
}
30
4.3.6. LISTA 2 – EX5 - MODELO DE MUNDO EM XML.
<furbot>
<enunciado>Lista de Exercícios - Exercício 5.<br> Faça o robô andar até a célula (0,0). <br> Em seguida
faça ele andar pelo mundo todo<br> e contando os aliens. Quando ele alcançar<br> a última célula deve
falar a quantidade<br> de aliens encontrados.</enunciado>
<mundo>
<random limiteInfY="3" limiteSupY="8" limiteInfX="3" limiteSupX="8" />
<explodir>true</explodir>
</mundo>
<robo>
<random />
</robo>
<!-- aliens -->
<objeto class="br.furb.furbot.Alien">
<random />
<bloqueado>false</bloqueado>
</objeto>
<objeto class="br.furb.furbot.Alien">
<random />
<bloqueado>false</bloqueado>
</objeto>
<objeto class="br.furb.furbot.Alien">
<random />
<bloqueado>false</bloqueado>
</objeto>
<objeto class="br.furb.furbot.Alien">
<random />
<bloqueado>false</bloqueado>
</objeto>
<objeto class="br.furb.furbot.Alien">
<random />
<bloqueado>false</bloqueado>
</objeto>
</furbot>
while (!ehFim(ABAIXO)) {
31
if (!ehVazio(AQUIMESMO))
qtdAliens++;
if (sentidoDireita) {
while (!ehFim(DIREITA)) {
if (!ehVazio(DIREITA)) {
qtdAliens++;
}
andarDireita();
}
} else {
while (!ehFim(ESQUERDA)) {
if (!ehVazio(ESQUERDA)) {
qtdAliens++;
}
andarEsquerda();
}
}
if (!ehFim(ABAIXO))
andarAbaixo();
sentidoDireita = !sentidoDireita;
}
if (!ehVazio(AQUIMESMO))
qtdAliens++;
if (sentidoDireita)
while (!ehFim(DIREITA)) {
if (!ehVazio(DIREITA)) {
qtdAliens++;
}
andarDireita();
}
else
while (!ehFim(ESQUERDA)) {
if (!ehVazio(ESQUERDA)) {
qtdAliens++;
}
andarEsquerda();
}
if (qtdAliens == 1) {
diga ("1 alien encontrado");
} else {
diga (qtdAliens + " aliens encontrados");
}
}
public static void main(String[] args) {
MundoVisual.iniciar("Lista1Exercicio5.xml");
}
}
32
<mundo>
<random limiteInfY="3" limiteSupY="8" limiteInfX="3" limiteSupX="8" />
<explodir>true</explodir>
</mundo>
<robo>
<random />
</robo>
<!-- aliens -->
<objeto class="br.furb.furbot.Alien">
<random />
<bloqueado>false</bloqueado>
</objeto>
<objeto class="br.furb.furbot.Alien">
<random />
<bloqueado>false</bloqueado>
</objeto>
<objeto class="br.furb.furbot.Alien">
<random />
<bloqueado>false</bloqueado>
</objeto>
<objeto class="br.furb.furbot.Alien">
<random />
<bloqueado>false</bloqueado>
</objeto>
<objeto class="br.furb.furbot.Alien">
<random />
<bloqueado>false</bloqueado>
</objeto>
<objeto class="br.furb.furbot.Alien">
<random />
<bloqueado>false</bloqueado>
</objeto>
</furbot>
33
if (sentidoDireita) {
while (!ehFim(DIREITA)) {
if (!ehVazio(DIREITA)) {
if (getX()%2 == 0) qtdALinhaPar++;
else qtdALinhaImpar++;
if (getY()%2 == 0) qtdAColunaPar++;
else qtdAColunaImpar++;
total++;
}
andarDireita();
}//while
} else
{ //sentido a esquerda
while (!ehFim(ESQUERDA)) {
if (!ehVazio(ESQUERDA)) {
if (getX()%2 == 0) qtdALinhaPar++;
else qtdALinhaImpar++;
if (getY()%2 == 0) qtdAColunaPar++;
else qtdAColunaImpar++;
total++;
}
andarEsquerda();
}//while
}
if (!ehFim(ABAIXO))
andarAbaixo();
sentidoDireita = !sentidoDireita;
}
if (!ehVazio(AQUIMESMO)) {
if (getX()%2 == 0) qtdALinhaPar++;
else qtdALinhaImpar++;
if (getY()%2 == 0) qtdAColunaPar++;
else qtdAColunaImpar++;
total++;
}
if (sentidoDireita)
while (!ehFim(DIREITA)) {
if (!ehVazio(DIREITA)) {
if (getX()%2 == 0) qtdALinhaPar++;
else qtdALinhaImpar++;
if (getY()%2 == 0) qtdAColunaPar++;
else qtdAColunaImpar++;
total++;
}
andarDireita();
}//while
else
while (!ehFim(ESQUERDA)) {
if (!ehVazio(ESQUERDA)) {
if (getX()%2 == 0) qtdALinhaPar++;
else qtdALinhaImpar++;
if (getY()%2 == 0) qtdAColunaPar++;
else qtdAColunaImpar++;
total++;
}
andarEsquerda();
}//while
if (total == 1) {
34
diga ("Total: 1 alien");
} else {
diga ("Total: "+total+" aliens");
}
if (qtdALinhaPar == 1) {
diga ("Linha Par: 1 alien");
} else {
diga ("Linha Par: "+qtdALinhaPar+" aliens");
}
if (qtdALinhaImpar == 1) {
diga ("Linha Impar: 1 alien");
} else {
diga ("Linha Impar: "+qtdALinhaImpar+" aliens");
}
if (qtdAColunaPar == 1) {
diga ("Coluna Par: 1 alien");
} else {
diga ("Coluna Par: "+qtdAColunaPar+" aliens");
}
if (qtdAColunaImpar == 1) {
diga ("Coluna Impar: 1 alien");
} else {
diga ("Coluna Impar: "+qtdAColunaImpar+" aliens");
}
}
public static void main(String[] args) {
MundoVisual.iniciar("Lista1Exercicio6.xml");
}
}
35
5. INTRODUÇÃO A PROGRAMAÇÃO ORIENTADA A OBJETOS
Orientação a objetos modela o mundo a partir dos objetos existentes no mundo real.
OBJETOS são elementos que existem concretamente, seja em forma física ou conceitual.
Os objetos têm características e comportamentos próprios.
encapsulamento: os objetos têm uma interface para se comunicar com o seu mundo
exterior.
herança1: objetos podem herdar informações de outros objetos.
polimorfismo1: objetos similares podem ter comportamentos diferentes.
associação1: objetos podem se associar a outros objetos.
abstração: classes devem ser modeladas considerando apenas aquilo que é relevante
para a solução de um determinado problema.
A implementação de uma solução computacional utilizando OO requer, portanto, a
construção de um modelo de classes e objetos.
5.1. CLASSES
As CLASSES são categorias de objetos com dados e comportamentos similares.
Exemplos de CLASSES:
1
Estes conceitos serão abordados nas disciplinas posteriores de programação.
36
ALUNO
Atributos: número de matrícula, nome, sexo, curso
Métodos: matricular-se, informar número de matrícula
CONTA CORRENTE
Atributos: número da conta, dígito verificador, nome do correntista, cpf, saldo
Métodos: abrir conta, depositar, retirar, ver saldo, ver dados correntista
ENDEREÇO
Atributos: rua, número, bairro, cidade, uf
Métodos: cadastrar endereço, alterar endereço, ver endereço
A representação diagramática mais comum de uma classe é feita através de uma caixa
dividida em três partes: a primeira deve conter o nome da classe, a segunda, deve conter
os atributos da classe e a terceira deve conter os métodos da classe.
Nome da Classe
atributos
métodos
Exemplos:
Aluno
Conta Corrente Endereço
número de matrícula número da conta rua
retirar
Existem atributos de uma classe que podem ser outras classes. Por exemplo, na classe
Aluno, o atributo Curso poderia ser uma outra classe, contendo o código do curso, nome
do curso, currículo e assim por diante.
37
no problema 1 analisado anteriormente, o aluno é um candidato a ser uma classe, pois
sobre ele definem-se outras informações tais como nome e notas.
no problema 2, a classe candidata poderia ser a sala, pois é sobre ela que se sabe a
largura e o comprimento e se deseja calcular a área.
5.2. OBJETOS
Um OBJETO é o que chamamos de INSTÂNCIA da classe, ou seja, quando atribuímos
valores aos DADOS.
contaCorrente : endereço :
aluno : Aluno Conta Corrente Endereço
número de matrícula: 100 número da Conta: 100 rua: Rua das Acácias
nome: Bento de Oliveira dígito verificador: 2 número: 123
sexo: M nome do correntista: Rica de bairro: Jovem
curso: Ciência da Computação Menezes cidade: Blumenau
CPF: 123456789-0 uf: SC
Saldo: R$1.000.000,00
Retirar
38
aluno1 : Aluno aluno2 : Aluno aluno3 : Aluno
Um objeto é a materialização de uma classe. Para ser usado um objeto deve ser criado.
5.3. ATRIBUTOS
Conforme visto anteriormente, ATRIBUTOS são as informações que caracterizam uma
classe.
39
Via de regra, um dado deve ser definido como atributo quando ele não tem
dependência de outros dados.
Dados dependentes devem ser definidos como atributos apenas quando são muito
usados. Entretanto, deve-se ter em mente que a cada dado alterado que influencie em
seu valor, o mesmo também precisa ser alterado.
Exemplo: considere o exercício 1 onde o professor tem que calcular a média de um aluno
a partir de suas 3 notas. Quem são os atributos do aluno?
nota1, nota2 e nota3 são atributos uma vez que são dados independentes.
média não deve ser atributo pois depende das notas, ou seja, é um dado calculado.
inteiro: define valores numéricos do tipo inteiro, ou seja, sem casas decimais. (Ex: 10,
15, 138)
real: define valores numéricos do tipo real (ponto flutuante), ou seja, com casas
decimais. (Ex. 0.15, 45.2, 1.3465)
caractere: define valores alfanuméricas compostas de apenas um caractere. (Ex. ‘A’,
‘?’ ‘@’)
lógico: define variáveis do tipo VERDADEIRO ou FALSO.
Outro tipo de dado muito comum é denominado de string ou cadeia de caracteres, pois
permite agrupar diversos caracteres. (Ex. “João da Silva”, “ABC123”, “Computador”).
Para as classes dos exemplos anteriores, poderíamos definir os seguintes tipos de dados
(o tipo do dado normalmente vem à frente do nome do atributo).
40
Aluno
Conta Corrente Endereço
inteiro número de matrícula inteiro número da conta string rua
retirar
5.4. MÉTODOS
Conforme visto anteriormente, MÉTODOS são os comportamentos ou as ações
realizadas por um objeto.
Os métodos também são chamados de funções, pois, assim como na Matemática, eles
recebem valores e retornam um resultado.
41
5.4.1. ASSINATURA DOS MÉTODOS
A Assinatura de um método é o seu cabeçalho, ou seja, é o que descreve o método.
O TIPO descreve o tipo de dado do valor de retorno do método. Quando ele é omitido, é
porque a saída é um atributo.
Nos PARÂMETROS deve ser colocado o tipo de dado e um nome para o parâmetro.
Quando os parâmetros são omitidos, é porque a(s) entrada(s) é(são) atributo(s).
5.4.2. ALGORITMO
O ALGORITMO de um método são as instruções que ele deve executar para realizar as
operações que são de sua responsabilidade.
Um ALGORITMO é similar a uma receita para resolver tarefas específicas. Estas tarefas
não podem ser redundantes nem subjetivas na sua definição, devendo ser claras e
precisas.
Também precisam ter uma SEQÜÊNCIA LÓGICA para que o problema seja resolvido
corretamente.
Via de regra todo algoritmo opera sobre DADOS (denominados de VARIÁVEIS), sendo
um processo que precisa de RECURSOS (dados de entrada) e produz RESULTADOS
(dados de saídas).
42
FIGURA 5 - COMPONENTES DE UM ALGORITMO.
5.5. ENCAPSULAMENTO
A orientação a objetos define regras de acesso aos atributos e métodos, para garantir a
segurança e qualidade do código desenvolvido.
privado: neste caso, o atributo ou método só pode ser utilizado dentro da própria
classe.
público: neste caso, o atributo ou método pode ser utilizado por qualquer outra classe.
2
Existem algumas exceções no caso de herança de classes que não serão vistas por enquanto.
44
MÉTODOS DE ACESSO (setters&getters)
Uma vez que os atributos são encapsulados, deve existir uma forma de atribuir valores a
eles ou de verificar seus valores.
5.6. CONSTRUTORES
Os objetos são instâncias de uma classe.
45
CONSTRUTORES não têm retorno, mas podem ter parâmetros com os valores de
inicialização dos atributos.
a classe principal: responsável pela interface com o usuário (leitura e escrita dos
dados) e criação dos objetos necessários para a solução do problema. Doravante esta
classe será denominada de main;
a classe do modelo: responsável por executar as tarefas que solucionam a situação-
problema proposta.
Neste caso dizemos que há uma associação entre as classes.
A classe principal tem a função de prover as funcionalidades descritas nos casos de uso.
Deste modo ela terá sempre as seguintes tarefas fundamentais:
46
INFORMAR ao usuário através do dispositivo de saída (vídeo) OS RESULTADOS
obtidos;
A classe do modelo terá sempre as seguintes tarefas fundamentais:
47
6. INTRODUÇÃO À LINGUAGEM JAVA
Origem da linguagem:
propósito geral;
orientada a objetos e fortemente tipada;
independente de plataforma ou sistema operacional (hardware e software);
vários fornecedores de ambientes de desenvolvimento;
gerência automática de memória (garbage collector) sem ponteiros e alocação direta
de memória;
escalabilidade das aplicações.
Como funciona:
JANDL JÚNIOR, Peter. Java 5: guia de consulta rápida. São Paulo : Novatec,
2006. 136 p, il. pg. 4.
Para poder ser executado um programa em Java como uma aplicação desktop, tem que
existir uma classe com uma função denominada main(), através da qual o programa em
Java é iniciado.
A classe com a função main(), também denominada Principal, pode ativar outras classes
conforme pode ser visualizado na figura a seguir.
48
FIGURA 7 - ATIVAÇÃO DE OUTRAS CLASSES A PARTIR DO MAIN.
Normalmente uma classe Principal não tem atributos ou métodos, mas apenas a criação
de outras classes e inicialização do programa. Isto não é uma regra e varia do gosto de
cada programador. Entretanto, é uma boa prática de programação.
//método construtor
public Nome_da_classe() {
}
Deve-se notar o uso de chaves para iniciar ({) e fechar (}) uma classe em Java.
Por convenção o nome de uma classe sempre é iniciado por letra maiúscula.
Exemplo: codificação da classe para calcular a largura da sala.
/** Esta classe define uma sala
* @author Maurício Capobianco Lopes
* @version %I%, %G% */
É importante ressaltar que novas e boas práticas de programação nos permitirão melhorar
esta classe no futuro.
JANDL JÚNIOR, Peter. Java 5: guia de consulta rápida. São Paulo : Novatec, 2006. 136
p, il. pgs. 5 a 7.
50
Um identificador em Java deve sempre iniciar com uma letra, podendo a seguir ter
qualquer combinação de letras (a..z), números (0..9) e do caractere sublinhado (_).
Observe que nenhum outro símbolo ou espaço em branco é permitido em um
identificador.
JANDL JÚNIOR, Peter. Java 5: guia de consulta rápida. São Paulo : Novatec, 2006. 136
p, il. pg. 6, 8 e 9.
Numéricos (inteiros):
Tipo Tamanho Domínio
(em bits)
byte 8 -128 .. 127
short 16 -32.768 .. 32.767
int 32 -2.147.483.648 .. 2.147.483.647
long (literal: L) 64 -2^64 .. 2^64-1
Numéricos (reais):
Tipo Tamanho Domínio Dígitos
(em bits) Significativos
float (literal: f) 32 1.4 * 10-45 .. 3.4 * 1038 7-8
double (literal: d) 64 5.0 * 10-324 .. 1.8 * 10308 15-16
Alfanuméricos:
Tipo Tamanho Armazenamento
(em bits)
char 16 1 caracter UNICODE
Lógicos:
Tipo Tamanho Armazenamento
(em bits)
boolean 1 true ou false
51
O Java possui ainda o tipo void que não armazena nenhum conteúdo.
JANDL JÚNIOR, Peter. Java 5: guia de consulta rápida. São Paulo : Novatec, 2006. 136
p, il. pg. 7.
JANDL JÚNIOR, Peter. Java 5: guia de consulta rápida. São Paulo : Novatec, 2006. 136
p, il. pg. 75.
Uma String não é um tipo primitivo, mas sim uma classe e, portanto, seu nome é iniciado
com uma letra maiúscula.
Um char é representado entre apóstrofos (Ex: ‘a’), enquanto uma String é representado
entre aspas (Ex: “a”).
52
6.3.2.1. OPERADORES E MÉTODOS DE STRINGS
A classe String tem o operador + para a concatenação entre strings.
JANDL JÚNIOR, Peter. Java 5: guia de consulta rápida. São Paulo : Novatec,
2006. 136 p, il. pg. 75.
onde:
qualificador: informa se o atributo é público ou privado;
tipo: é o tipo do atributo;
nome_atributo: é o nome dado ao atributo;
valor: inicialização do atributo;
final: é um qualificador (palavra reservada) que indica que o valor do atributo não pode ser alterado.
53
Exemplos:
private char letra;
private int numero = 10;
private final double tamanho = 50;
JANDL JÚNIOR, Peter. Java 5: guia de consulta rápida. São Paulo : Novatec, 2006. 136
p, il. pg. 9 e 30.
6.5. MÉTODOS
Métodos são as funções que permitem realizar operações sobre o objeto.
A definição de métodos em uma classe em Java pode ser feita do seguinte modo:
qualificador tipo nome_método ([parâmetros]) {
bloco de instruções
[return expressão]
}
onde:
qualificador: informa se o método é público ou privado;
tipo: é o tipo do valor de retorno do método;
nome_método: é o nome dado ao método;
parâmetros: são os dados de entrada passados para o método para que o mesmo possa ser executado.
Estão entre colchetes ([]), pois são opcionais em um método;
bloco de instruções: são as instruções realizadas pelo método para o processamento dos dados;
return: indica que o método deve ser finalizado retornando o valor que é o resultado da expressão.
Também é opcional no caso de um método do tipo void.
JANDL JÚNIOR, Peter. Java 5: guia de consulta rápida. São Paulo : Novatec,
2006. 136 p, il. pg. 31.
6.6. EXPRESSÕES
As expressões denotam chamadas de métodos ou operações sobre os dados de uma
classe. As expressões envolvem o uso de operadores.
54
6.6.1. OPERADOR DE ATRIBUIÇÃO
O operador de atribuição na linguagem Java é o sinal de igual que representa a atribuição
da expressão à direita a variável à esquerda.
Exemplos:
x = 100;
y = x + 3;
55
6.6.4. OPERADORES LÓGICOS
Os operadores lógicos são:
Operação Operador
E &&
OU ||
NEGAÇÃO !
JANDL JÚNIOR, Peter. Java 5: guia de consulta rápida. São Paulo : Novatec, 2006. 136
p, il. pgs. 14 a 16.
6.7. ENCAPSULAMENTO
Conforme já visto anteriormente, em uma linguagem orientada a objetos, os atributos são
encapsulados, ou seja, só podem ser acessados através de métodos.
Assim, para que se possa atribuir um valor ao atributo ou pegar o seu conteúdo deve-se
criar métodos específicos para esta tarefa denominados comumente de set e get.
Exemplo:
//classe
public class Pessoa {
//atributo da classe
private String nome;
56
O qualificador this é usado para referenciar o objeto dentro da própria classe.
O método set pode ter consistências para verificar se um determinado valor pode ser
armazenado no objeto.
Neste caso, o conteúdo armazenado no atributo é retornado para o método que solicitou a
informação ao objeto.
O método get deve ter um tipo idêntico ao do atributo que ele irá retornar.
JANDL JÚNIOR, Peter. Java 5: guia de consulta rápida. São Paulo : Novatec, 2006. 136
p, il. pg. 32 e 37.
6.8. CONSTRUTOR
Para que um objeto seja utilizado ele precisa ser criado.
Os construtores devem ter o mesmo nome da classe e não podem retornar um valor.
57
Estrutura de um construtor:
//método construtor
public Nome_da_classe() {
}
O endereço de memória alocado para o objeto deve ser armazenado em uma variável do
tipo da classe do objeto que se deseja criar.
JANDL JÚNIOR, Peter. Java 5: guia de consulta rápida. São Paulo : Novatec, 2006. 136
p, il. pg. 34.
58
6.10. PACOTES E CLASSES ESTÁTICAS
A linguagem Java oferece muitas classes prontas, com funções para realizar as mais
diversas tarefas.
Assim, ao utilizar uma função de um pacote em java é necessário fazer sua importação
através da diretiva import.
Algumas classes não precisam ser importadas e nem instanciadas. Estas classes têm a
característica de serem estáticas e já estarem disponíveis pela API da linguagem. É o
caso da classe System.
JANDL JÚNIOR, Peter. Java 5: guia de consulta rápida. São Paulo : Novatec, 2006. 136
p, il. pg. 42 e 61.
59
nextInt(): lê um valor inteiro;
nextDouble(): lê um número real;
next(): lê um string;
nextBoolean(): lê um valor lógico;
Um exemplo de uso destes métodos pode ser visto no item sobre criação de objetos.
Na classe System utiliza-se o objeto out e em seguida podem ser usados os métodos:
JANDL JÚNIOR, Peter. Java 5: guia de consulta rápida. São Paulo : Novatec, 2006. 136
p, il. pg. 10.
De única linha //
// Exibe apenas a linha como comentário
De documentação /** */
/** Indicam que o comentário deve ser inserido em qualquer documentação gerada automaticamente pelo
javadoc . */
60
O javadoc é uma documentação padrão em arquivos HTML para programas Java. A
documentação em Java deve inserir diversos tags que permitem identificar informações
sobre a classe. Algumas tag importantes são:
JANDL JÚNIOR, Peter. Java 5: guia de consulta rápida. São Paulo : Novatec, 2006. 136
p, il. pg. 6.
61
7. INTERFACE GRÁFICA
Nesta seção são abordados os aspectos relacionados a criação de aplicações gráficas,
conhecidas inicialmente como AWT – Abstract Windows Toolkit. Nas sucessivas versões
do Java, o AWT foi substituído pelo Swing, uma biblioteca pertencente a biblioteca JFC-
Java Foundation Classes. Existem diversas APIs para construção de interfaces gráficas
em Java. Entre elas destacam-se: AWT, SWT, Swing e JSF.
Pela característica das aplicações desenvolvidas na disciplina será utilizada a API Swing.
A API Swing apresenta diversos componentes gráficos para construção de interfaces com
o usuário em Java.
As aplicações gráficas são aquelas que possibilitam a criação de uma GUI (Graphical
User Interface – Interafce Gráfica do Usuário). Assim, ao desenvolver uma aplicação
dotada de uma GUI, é necessário definir quais componentes serão utilizados e qual a
disposição dos mesmos na janela.
O swing possui inúmeras classes que podem ser utilizadas na construção de uma GUI.
Estes componentes pertencem ao pacote javax.swing e estão destacados na figura a
seguir:
Fonte: http://www-static.cc.gatech.edu/classes/cs4812_99_winter/
Fonte: http://www-static.cc.gatech.edu/classes/cs4812_99_winter/
7.1. FRAMES
Um Frame é uma classe do pacote AWT responsável pela criação de janelas (similares
aquelas criadas no ambiente Windows).
A classe Frame gera uma janela com barra de título, bordas e pode ter outros
componentes em seu interior(Figura 11).
FIGURA 12 - JROOTPANE.
O exemplo a seguir ilustra a criação de uma janela através da utilização da classe JFrame
do pacote swing (Furgeri; 2006,pág 181).
import java.awt.*; //permite a utilização de classes do pacote AWT e de constantes numéricas
import Java.awt.event.*;// usado para proces. de eventos como clique do mouse, Enter,etc
import javax.swing.*;// permite a utilização de diversas classes do pacote swing.
void fecharJanela() { //método que registra a operação de fechar a janela ao clicar sobre o "x".
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
public static void main (String args[]) { //método para teste da janela
JFrame janela = new InterfaceGUI(); //cria um objeto do tipo Janela
janela.setVisible(true); //a janela é criada e exibida na tela
}
}
Conforme Furgeri (2006,pág 178), os métodos mais utilizados da classe JFrame são:
void fecharJanela() { //método que registra a operação de fechar a janela ao clicar sobre o "x".
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
66
A Figura 19 apresenta a janela construída a partir do código acima.
A classe Container pertence ao pacote AWT e representa um objeto que contém todos os
demais componentes de uma janela.
Você pode testar outras variações que podem ser obtidas utilizando-se as constantes:
JRootPane.NONE;
JRootPane.COLOR_CHOOSER_DIALOG;
JRootPane.ERROR_DIALOG;
JRootPane.FILE_CHOOSER_DIALOG;
JRootPane.INFORMATION_DIALOG;
JRootPane.PLAIN_DIALOG;
JRootPane.QUESTION_DIALOG;
JRootPane.WARNING_DIALOG.
Conforme Furgeri (2006,pág 182), os métodos mais utilizados da classe JLabel são:
Para dividir uma janela em células, é preciso utilizar um gerenciador de layout, ou seja,
um método que controla a maneira como os componentes serão dispostos na janela. Esta
é a função do método setLayout(). Este método é utilizado para definir como o frame será
dividido. No caso do exemplo acima, esta sendo estabelecido que o frame será composto
por uma grade de quatro linhas e uma coluna (4,1) conforme esboçado abaixo:
Célula 1
Célula 2
Célula 3
Célula 4
Caso não tivesse sido definido o tipo de layout a ser utilizado pela janela, o sistema
consideraria que o frame contém somente uma célula.
Por padrão, o Java vem com cinco Gerenciadores de Layout: BorderLayout, BoxLayout,
FlowLayout, GridBagLayout, GridLayout e um adicional, o CardLayout.
ATENÇÃO: O IDE NetBeans disponibiliza mais opções de Layout. Neste tutorial utilizam-
se o BorderLayout, o GridLayout e o FlowLayout.
69
7.3. EVENTOS
A interação do usuário do programa com as classes definidas pelo programador
normalmente é implementada através de eventos.
70
botao1.setToolTipText(" Pressione neste botão para realizar uma busca");//dica
botao1.setMnemonic(KeyEvent.VK_B);
void fecharJanela() { //método que registra a operação de fechar a janela ao clicar sobre o "x".
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}
Ao passar-se com o mouse sobre o botão Busca, surgirá a dica cadastrada através do
método botao1.setToolTipText(“texto”) conforme apresentado na Figura 18.
Para adicionar uma tecla de atalho ao botão, utiliza-se o método setMnemonic() passando como parâmetro uma letra
Da mesma forma que um objeto JLabel, um objeto do tipo botão pode ser inicializado de
três maneiras:
Somente com um texto (o título de um botão);
Com uma imagem ou,
Com ambos um texto e uma imagem.
Para definir a posição do texto do botão em relação à imagem inserida no mesmo, utiliza-
se o método setHorizontalTextPosition(. Esta propriedade deve ser definida quando o
botão possuir imagem e texto ao mesmo tempo. A convenção padrão estabelece que a
imagem aparece ao lado esquerdo do texto, contudo, isto pode ser modificado pela
constante LEFT que fará com que o texto apareça ao lado esquerdo da imagem. Da
mesma forma, pode-se alterar o alinhamento vertical do texto através do método:
setVerticalTextPosition() utilizando as constantes TOP (topo) ou BOTTOM (abaixo)
(Furgeri; 2006,pág 184).
Além destas, outra propriedade importante refere-se ao fato de que um botão pode ser
criado e não estar habilitado para o usuário clicar. Em algum momento futuro, em função
da lógica da aplicação , o botão terá função e, neste caso, será habilitado. Para
implementar esta funcionalidade, utiliza-se o método setEnabled(true/false).
72
7.3.2. TRATADORES DE EVENTOS
No Erro! Fonte de referência não encontrada. são descritos os principais eventos que podem
ocorrer em uma aplicação, e em que momento elas ocorrem.
ActionEvent Ocorre quando um botão é pressionado, quando um item de lista recebe um
duplo clique ou quando um item de menu é selecionado.
ComponentEvent Ocorre quando um componente é ocultado, movido, redimensionado ou se torna
visível.
FocusEvent Ocorre quando um componente recebe ou perde o foco do teclado.
ItemEvent Ocorre quando é selecionado um item em uma lista de itens.
KeyEvent Ocorre quando se manipula o teclado.
MouseEvent Ocorre quando se manipula o mouse (mover, clicar, etc.).
WindowEvent Ocorre quando se manipula uma janela (mover, fechar, maximizar, etc.).
QUADRO 1- PRINCIPAIS EVENTOS
exibida abaixo mostra uma hierarquia dos principais listeners do pacote java.awt.
73
Fonte: Fernandes (2002).
FIGURA 19 - HIERARQUIA DOS PRINCIPAIS LISTENERS.
O método e.getSource() retorna uma referência ao objeto que gerou o evento. Através de
um comando IF, verifica-se se o evento foi produzido, por exemplo, pelo objeto botão1.
Conforme Furgeri (2006,pág 186), os métodos mais utilizados da classe JButton são:
try {
n1 = Float.parseFloat(txt1.getText()); n2 = Float.parseFloat(txt2.getText());
} catch (NumberFormatException erro) {
txt3.setText("Erro de formato");
return;
}
if (e.getSource() == bt1) {
result = n1 + n2;
} else if (e.getSource() == bt2) {
result = n1 - n2;
} else if (e.getSource() == bt3) {
result = n1 * n2;
} else if (e.getSource() == bt4) {
result = n1 / n2;
}
txt3.setText("" + result);
}
void fecharJanela() { //método que registra a operação de fechar a janela ao clicar sobre o "x".
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
l) pronto, seu formulário foi criado (Figura 30). Apenas é necessário incluir os
componentes para que o formulário fique semelhante ao que conhecemos como
um computador. Mas antes de começar a incluir os componentes, vamos abrir um
parêntese e falar sobre o Gerenciador de Layout (consulte a seção: 0).
FIGURA 30 - JFRAME CRIADO.
n) na Paleta, estão os componentes que podem ser utilizados no JFrame. Para que
eles sejam apenas adicionados, basta clicar uma vez sobre o componente
desejado e no desenho do JFrame (Figura 32);
FIGURA 32 - PALETA DE COMPONENTES.
r) agora para executar e ver o resultado (Figura 37), salve o projeto e clique no
Menu <Executar> <Executar Projeto Principal> ou então utilize o atalho F6 no
teclado. Agora seu projeto Computador está pronto.
Até agora você precisava definir um modelo de mundo em XML para que o Furbot
pudesse operar. Existe uma outra forma de fazê-lo utilizando componentes de interface
gráfica.
public ExemploDeFurbot () {
//no construtor do furbot, você deve estabelecer os parâmetros gerais de funcionamento do mesmo.
this.setTempoEspera(20); //estabelece a “velocidade de execução do furbot
this.desbloquear(); // estabelece que o mesmo está desbloqueado
}
O quadro a seguir apresenta uma estrutura geral da tela gráfica a partir da qual são
criados o mundo sobre o qual o furbot irá se movimentar e a própria instancia de furbot
(definida no quadro acima).
Exemplos:
import br.furb.furbot.MundoFurbot; // classe que viabiliza a interação com a interface com o usuário
import br.furb.furbot.suporte.TamanhoCelula; //classe que estabelece o tamanho da célula
85
// cria um JFrame - ver seção 7.
public Apresentacao() {
initComponents();
setLocationRelativeTo(null);
jScrollPane1.setViewportView(mundo);
robo = new ExemploDeFurbot ();
mundo.addObjeto(robo,0,0);
//a seguir indica ao mundo quais são os botões da interface grafica que comandam
// o inicio e fim das operações ( Esta indicação é opcional)
mundo.setBotaoExecutar(jButton2);
mundo.setBotaoParar(jButton3);
// Indica ao mundo qual a area de texto (JTextArea) que exibira o que o robô
// falar (metodo diga)
mundo.setConsole(jTextArea1);
}
………….
setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
………….
86
public static void main(String args[]) {
java.awt.EventQueue.invokeLater(new Runnable() {
public void run() {
new Apresentacao().setVisible(true);
}
});
}
87
9. ESTRUTURAS DE CONTROLE EM NÍVEL DE INSTRUÇÃO
As estruturas de controle em nível de instrução são (entre parênteses está sua
representação em Java):
Sintaxe em Java:
if (expressão-lógica) {
<seqüência-de-comandos em Java>
}
88
Em Português Estruturado:
se média do aluno >= 6.0 então
situação do aluno = “Aprovado”
fimse
Em Java:
if (aluno.media >= 6)
aluno.situacao = “Aprovado”;
JANDL JÚNIOR, Peter. Java 5: guia de consulta rápida. São Paulo : Novatec,
2006. 136 p, il. pg. 19.
Sintaxe em Java
if (expressão-lógica) {
<seqüência-de-comandos-expressão-verdadeira>
} else {
<seqüência-de-comandos-expressão-falsa>
}
89
Em Português Estruturado:
se nota do aluno >= 6.0 entao
situação do aluno = “aprovado”
senão
situação do aluno = “reprovado”
fimse
Em Java:
if (aluno.nota >= 6)
aluno.situacao = “aprovado”;
else
aluno.situacao = “reprovado”;
JANDL JÚNIOR, Peter. Java 5: guia de consulta rápida. São Paulo : Novatec, 2006. 136
p, il. pg. 19.
90
Em Java o operador lógico E é representado por && e o operador lógico OU é
representado por ||.
Exemplo simplificado de um algoritmo para verificar se uma pessoa pode nadar em uma
piscina:
Exemplo em Português Estruturado:
se (temperatura da água > 25) e (água está limpa) então
pessoa pode nadar
fimse
Exemplo em Java:
if (agua.temperatura>25) && (agua.situacao==‘L’)
pessoa.nadar = true ;
Leia mais em:
JANDL JÚNIOR, Peter. Java 5: guia de consulta rápida. São Paulo : Novatec, 2006. 136
p, il. pg. 19.
Escolha a cor
verde : tenho esperança
vermelho : estou apaixonado
azul : está tudo tranquilo
A opção senão indica que nenhuma das opções anteriores foi validada.
A sintaxe em Java é:
91
switch <expressão> {
case 1 : <seqüência-de-comandos-1>
break;
case 2 : <seqüência-de-comandos-2>
break;
.
.
default : <seqüência-de-comandos-extra>
}
Em Java a expressão só pode ter como resultado um valor numérico inteiro, caractere ou
enumeração. Em Java a opção senão é denominada de default e é opcional. O break é
utilizado para finalizar o switch e deve ser usado em cada condição.
Exemplo simplificado de um algoritmo para escrever por extenso o sexo de uma pessoa
dada a digitação de F ou M:
Exemplo em Português Estruturado:
escolha sexo da pessoa
"F" : escreva ("Feminino")
"M" : escreva ("Masculino")
senão escreva ("Sexo não informado")
fimescolha
Exemplo em Java:
switch (pessoa.sexo) {
case 'F' : System.out.println("Feminino");
break;
case 'M' : System.out.println("Masculino");
break;
default : System.out.println("Não Informado");
}
JANDL JÚNIOR, Peter. Java 5: guia de consulta rápida. São Paulo : Novatec,
2006. 136 p, il. pg. 20.
Um exemplo para somar ou diminuir um valor a uma variável se ele for par ou ímpar é
apresentado a seguir:
92
Exemplo em Português Estruturado:
num = (x é par)? x + 1 : x - 1
Exemplo em Java:
int num = (x % 2 == 0) ? x++ : x--;
No exemplo se o valor x for par num receberá o valor de x acrescido de uma unidade.
Caso contrário receberá o valor de x diminuído de uma unidade.
JANDL JÚNIOR, Peter. Java 5: guia de consulta rápida. São Paulo : Novatec, 2006. 136
p, il. pg. 15.
93
5. Um matemático deseja verificar se determinados valores podem ser lados
de um triângulo. Em caso afirmativo, ele deseja saber qual é o tipo do
triângulo: eqüilátero (todos os lados iguais), isósceles (pelo menos dois
lados iguais), ou escaleno (nenhum lado igual)). Ele lembra que para ser
um triângulo, a soma do valor de dois lados tem que ser maior que a do
terceiro lado.
6. Na classe criada no exercício da lista anterior insira um método para
informar se o triângulo é ou não retângulo (h2= a2 + b2). Considere
também a possibilidade de não ser triângulo, considerando as mesmas
condições apresentadas naquele exercício.
7. Considerando duas pessoas da classe Pessoa criada no exercício da lista
anterior, informe a mais alta.
Sintaxe
Em Português Estruturado
Para contador de inicio a fim faça
Bloco de comandos
Fim para
Em Java
for (expressão 1; expressão 2; expressão 3)
bloco de comandos ;
IMPORTANTE:
94
Exemplo simplificado para ler e escrever 10 números:
Em Português Estruturado
para contador de 1 a 10 faca
leia (numero)
escreva (numero)
fimpara
Em Java
//declara a variável para ler e escrever o número
int numero;
//inicializa um objeto para leitura
Scanner sc = new Scanner(System.in);
//faz a repetição
for (int cont = 1; cont <=10; cont++) {
System.out.println("Digite um número");
//lê o número do teclado
numero = sc.nextInt();
//escreve o número no monitor de vídeo
System.out.println(numero);
}
JANDL JÚNIOR, Peter. Java 5: guia de consulta rápida. São Paulo : Novatec, 2006. 136
p, il. pg. 17.
Faça
calcule a média do aluno
Enquanto tem alunos
95
A sintaxe é:
Em Português Estruturado
enquanto <expressão-lógica> faça
<seqüência-de-comandos>
fim enquanto
ou
faça
<seqüência-de-comandos>
enquanto <expressão-lógica>
Em Java
while (expressão-lógica) {
<seqüência-de-comandos>
}
ou
do {
<seqüência-de-comandos>
} while (expressão-lógica);
IMPORTANTE:
Em Java
//declara a variável para ler e escrever o número
int numero;
//inicializa um objeto para leitura
Scanner sc = new Scanner(System.in);
//lê o número do teclado
System.out.println("Digite um número");
numero = sc.nextInt();
//enquanto o número digitado não for zero continua a repetição
while (numero <> 0) {
//escreve o número no monitor de vídeo
System.out.println(numero);
//lê outro número do teclado
System.out.println("Digite um número");
numero = sc.nextInt();
}
No exemplo apresentado pode ser observado o uso de um flag (0). O flag indica o fim de
um determinado conjunto de dados.
96
JANDL JÚNIOR, Peter. Java 5: guia de consulta rápida. São Paulo : Novatec, 2006. 136
p, il. pgs. 18 e 19.
97
todas as mensagens, mas sim sortear uma delas e exibir o resultado, a cada objeto
encontrado.
Adicione um último botão para que o robô volte à célula [0,0], ele monte uma nova
matriz de ordem N, porém transposta, e altere os valores dos objetos Numero para
refletir essa nova matriz.
98
tridimensional de inteiros que em cada posição guarda a quantidade de passageiros
transportados por hora, de determinado dia, de determinado mês. Assim a matriz é de
ordem 12 meses x 30 dias x 24 horas. Crie esta classe, que deve ter as seguintes
funcionalidades:
FUNCIONALIDADE Código de teste
PassageirosHora ph = new PassageirosHora();
a) adicione mais um passageiro em
determinada hora; ph.adiciona(1,1,13); // 13 horas de 1o de
Janeiro
b) retorne a quantidade de passageiros
transportados em determinado dia; int qtde = ph.quantosPassageiros(25,12); //
Natal
c) retorne o mês em que houve o menor
fluxo de passageiros. int mês = ph.mesMenorFluxo();
d) retorne o dia, mês e hora em que int[ ] momento = ph.picoTransporte();
houve a maior quantidade
transportada de passageiros;
99
10. RECURSOS NO FURBOT PARA DESENVOLVIMENTO DE JOGOS
Esta seção apresenta os recursos que o Furbot disponível para desenvolver jogos
simples. Todos os recursos aqui apresentados estão disponíveis a partir da versão 0.15.
A Figura 38 apresenta um exemplo de jogo do tipo PacMan desenvolvido utilizando os
recursos do FURBOT.
Ao executar o robô, você vai reparar que o sistema vai imprimindo o código “0” enquanto
nenhuma tecla for pressionada. Quando pressionar uma tecla o código dela é mostrado
na console, e em seguida volta a imprimir o código “0”. Esse exemplo mostra que ao
chamar o método ele tira o código que estava guardado, ou seja, se chamar duas vezes
seguidas, na segunda vez provavelmente não virá o mesmo código, e mais provável
ainda, deve vir o código “0”.
O código abaixo apresenta o uso desses dois métodos: cria dois novos Aliens (observe a
sintaxe usando a palavra reservada new) e adiciona-os no Mundo.
Alien alien1 = new Alien();
adicionarObjetoNoMundo(alien1, DIREITA);
Alien alien2 = new Alien();
adicionarObjetoNoMundoXY(alien2, 3, 4); // x = 3, y = 4
Atenção: a execução do sistema pára se tentar incluir o mesmo objeto duas vezes. Por
exemplo, o código abaixo faz parar o sistema.
101
Também é possível remover um objeto do mundo (esse é um recurso muito útil quando
algum elemento precisa sumir). O código abaixo apresenta o exemplo de como remover
um objeto que o robô encontrou.
102
registro de atividades (diga()) e para adicionar e remover objetos (como visto nas seções
anteriores).
Os objetos dessa classe podem ser adicionados durante a execução do robô, através dos
métodos adicionarObjetoNoMundo(...) ou adicionarObjetoNoMundoXY(...) ou mapeá-los
no XML. Para isso, basta usar o elemento <objeto> e no atributo class colocar o nome da
classe. Veja um exemplo no quadro abaixo. Aqui é criado um objeto com a classe Inimigo
numa posição aleatória.
Agora veremos como atribuir uma imagem a qualquer objeto do mundo (inclusive o robô:
você poderá atribuir uma imagem personalizada para seu robô). Para isso será
necessário implementar o método buildImage(). Veja como fazer esse método no quadro
abaixo.
public ImageIcon buildImage() {
return LoadImage.getInstance().getIcon("inimigo.png");
}
Observa como é bastante simples atribuir imagens aos objetos: basta informar o novo do
arquivo contendo a imagem. São aceitos arquivos no formato PNG, GIF e JPG. As
imagens precisam ter de preferência o tamanho de 50X50, que é a dimensão de cada
célula no mundo. O arquivo precisa estar na pasta do projeto (o mesmo local aonde você
vinha colocando os arquivos XML).
103
janela. Mas também é possível que se especifiquem velocidades diferentes para cada
objeto no mundo. Para isso utilizamos o método setVelocidade() conforme o exemplo no
quadro abaixo.
Alien1 alien = new Alien();
alien.setVelocidade(100);
adicionarObjetoNoMundo(alien, ACIMA);
....
setVelocidade(0);
10.5. SORTEIO
Para deixar um jogo interessante, existem momentos em que os objetos precisam sortear
algo, por exemplo, uma direção ou a velocidade do tiro. Para isso, você utilizará o método
sortear(). Esse método retorna um int. Por exemplo, o código abaixo sorteia um número e
faz o resto da divisão por quatro. De acordo com o resultado, que fica entre 0 e 3, o robô
toma uma decisão.
int sorteio = sortear() % 4;
switch(sorteio) {
case 0 : andarAcima(); break;
case 1 : andarAbaixo(); break;
case 2 : andarEsquerda(); break;
case 3 : andarDireita(); break;
}
104
método termina a execução do robô!!! Como poderíamos implementar a troca de
mundos?
A partir da versão 0.15 tem uma nova forma de iniciar o MundoVisual. Observe o código
no quadro abaixo.
public static void main(String[] args) {
MundoVisual.iniciarSequencia(RoboJogavel.class, "PrimFase.xml", "SegFase.xml");
}
Para programar a troca de mundos durante a execução você precisará utilizar o método
proxMundo(int) da classe MundoVisual. Esse método sinaliza ao mundo para carregar
uma nova configuração automaticamente quando acabar a inteligência do robô. O
parâmetro indica o código do mundo a ser carregado, de acordo com os parâmetros
passados no método iniciarSequencia(). O primeiro mundo é de código 0, o segundo de
código 1 e assim por diante.
if (MundoVisual.getMundo() == 0) {
MundoVisual.proxMundo(1);
}
É importante chamar a atenção de que toda vez que um novo mundo é criado, todos os
objetos desse mundo são recriados, inclusive o robô. Existem situações em que
precisamos transferir dados de uma fase para outra, e infelizmente não tem como guardar
no robô. Uma alternativa criada para resolver esse problema é fazer com que o
MundoVisual mantenha esses dados. Existem três métodos que você utilizará para isso.
Vamos explicar esses métodos através do código abaixo. O método setAtributo() guarda
um valor de qualquer tipo (int, boolean, String, Alien, etc) e associa ele com um nome.
105
Esse nome deve ser único. Se você utilizar duas vezes, o valor que tinha antes é perdido.
O método temAtributo() verifica se existe um valor guardado com o nome passado por
parâmetro. E o método getAtributo() retorna o valor guardado com o nome passado como
parâmetro.
MundoVisual.setAtributo("x", getX());
MundoVisual.setAtributo("y", getY());
...
if (MundoVisual.temAtributo("x")) {
int x = MundoVisual.getAtributo("x");
int y = MundoVisual.getAtributo("y");
}
Para tentar minimizar (e não corrigir!!) o impacto destes problemas, utilizem a solução a
seguir. Em cada entidade que se movimenta declarar um atributo:
Em cada entidade que se movimenta declarar um método que permite sinalizar que a
mesma não deve continuar a execução. Exemplo:
106
public void entidadeMorreu() {
estouVivo = false;
} .....
O efeito desta solução é que a entidade “viva” continuará executando até retornar ao teste
do comando while. Neste momento ela pára de executar. Dependendo da complexidade
da lógica a ser executada, é possível que o comportamento da entidade fique errôneo por
um tempo equivalente ao tempo necessário para executar os comandos restantes até o
final do comando while.
107
10.8. CONSIDERAÇÕES FINAIS
É importante chamar a atenção de que o Furbot não é uma engine de jogos, mas um
conjunto de classes para facilitar o aprendizado de programação Java. Os problemas de
desempenho e alguns de apresentação são inevitáveis para garantir um ambiente fácil de
programar. Na medida do possível estaremos resolvendo esses problemas.
Aconselho que você destrinche esse documento: entenda todos os parágrafos e todos os
códigos. Programe para testá-los. Anote as dúvidas e procure pelos professores,
monitores ou alunos mais experientes.
10.9. EXEMPLO
import javax.swing.ImageIcon;
import br.furb.furbot.Direcao;
import br.furb.furbot.ObjetoDoMundoAdapter;
import br.furb.furbot.suporte.LoadImage;
public class SeguidorDeRobo extends ObjetoDoMundoAdapter{
private boolean fim = false;
public ImageIcon buildImage() {
return LoadImage.getInstance().getIcon("imagens/alienmovel.png");
}
public SeguidorDeRobo() {
setVelocidade(0);
}
public void executar() throws Exception {
Direcao direcao = descobrirDirecao();
while (ehFim(direcao) == false) {
obterLetra();
andar(direcao);
}//while
passoNaExtremidade(direcao);
diga(palavra);
fim = true;
}
private String palavra = "";
private void obterLetra() {
Letra letra = getObjeto(AQUIMESMO);
palavra += letra.getLetra();
}
private void passoNaExtremidade(Direcao direcao){
if (direcao == ABAIXO || direcao == ACIMA) {
andarEsquerda();
} else {
andarAbaixo();
}
private void andar(Direcao direcao) {
switch (direcao) {
case ABAIXO: andarAbaixo(); break;
case ACIMA: andarAcima(); break;
case DIREITA: andarDireita(); break;
default : andarEsquerda();
}//switch
}
108
private Direcao descobrirDirecao() {
if (ehVazio(ABAIXO) == false)
return ABAIXO;
if (ehVazio(ACIMA) == false)
return ACIMA;
if (ehVazio(ESQUERDA) == false)
return ESQUERDA;
return DIREITA;
}
public boolean finalizou() {
return this.fim ;
}
}//class }//SeguidorDeRobo
109
11. INSTALAÇÃO DO AMBIENTE DE DESENVOLVIMENTO: JDK E NETBEANS
O material desta seção foi desenvolvido pelo Prof. Mauricio Capobianco Lopes e pela
monitora Fernanda Gums e tem por objetivo descrever os procedimentos para instalação
do ambiente de programação orientada a objetos: JDK e IDE Netbeans.
Assim sendo, para criar as aplicações Java, poderemos utilizar a ferramenta Netbeans. A
ferramenta permite a edição dos programas em Java e proporciona um ambiente de
desenvolvimento que facilita o aprendizado da linguagem e dos conceitos associados.
110
2. Fazendo o download diretamente da página dos fornecedores das ferramentas: IDE
NetBeans e JDK.
Clique no link “Get the JDK download” e você será remetido para uma página similar à
página abaixo (Figura 40):
Será apresentada a janela (Figura 45) que contém os termos de licença de uso do
software Sun Download Manager. Clique no botão “Accept”.
FIGURA 45- TERMOS DE LICENÇA DO SOFTWARE.
Neste momento será apresentada uma janela (Figura 47) contendo as informações sobre
o processo de download do software selecionado. Como geralmente os arquivos a serem
baixados são relativamente grandes, o tempo para download vai depender da velocidade
de conexão com a internet que você possui. A qualquer momento você pode selecionar a
opção “Pause” para suspender temporariamente o download ou “Parar” para parar o
processo.
Depois que o arquivo tenha sido baixado com sucesso, inicie a instalação.
Se você vai executar o NetBeans em uma máquina com sistema operacional Windows,
clique no botão “Download NetBeans IDE”, baixe o arquivo e execute-o. Se você vai
executar o NetBeans em uma máquina com outro sistema operacional (Linux, MacOS,
Solaris) clique no link “Other Systems & Languages”, escolha o instalador, baixe o arquivo
e siga as instruções da seção 11.2.4.
11.2.4.2. LINUX
Em computadores com Linux, o método de preferência para instalar o NetBeans IDE é
usar o instalador binário.
$ chmod +x seu_binário_executável
$ ./seu_binário_executável
118
Observação: Verifique novamente se substituiu seu_binário_executável pelo nome real do
arquivo do binário que foi baixado.
4. No assistente de instalação, escolha uma resposta para o Contrato de Licença e
clique em Próximo.
5. Especifique um diretório vazio dentro do qual será instalado o NetBeans IDE e
clique em Próximo.
6. Escolha o JDK que o IDE usará na lista de JDKs compatíveis e clique em Próximo.
11.2.5. RESULTADOS
Você deve ter o Java e o IDE NetBeans instalados no seu sistema.
119
12. ANEXO 1 - LEIA MAIS EM ...
12.1. MODELAGEM DE PROBLEMAS
LARMAN, Craig. Utilizando UML e padrões: uma introdução à análise e ao projeto
orientados a objetos. 2. ed. Porto Alegre : Bookman, 2004. 608 p, il
CORMEN, Thomas H. Algoritmos: teoria e prática. Rio de Janeiro : Campus, 2002. xvii,
916p, il. Tradução de: Introduction to algorithms.
MANZANO, Jose Augusto N. G; OLIVEIRA, Jayr Figueiredo de. Algoritmos : logica para
desenvolvimento de programacao. Sao Paulo : Erica, 1996. 265p.
120