CURSO BSICO DE JAVA

Superintendncia Regional de Ensino

Varginha

Autor: Mauricio Kuris

Analista Educacional Informtica

Curso Bsico de JAVA

PARTE I Comeando do incio...............................................................................................3

O que JAVA?..............................................................................................................................3
O que um Programa?.................................................................................................................3
O que uma Linguagem de Programao?..................................................................................4
A Evoluo das Linguagens de Programao..............................................................................5
JAVA: uma Linguagem de Programao revolucionria..............................................................7
A Mquina Virtual Java (JVM)..................................................................................................10
PARTE II Fundamentos da Programao........................................................................................14
Programao Estruturada X Programao Orientada a Objeto................................................14
ALGORITMO: escrevendo instrues que os outros vo seguir...............................................15
ESTRUTURA DE DADOS: organizando as informaes.........................................................18
Modularizao X Abstrao.....................................................................................................20
Classes e Objetos: trazendo o mundo real para dentro do computador......................................24
Criando e executando um programa no console........................................................................29
Criando e executando um programa no BlueJ............................................................................32
PARTE III Regras de Sintaxe..........................................................................................................38
Comentrios................................................................................................................................38
Definio de Classe....................................................................................................................38
Definio de Mtodo..................................................................................................................39
Invocao de Mtodo.................................................................................................................40
Mtodo Principal e Mtodo Construtor......................................................................................41
Declarao de variveis..............................................................................................................42
Instruo de Atribuio..............................................................................................................45
Criando Instncias de Classe......................................................................................................46
Sobrecarga de Mtodos..............................................................................................................48
Operadores Aritmticos, Relacionais e Lgicos.........................................................................51
Operadores Aritmticos combinados com Atribuio................................................................56
Concatenao de Strings............................................................................................................56
Incremento e Decremento..........................................................................................................57
Instrues e Blocos de Instrues..............................................................................................57
Instrues de Deciso.................................................................................................................59
Instrues de Repetio (loop)...................................................................................................60
Importando classes das bibliotecas do Java...............................................................................64
Criando um arquivo jar...............................................................................................................67
Concluso...................................................................................................................................68
Bibliografia.................................................................................................................................69
APNDICE A Dinmica com BlueJ...............................................................................................70
APNDICE B Exemplos de Programas Comentados.....................................................................74
Programa 1 - ProgramaComEco.................................................................................................74
Programa 2 - ProgramaGraficoComEco....................................................................................76
Programa 3 CalculaFatorial.....................................................................................................77
Programa 4 CalculaFatorial2...................................................................................................79
Programa 5 CalculaRendimentoCarro.....................................................................................81
Programa 6 ImprimeInvertido.................................................................................................82
Programa 7 ParOuImpar..........................................................................................................85

Curso Bsico de JAVA

PARTE I Comeando do incio

O que JAVA?
Java uma linguagem de programao muito poderosa, que serve para desenvolver
programas que rodem em qualquer computador. Vamos detalhar este conceito mais adiante,
mas primeiro vamos entender o que um programa e como ele funciona.

O que um Programa?
Se voc j usou um computador provavelmente usou um dos programas mais
conhecidos como editor de texto (Word, Writer, etc), navegadores de internet (Internet
Explorer, Firefox, etc), tocadores de msica ou DVDs (Windows Media Player, etc) ou outros.
Tomemos como exemplo um editor de textos (como o Word). Quando aprendemos a
usar o editor de texto basicamente temos que aprender a usar os menus e botes que
aparecem na tela principal. No precisamos saber o que est por trs dos botes que clicamos.
Quando selecionamos uma palavra no texto que estamos escrevendo e clicamos no boto
negrito, sabemos que a palavra selecionada fica em negrito, mas no paramos para pensar
em porque isso acontece.
Um computador foi feito para executar instrues. Se ns ligamos o computador e no
passamos nenhuma instruo a ele, ele no faz nada. No passado, os computadores eram bem
simples e quando eram ligados apresentavam uma tela preta com um cursor piscando, o que
era a forma dele dizer ao usurio Estou esperando que voc me passe alguma instruo.
Naquele tempo anda no existiam Sistemas Operacionais grficos como o Windows com
figuras, janelas e botes para serem clicados com o mouse. Alis, nem mouse existia, o
computador era praticamente uma mquina de escrever incrementada, na qual voc passava
as instrues digitando no teclado e aps teclar ENTER o computador executava a instruo
que voc tinha digitado, apresentava o resultado na tela (em forma de texto) e ficava
novamente piscando o cursor espera de novas instrues.
Ento se voc digitasse uma instruo como Mostre a data e a hora e teclasse
ENTER ele mostraria a data e a hora e depois ficaria piscando espera de outra instruo. Se
voc digitasse Escreva BOM DIA na tela, ele escreveria e ficaria piscando e esperando
novamente. Se voc colocasse um disquete no leitor de disquetes e digitasse copie o arquivo
manual.doc para o disquete ele copiaria e ficaria novamente piscando esperando a prxima
instruo.
Se voc tinha apenas algumas instrues para passar para ele, tudo bem. Mas, imagine
que para realizar alguma tarefa mais complexa, como escrever um relatrio, por exemplo,
voc precisasse passar dezenas, ou mesmo centenas dessas instrues, na base do passainstruo-e-tecla-ENTER, passa-outra-instruo-e-tecla-ENTER, e assim por diante, digamos,
duzentas vezes. J imaginou o trabalho? Agora imagine que no dia seguinte voc tivesse que
fazer outro relatrio e tivesse que passar as mesmas duzentas instrues de novo?
Pois , antes de inventarem os programas, no tinha jeito. A cada vez que voc quisesse
repetir aquela operao, tinha que passar as instrues para o computador, uma de cada vez e
aguardar que ele executasse a instruo antes de passar para a prxima e assim
sucessivamente.
Foi a que algum criou um arquivo e colocou em cada linha do arquivo uma instruo.
E disse ao computador Siga as instrues do arquivo. Pronto, estava criado o programa. A
partir da bastava passar ao computador uma nica instruo Execute o arquivo tal que ele
encontrava o arquivo, lia uma linha de cada vez e ia executando uma a uma. Ou seja, no
nosso exemplo do relatrio, voc s ia ter o trabalho de digitar as duzentas instrues no
arquivo uma nica vez e salvar o arquivo. Depois, a cada vez que voc quisesse criar um

Curso Bsico de JAVA

relatrio, bastaria dizer ao computador para executar as instrues do arquivo (em

informatiqus, executar o programa ou rodar o programa) e pronto.
Com o tempo os computadores foram ficando mais complexos e os programas tambm,
para poder acompanhar a evoluo dos computadores. Surgiram os sistemas operacionais
grficos (como o Windows) que nada mais do que um enorme programa que controla todos
os recursos da mquina e que colocado para rodar quando voc liga o computador.
Voltando ao exemplo do editor de texto, quando voc clica no cone do Word voc est
dizendo ao computador Execute o programa que faz o Word funcionar. E a primeira coisa que
esse programa faz mostrar a janela principal do Word e em seguida fica esperando voc
fazer alguma coisa. E dependendo o que voc fizer, o programa vai dizendo ao computador o
que ele tem que fazer para alcanar o resultado esperado. Ento se clicarmos no boto
negrito o programa passa ao computador a instruo para a palavra selecionada aparecer em
negrito na tela. Se, quando estamos digitando uma frase, chegamos ao final da linha e
continuamos digitando sem parar, o Word pula para a linha seguinte. Isto ocorre porque o
programa disse ao computador para fazer isso. E assim por diante, o programa tem que prever
todos as possibilidades de interao com o usurio e para cada uma delas, passar ao
computador as instrues necessrias.
Quem cria o programa o programador. Ele tem que escrever as instrues que sero
passadas ao computador para cada ao que o usurio executar na tela. Para escrever essas
instrues, ou seja, para escrever um programa, o programador usa uma linguagem de
programao.
E o que uma linguagem de programao? o que veremos no prximo tpico.

O que uma Linguagem de Programao?

No tpico anterior dissemos que o usurio passava ao computador instrues como
mostre a data e a hora ou copie o arquivo para o disquete. Do mesmo modo o
programador, ao criar ao programa, escrevia instrues como pule para a prxima linha ou
mostre a palavra selecionada em negrito.
claro que isso no acontecia com instrues escritas desse modo. O computador
simplesmente no entende a nossa lngua. Ele tem uma linguagem prpria que composta de
palavras escritas com 0s (zeros) e 1s (uns). Da mesma forma que ns nos comunicamos
juntando letras para formar palavras e frases, o computador faz a mesma coisa juntando os
nmeros 0 e 1. S que para escrever os nossos textos, usamos um alfabeto com 26 letras,
dez nmeros e diversos caracteres especiais, como parnteses, vrgula, ponto de exclamao,
etc. O computador usa apenas 0s e 1s.
Tomemos como exemplo o boto Iniciar, da tela principal do windows. O que ns
compreendemos como uma seqncia de 7 letras: INICIAR, o computador entende
como uma seqncia de 56 dgitos:
01001001010011100100100101000011010010010100000101010010. Da mesma forma que a
palavra INICIAR no significa nada para o computador,
01001001010011100100100101000011010010010100000101010010 no significa nada para
ns.
como quando tentamos nos comunicar com algum que fala outra lngua, como por
exemplo, o chins. Se falarmos alguma coisa em portugus para um chins, ele no entende,
e vice-versa. Para que possamos nos comunicar precisamos de um tradutor a quem possamos
nos dirigir em portugus para que ele traduza para o chins. Da mesma forma, foram criados
programas-tradutores para traduzir o que escrevemos usando nossa lnguagem, para uma
seqncia de 0s e 1s, que a linguagem que o computador entende.

Curso Bsico de JAVA

S que se o programa-tradutor fosse traduzir a nossa linguagem do jeito que ns

falamos, teria que conhecer todas as palavras que usamos (o dicionrio Aurlio, por exemplo,
tem mais de 435.000 palavras) alm das regras de sintaxe, concordncia, regncias verbal e
nominal, etc. Seria um programa enorme e muito lento. Hoje, os computadores tm memrias
medidas em Gigabytes (1 Gigabyte = 1.000.000 Kbytes), mas no passado os computadores
tinham memrias de poucas dezenas de Kbytes. Simplesmente no seria possvel escrever um
programa-tradutor que coubesse na memria do computador. A soluo foi criar uma verso
reduzida de nossa linguagem, com apenas algumas dezenas de palavras e algumas poucas
regras de sintaxe, que fossem suficientes para podermos passar as instrues ao computador
e que no fosse muito difcil para o programa-tradutor traduzir. Como tinha menos palavras
para conhecer e traduzir, o programa-tradutor era bem mais simples e cabia tranqilamente na
pequena memria do computador, alm de ser bem mais rpido para executar.
Para ns tambm, no era muito difcil aprender aquela verso reduzida de nossa
prpria lngua, com menos palavras e regras para decorar.
Ao passar as instrues ficava parecendo Tarzan falando com o computador: Mim
querer computador imprimir relatrio, mas dava conta do recado. claro que se os
computadores tivessem nascido e se desenvolvido no Brasil, naturalmente teramos os
programas escritos em portugus, ou em verses reduzidas do portugus.
Como isto aconteceu nos Estados Unidos, o idioma escolhido para fazer essas verses
reduzidas acabou sendo o ingls. Foi assim que nasceram as linguagens de programao, que
so essas verses reduzidas do ingls, e por isso que todas as linguagens de programao
que conhecemos esto em ingls.

A Evoluo das Linguagens de Programao

As primeiras linguagens de programao no eram to parecidas com a nossa prpria
linguagem como so hoje. Elas estavam mais prximas da linguagem do computador. As
instrues eram passadas usando uma palavra-chave (mnemnico) seguida ou no de
nmeros. A figura 1 mostra um trecho de um programa em Assembly que pode ser traduzido
para: some o valor das 3 variveis e armazene o resultado na primeira varivel.
add 3,2,3
add 2,1,2
add 1,2,3

Fig. 1

000011010011000010001010000001010011

var1:= var1 + var2 + var3;

Fig. 2

Fig. 3

Era bem mais trabalhoso escrever um programa porque eram necessrias muitas
dessas instrues curtas para realizar qualquer tarefa menos as mais simples. Alm disso,
eram linguagens muito difceis de aprender porque no eram to prximas da nossa
linguagem. De qualquer modo era bem mais fcil do que ficar digitando centenas de 0s e 1s. A
figura 2 mostra o mesmo trecho da figura 1 em linguagem de mquina. Essas linguagens eram
chamadas de Linguagens de Baixo Nvel porque estavam mais prximas da linguagem do
computador do que da nossa. Dentre as linguagens de baixo nvel, a mais usada era o
Assembly.
Com o tempo foram surgindo as Linguagens de Alto Nvel, que esto mais prximas da
nossa linguagem do que da linguagem do computador. Eram linguagens mais fceis de
aprender e usar porque era quase como re-aprender a falar usando um conjunto reduzido de
palavras e regras de sintaxe, regncia e concordncia. Para ilustrar, a figura 3 traz a mesma
instruo das figuras 1 e 2, escrita em PASCAL.
Dentre as linguagens de alto nvel que mais se popularizaram podemos citar: o
FORTRAN, o COBAL e o PASCAL. Cada uma tinha caractersticas que facilitavam um uso
especfico e tinham suas legies de fs.

Curso Bsico de JAVA

O COBOL, por exemplo, tinha recursos que facilitavam armazenar e recuperar

informaes e transform-las em relatrios. Por isso eram muito usadas em bancos e
escritrios de contabilidade. O FORTRAN tinha recursos poderosos para clculos de preciso e
era muito usado em universidades e instituies de pesquisa. O PASCAL era uma linguagem de
uso geral e era to bem organizada que era a linguagem preferida para ensinar programao
nas escolas e faculdades.
Todos esses programas interagiam com os usurios de forma muito simples. Para
passar informaes para o programa, o usurio digitava os dados via teclado em modo texto.
Ou ento o programa lia os dados em um arquivo armazenado no computador ou em um
dispositivo de armazenamento, como um disquete ou fita magntica. Para enviar dados ao
usurio, o programa mostrava os dados na tela (em modo texto) ou imprimia em uma
impressora.
A estrutura desses programas tambm era muito simples. As instrues eram escritas
em seqncia e havia algumas estruturas de deciso (SE condio--verdadeira ENTO faa
isso SENO faa aquilo) e de repetio (FAA isso ENQUANTO condio--verdadeira). Essas
linguagens eram chamadas de Linguagens de Programao Estruturadas (ou Procedurais) por
que seguiam uma estrutura lgica e bem definida.
Com a evoluo dos computadores, o surgimento dos Sistemas Operacionais grficos
(Windows) e o crescimento da internet a interao com os usurios ficou bem mais complexa.
Agora o programa recebe informaes via teclado, cliques do mouse, arquivos, dispositivos de
comunicao ou diretamente de outro computador atravs de uma rede local ou da internet. E
responde atravs de texto, imagens, fotos, sons e transmisso via rede. Para lidar com toda
esta riqueza de informaes, a forma de escrever os programas tambm evoluiu e surgiu o
conceito de Orientao a Objetos e com eles as Linguagens de Programao Orientadas a
Objetos.
Tomemos como exemplo um programa para controlar os dados de uma biblioteca.
Temos que registrar informaes acerca dos livros (ttulos, autor, etc) dos usurios (n de
matrcula, nome, telefone, etc) alm das aes feitas por eles (os usurios podem pegar livros
emprestados, podem devolver livros, podem pagar a taxa de mensalidade, etc). As linguagens
de programao estruturadas tinham formas de representar as caractersticas dos objetos
(usurio tem nome, n matrcula) mas no as aes dos objetos (usurio devolve livros, paga
mensalidade). Essas aes eram representadas atravs de instrues escritas usando as regras
daquela linguagem.
A forma de escrever o programa variava em funo da linguagem escolhida. Se eu
fosse escrever em FORTRAN, que uma linguagem que privilegia as descries de dados, eu
escreveria de um jeito. Se fosse escrever em PROLOG que uma linguagem baseada em
tomadas de decises, eu escreveria de outro. E assim por diante.
Com o conceito de Orientao a Objetos, os objetos (livros, usurios) so representados
de forma completa, armazenando ao mesmo tempo as informaes sobre suas caractersticas
(nome) e as aes que podem realizar (pegar livro emprestado). O programador pode bolar os
seus programas usando esta representao e na hora de escolher uma linguagem para
escrever as instrues, pode escolher qualquer Linguagem de Programao Orientada a
Objetos. Ele apenas teve que fazer pequenas adaptaes em funo da linguagem escolhida
(cada linguagem tem regras prprias de como escrever as instrues), mas a estrutura do
programa e a representao dos dados a mesma. Este conceito de representao de objetos
atravs de suas aes e caractersticas ser explicado em detalhes quando formos estudar as
Classes e Objetos.
Dentre as Linguagens de Programao Orientadas a Objetos, uma se destacou
provocando uma verdadeira revoluo no mundo da programao: o JAVA. Vamos saber
porque no prximo tpico.

Curso Bsico de JAVA

JAVA: uma Linguagem de Programao revolucionria

Vamos recapitular o que vimos no tpico sobre programas: o computador no entende
a nossa linguagem - feita de letras, nmeros e caracteres especiais e ns no entendemos a
linguagem do computador feita de zeros e uns. Para que pudssemos nos comunicar foi
necessrio criar um programatradutor. E para facilitar a tarefa de traduo, foi criada uma
verso reduzida da nossa linguagem com poucas palavras e regras. Esse processo de traduo
conhecido como compilao e os programastradutores so chamados de compiladores.
Quando era criada uma linguagem de programao tinha que ser criado tambm o
compilador para aquela linguagem. Um programador que quisesse escrever seus
programas usando aquela linguagem teria em primeiro lugar que aprender as regras e o
vocabulrio daquela linguagem. Em segundo lugar teria que instalar o compilador no seu
computador. Ai ento ele estaria pronto para escrever e executar seus programas escritos
naquela linguagem.
Para escrever os programas bastava abrir um editor de texto, escrever as instrues de
acordo com as regras da linguagem escolhida e salvar o arquivo. Este arquivo contendo as
instrues escritas em linguagem de alto nvel chamado de cdigofonte, ou simplesmente
cdigo. Em seguida era preciso compilar (traduzir) o cdigofonte e isso era feito executando
o compilador. O compilador lia as instrues do cdigofonte e criava um arquivo aonde ia
colocando as instrues correspondentes em linguagem de mquina (0s e 1s). Ao final do
processo, tnhamos um arquivo cheio de 0s e 1s. Este arquivo conhecido como cdigo
binrio ou executvel. Quando rodamos (executamos) um programa, este executvel que
utilizado pelo computador para seguir as instrues.
Este processo permanece at hoje: usamos um editor para escrever o cdigofonte,
compilamos o cdigofonte e rodamos o executvel.
Temos sempre dois arquivos: o arquivo contendo o cdigofonte que ns podemos ler
e compreender, mas o computador no e o cdigo binrio - que ns no compreendemos,
mas o computador sim. Se fizermos alguma alterao no nosso cdigofonte ser necessrio
compil-lo novamente para gerar um novo arquivo executvel (cdigo binrio) contendo as
alteraes.
At aqui est tudo bem? Ento vamos complicar um pouco.
O compilador, para fazer o trabalho de traduo, precisava conhecer a linguagem de
programao e a linguagem do computador. Conhecer a linguagem de programao era fcil
porque a mesma equipe que desenvolvia a linguagem de programao, desenvolvia ao mesmo
tempo o compilador. Restava conhecer a linguagem do computador e era aqui que a coisa
ficava complicada. No existia uma linguagem de mquina padro que fosse comum a todos os
computadores. Cada fabricante desenvolvia a sua.
Os computadores eram desenvolvidos segundo uma estrutura de componentes, peas e
circuitos que era prpria de cada fabricante. Cada fabricante tinha que desenvolver todos os
componentes da sua marca. Assim, quem tinha um computador da IBM s poderia usar
componentes da marca IBM no seu computador. Se tivesse uma promoo muito boa de
monitores Apple (marca concorrente), voc no poderia aproveitar porque os monitores da
Apple eram incompatveis com o seu computador IBM. O mesmo com teclados, drives de
disquete, etc, at mesmo com impressoras.
Do mesmo modo, as instrues de mquina, ou seja, a linguagem de mquina, era
definida em funo do padro de cada fabricante. Cada marca de computador tinha a sua
prpria linguagem de computador. Assim, a mesma seqncia de 0s e 1s podia significar uma
coisa para um computador de uma marca e outra coisa para outro computador de outra
marca. Por exemplo, a seqncia 010011101 poderia significar, para um computador IBM,
uma instruo para somar dois nmeros. A mesma seqncia, para um computador Apple,
poderia ser entendida como uma instruo de subtrao. Era tudo escrito com 0s e 1s mas
cada computador compreendia de forma diferente.

Curso Bsico de JAVA

O mesmo acontece com a nossa linguagem. Se pegarmos a palavra cola, por exemplo.
Em portugus cola significa substncia adesiva. Mas se eu for para a Argentina ou Espanha,
as pessoas vo entender outra coisa, porque cola em espanhol quer dizer rabo, cauda de
animal. E se eu for para os EUA, eles entendem uma coisa diferente, porque cola em ingls
quer dizer bebida gasosa. a mesma seqncia de quatro letras, mas cada linguagem
compreende de uma forma diferente.
Voltando ao nosso compilador, ns vimos que para poder fazer a traduo, o compilador
tinha que conhecer a linguagem de programao e a linguagem do computador. A linguagem
de programao era uma s porque cada linguagem tinha o seu prprio compilador
desenvolvido sob medida para ela (um compilador PASCAL s traduz programas escritos em
PASCAL, um compilador COBOL s traduz programas escritos em COBOL, e assim por diante).
Mas a linguagem de mquina era diferente dependendo do fabricante. Como resolver? Simples.
O desenvolvedor da linguagem de programao escolhia um padro de computadores e criava
seu compilador para aquele padro. Com isso, a linguagem ficava restrita quele padro, s
podendo ser usada nele. Quem comprasse um computador IBM s poderia rodar nele os
programas escritos nas linguagens de programao compatveis com o padro IBM. Quem
comprasse um computador da Apple teria que escolher programas escritos em outras
linguagens, desenvolvidos para rodar na Apple.
Essa estrutura de circuitos, componentes e etc., (hardware) bem como o sistema
operacional e programas que fazem o computador funcionar (software), esse padro que
variava de acordo com o fabricante chamado de plataforma.
Com o tempo, alguns fabricantes desistiram de suas plataformas e passaram a fabricar
os seus componentes seguindo o padro estabelecido por outro. Foi o que aconteceu quando a
IBM abriu o seu padro para que outros pudessem copiar. O que poderia parecer loucura,
acabou se revelando uma estratgia genial porque vrios fabricantes de componentes
(impressoras, monitores, teclados, etc) comearam a fabricar seus componentes para o padro
IBM. Com o aumento da oferta os preos caram e cada vez mais as pessoas compravam
computadores IBM porque tinha mais oferta de componentes de vrios fabricantes e preos
mais baixos, todos compatveis com o seu computador. claro que alm dos componentes,
surgiram fabricantes que faziam no apenas um teclado ou mouse, mas todo um computador
seguindo o padro IBM e passando a concorrer diretamente com os computadores fabricados
pela prpria IBM. Eram os clones IBM. Mas sempre houve, como hoje, quem preferisse
comprar um produto de marca a comprar um produto genrico. Com isso as vendas da IBM
dispararam e o padro dominou o mercado.
Outros fabricantes que no aderiram plataforma IBM, ou faliram ou mantiveram sua
plataforma fechada. o caso da Apple que hoje fabrica os computadores Mac. A Apple tem que
desenvolver tudo, desde a placa-me at o software. No existem vrios fornecedores para
voc comparar preos. Ou voc compra deles ou no. por isso que os Mac so to mais caros
em comparao com outros computadores.
Atualmente existem apenas quatro ou cinco plataformas (hardware e software) que
dominam o mercado. Com este nmero reduzido de plataformas uma Linguagem de
Programao no precisa mais ficar presa a um nico padro, como no passado. Ao invs de
escolher uma nica plataforma e criar um compilador para ela, o que os desenvolvedores
fazem criar um compilador para cada plataforma. Por exemplo, a linguagem Perl tem um
compilador Perl para Windows, outro para Linux, outro para Solaris e outro para Mac. Essas
linguagens so chamadas de Linguagens Multiplataforma, justamente porque desenvolveram
compiladores para cada uma das plataformas existentes. Agora um programador pode escolher
qualquer linguagem multiplataforma para escrever seus programas, pois sabe que poder
rod-los em qualquer plataforma.
S que tem mais um pequeno detalhe: lembram que ns vimos que o programador
escreve o cdigofonte e depois tem que compilar este cdigo-fonte para gerar o cdigobinrio, que o cdigo que o computador entende? E que cada computador, dependendo da
sua plataforma, entende o cdigo-binrio (a seqncia de 0s e 1s) de maneira diferente? Isto

Curso Bsico de JAVA

significa que o cdigo-binrio que foi gerado por um compilador Windows no poder ser
usado para rodar o programa em um computador Linux, nem em um Mac e nem em um
Windows, porque eles iro entender tudo errado. Para rodar em uma mquina Linux, o
programador ter que compilar o cdigofonte outra vez, usando um compilador Linux, que ir
gerar um cdigo binrio Linux, que os computadores Linux entendem. E o mesmo processo
para os computadores Mac e Windows.
O cdigofonte o mesmo. S o que vai mudar so os cdigos-binrios. Precisa de um
binrio diferente para cada tipo de plataforma. Pode parecer meio trabalhoso, mas melhor do
que ficar preso a uma nica plataforma.
Para ajudar a compreender, vamos fazer uma comparao com a nossa linguagem.
Imaginemos que eu sou um escritor e escrevi um livro para ser vendido aqui no Brasil. Se eu
no quiser que o meu livro fique encalhado nas prateleiras, claro que vou ter que escrever
em portugus. Agora suponhamos que eu fechei um contrato com editoras de outros pases
para vender meus livros na Itlia, Rssia e China. Ora, eu no posso enviar meus livros em
portugus porque ningum vai entender nada. Ento eu contrato um tradutor (compilador) de
italiano que vai ler o meu livro em portugus (cdigofonte) e escrever a verso do livro em
italiano (cdigo-binrio). Agora eu posso vender (executar) a verso em italiano do livro
porque todas as pessoas (computadores) que vivem naquele pas (plataforma) vo conseguir
entender.
Porm eu no posso vender essa verso em italiano na Rssia, pois os russos no vo
entender. Ou seja, eu no posso aproveitar o trabalho de traduo (compilao) que j foi
feito. Eu tenho que chamar um outro tradutor (compilador) para traduzir o meu livro do
portugus (cdigofonte) para o russo (cdigo-binrio) de modo que as pessoas
(computadores) que vivem na Rssia (plataforma) consigam entender. E assim por diante, o
mesmo tem que ser feito para a China ou qualquer outro pas (plataforma) onde eu queira
vender meu livro.
Eu s precisei escrever o meu livro (programa) uma nica vez usando a Lngua
Portuguesa (linguagem de programao). Mas o processo de traduo (compilao) que
transforma o meu livro do portugus (cdigofonte) para outro idioma (cdigo-binrio) teve
que ser feito vrias vezes, uma para cada pas (plataforma) que escolhi para vender (executar)
meu livro (programa).
Ficou claro? Ento vamos seguir em frente.
Bom, e a surgiu no mercado a linguagem JAVA. Seria de se esperar que os criadores
do Java fizessem como as outras linguagens e criassem um compilador Java para cada
plataforma existente. Mas eles fizeram uma coisa diferente: criaram um conceito chamado
Mquina Virtual Java, a JVM (a sigla vem do ingls, Java Virtual Machine). Graas JVM, os
programadores no precisavam mais compilar vrias vezes o seu cdigofonte, uma vez para
cada plataforma. Escrevendo seu programa em Java, bastava compilar uma nica vez e o
cdigo resultante poderia ser executado em qualquer computador de qualquer plataforma.
Essa caracterstica era enfatizada pelo seu slogan: escreva uma vez, execute em qualquer
lugar.
Esta praticidade incomparvel fez do Java um sucesso instantneo. Lanado em maio
de 1995, Java foi adotado mais rapidamente do que qualquer outra linguagem de programao
na histria da computao. Em 2003, o Java atingiu a marca de 4 milhes de desenvolvedores
em todo o mundo. Ele continuou crescendo e hoje uma referncia no mercado de
desenvolvimento de software, estando presente em toda parte: desde mainframes, sistemas
operacionais e navegadores de internet, at celulares, palmtops e cartes inteligentes entre
outros.
Mas espere a! Se o programador tinha que compilar o seu cdigofonte escrito em Java
e como resultado da compilao tinha um cdigo executvel, igualzinho acontecia nas outras
linguagens, como que computadores de outras plataformas conseguiam entender aquele

Curso Bsico de JAVA

10

cdigo que tinha sido gerado em uma plataforma diferente da sua? Que mgica era essa? o
que ns vamos descobrir no prximo tpico.

A Mquina Virtual Java (JVM)

Como vimos, um programa tradicional compilado, gerando um executvel binrio,
escrito em cdigo nativo, ou seja, cdigo na linguagem de mquina da plataforma na qual foi
compilado. Este processo est ilustrado na figura abaixo.
Cdigo - fonte
Program Bom Dia;
Uses crt;
Begin
Writeln (Bom dia!);
End.

Cdigo Binrio

Compilador

001010100
010001100
101100011
100001000

Figura 4

Os programas em JAVA tambm so compilados, mas no geram um executvel binrio

escrito em linguagem de mquina. Em lugar disso, geram um cdigo intermedirio escrito em
uma sub-linguagem inventada pelo JAVA, uma espcie de cdigoJAVA, chamada de bytecode.
O arquivo em bytecode, criado no processo de compilao um intermedirio entre o
cdigofonte (que ns compreendemos) e o cdigo-binrio (que o computador compreende).
O bytecode no compreendido nem pelos programadores e nem pelos computadores. E para
que serve um arquivo que ningum consegue compreender? Afinal, quem consegue
compreender o bytecode? Resposta: a Mquina Virtual JAVA.
Em computao, chamamos de virtual uma representao criada para o computador
para simular alguma coisa existente no mundo real.
Os jogos de ao fazem isso o tempo todo. Neles, voc pode dirigir um carro virtual em
ruas de cidades virtuais. A sensao to perfeita que voc tem a impresso de que est
dirigindo um carro de verdade.
Ou pode jogar um jogo de futebol onde a sua seleo tem
um Ronaldinho virtual, um Robinho virtual, etc. Alguns museus famosos tm sites onde voc
pode percorrer suas galerias virtuais e admirar seus quadros virtuais (que so cpias
digitalizadas dos originais). Existem sites de bibliotecas onde voc pode procurar um livro
virtual nas estantes virtuais, abr-lo e l-lo na tela do computador.
Portanto, uma mquina (computador) virtual uma simulao de uma mquina de
verdade, ou seja, de um computador de verdade dentro do seu computador.
A JVM nada mais do que um programa que voc instala no seu computador e que
simula o comportamento de um computador de verdade no que diz respeito execuo de
programas. Instalando a Mquina Virtual Java, tambm conhecida como plataforma Java, no
seu computador, voc passa a ter um computador dois-em-um. Ao mesmo tempo, que ele da
plataforma Mac (entende a linguagem de mquina Mac), tambm da plataforma Java ( e
entende a linguagem de mquina do Java). Ou se voc tem um computador Solaris, ao mesmo
tempo que ele da plataforma Solaris (e entende a linguagem de mquina Solaris) ele
tambm da plataforma Java (e entende a linguagem de mquina do Java).
Com isso, o Java conseguiu simular no mundo virtual uma coisa quase impossvel no
mundo real: criar um nico padro, uma nica plataforma - a plataforma Java. como se
todos os computadores do mundo fossem do mesmo fabricante e portanto tivessem um
mesmo padro. claro que para isso acontecer de verdade precisaria que todos os
computadores tivessem a JVM instalada. Mas a cada dia que passa isso fica mais perto de

Curso Bsico de JAVA

11

acontecer. A maioria dos Sistemas Operacionais j vem com a JVM instalada. E quando no
vem, basta entrar no site da Sun (desenvolvedora do Java), fazer o download e instalar.
Mas voltando a JVM, dissemos que um computador com a Mquina Virtual JAVA
instalada entende a linguagem de mquina nativa de sua plataforma (os 0s e 1s do cdigobinrio) e tambm a linguagem de mquina do JAVA. E o que essa linguagem da mquina do
Java? So justamente os bytecodes que foram gerados pelo compilador do Java quando
compilamos nosso cdigofonte.
Recapitulando: nas linguagens compiladas tradicionais ns escrevemos o programa em
um editor de texto gerando o cdigo-fonte. A seguir compilamos o cdigo-fonte usando o
compilador de uma determinada plataforma para gerar o cdigo-binrio nativo daquela
plataforma. Em seguida rodamos o cdigo-binrio e o computador l as instrues do binrio e
os executa.
No Java o processo quase o mesmo, a diferena que entre o programador e o
computador de verdade existe um computador virtual: a Mquina Virtual Java. O processo com
Java fica assim: ns escrevemos o programa em um editor de textos gerando o cdigo-fonte.
A seguir compilamos o cdigo-fonte usando o compilador Java para gerar o cdigo-Java
(bytecode). Em seguida rodamos o bytecode e o computador virtual Java (a JVM) l as
instrues do bytecode e as transforma em instrues de mquina escritas em cdigo-binrio
nativo da plataforma do computador de verdade. Finalmente, o computador de verdade recebe
as instrues passadas pela JVM e as executa. A figura abaixo ilustra o processo:
BYTECODE

Cdigo-fonte

class BomDia {
println(Ol!);
}

Compilador
JAVA

xxxx
xxxx
xxxx
xxxx
xxxx
xxxx
xxxx
xxxx

JVM

0010110100.
..

Figura 5

Observe o trecho da figura que ilustra a JVM. De um lado ela recebe um arquivo com o
bytecode e do outro ela gera cdigo-binrio para o computador de verdade. Ou seja, ela l o
bytecode e traduz para o cdigo-binrio.
Ora, mas ento a JVM um tradutor, ou seja, um compilador? Exatamente.
A diferena da compilao no Java para a compilao nas outras linguagens que nas
linguagens tradicionais a compilao feita em uma etapa e no Java ela feita em duas
etapas.
Nas linguagens compiladas tradicionais o cdigo-fonte lido pelo compilador, que gera o
cdigo binrio, que executado pelo computador (ver fig.4).
No Java o cdigo-fonte lido pelo compilador-Java, que gera o bytecode, que lido pela
JVM, que gera o cdigo-binrio, que executado pelo computador (ver fig5).
Mas se a JVM gera cdigo binrio (0s e 1s) para o computador e cada plataforma
entende esses 0s e 1s de maneira diferente, eu no teria que ter uma JVM diferente para cada
plataforma? Sim. Do mesmo modo que quem criava uma linguagem tinha que criar tambm
um compilador para cada plataforma, tambm os criadores do Java tiveram que fazer uma JVM
para cada plataforma. E cada JVM gera o cdigo-binrio correspondente sua plataforma que
os computadores daquela plataforma conseguem ler e executar.

Curso Bsico de JAVA

12

Se compararmos os dois diagramas, veremos que o compilador da Fig.4, ou melhor

dizendo, os vrios compiladores da Fig.4 (um para cada plataforma) equivalem s vrias JVMs
da Fig.5 (uma para cada plataforma). Desse modo, o que tem a mais no desenho da Fig.5 que
no tem na Fig.4 justamente o compilador Java. E ser que eu preciso de um compilador
Java diferente para cada Mquina Virtual Java? Boa pergunta...
Vamos analisar: no caso das linguagens tradicionais cada compilador recebe como
entrada o cdigo-fonte escrito segundo as regras daquela linguagem e gera como sada o
cdigo-binrio especfico para sua plataforma. A entrada uma s, porque a Linguagem de
Programao sempre a mesma. O que varia a sada: cada compilador gera uma sada
diferente (cdigo-binrio) correspondente sua plataforma.
No caso do Java, cada JVM recebe como entrada um arquivo escrito em bytecode e gera
como sada o cdigo binrio especfico para a sua plataforma. A entrada tambm uma s,
porque s existe uma linguagem bytecode e todas as JVMs sabem ler o bytecode. Aqui
tambm, o que varia a sada: cada JVM gera uma sada diferente (cdigo-binrio)
correspondente sua plataforma.
J para o compilador Java, ele recebe como entrada o cdigo-fonte escrito seguindo as
regras do Java e gera como sada um arquivo contendo os bytecodes. A entrada uma s,
porque s existe uma especificao para a Linguagem de Programao Java. E a sada tambm
sempre a mesma, porque s existe uma especificao para a linguagem do cdigo-Java, o
bytecode. Se a entrada uma s e a sada tambm, ento eu no preciso de vrios
compiladores Java, basta um.
Resumindo: o programador escreve o cdigo-fonte em Java (que sempre o mesmo) e
depois compila usando o compilador Java (que tambm sempre o mesmo).
A principal diferena acaba sendo que o processo no Java feito em duas etapas e nas
outras linguagens feito em uma etapa. Esse processo em duas etapas a mgica que
mencionamos no final do tpico anterior e que permite que o programador escreva uma vez e
execute em qualquer lugar.
O programador, usando qualquer computador de qualquer plataforma, escreve o
programa e compila o cdigo-fonte (usando o compilador Java que o mesmo em qualquer
plataforma) gerando o arquivo bytecode. Esse arquivo bytecode pode ser levado para qualquer
computador de qualquer plataforma (desde que ele tenha uma JVM instalada) porque todas as
JVMs sabem ler o bytecode e traduz-lo para cdigo-binrio nativo de sua plataforma. A figura
6 ilustra o processo.
Programa Java

class BomDia{
println(Bom Dia!);
}

Compilador
Java
Bytecode
Bytecode

JVM

01000110

Figura 6

Bytecode
JVM
JVM

10111001

00110100

Curso Bsico de JAVA

13

Vamos analisar o impacto desta compilao-em-duas-etapas para as partes envolvidas.

O usurio, para executar um programa escrito em uma linguagem tradicional, recebe
um arquivo contendo cdigo-binrio (um monte de s e 1s que ele no entende), clica duas
vezes e o programa executado (o computador l as instrues do cdigo-binrio e as
executa).
Para executar um programa escrito em Java o usurio recebe um arquivo escrito em
bytecode (que ele tambm no entende), clica duas vezes e o programa executado (a
mquina virtual Java l as instrues do bytecode e repassa para o computador em formato de
cdigo-binrio que ele reconhece e executa). Ou seja, para o usurio no muda nada. De
um jeito ou de outro, o usurio vai clicar duas vezes no arquivo executvel (binrio ou
bytecode) e pronto, o programa executa.
Se para o usurio no faz diferena nenhuma, para o programador fez toda a diferena
do mundo. Antes o programador escrevia o programa uma vez e compilava vrias vezes, uma
para cada plataforma. E se fizesse uma alterao no programa tinha que compilar vrias vezes
de novo. Com o Java o programador escreve o programa uma vez e compila uma vez. Acabou
o trabalho de compilar uma vez para cada plataforma. E se fizer alguma alterao no
programa basta recompilar uma vez que o bytecode resultante poder ser lido por qualquer
computador de qualquer plataforma: escreva uma vez, execute em qualquer lugar.
Para terminar, uma pequena correo: na verdade a JVM no um compilador, um
interpretador. Com a evoluo dos programas e das linguagens de programao, os
programas-tradutores tambm evoluram e passaram a ser classificados em duas categorias:
os compiladores e os interpretadores.
O compilador esttico: ele faz o seu trabalho de traduo uma vez e gera um arquivo
contendo o cdigo-binrio que ser lido e executado pelo computador. Se voc executar o
cdigo binrio uma, dez ou cem vezes isso no muda nada. O trabalho de traduo j foi feito
uma nica vez.
J o interpretador dinmico: medida que ele vai lendo as instrues do cdigo fonte,
ele vai traduzindo em linguagem de mquina e passando para o computador que as recebe e
executa. Ao final do processo, no foi gerado nenhum arquivo com instrues em cdigobinrio. Ou seja, se voc rodar o programa de novo o interpretador vai traduzir tudo de novo
instruo por instruo. A cada vez que voc rodar o programa uma nova traduo ser feita.
Se voc rodar o programa cinqenta vezes, sero cinqenta tradues.
Hoje existem linguagens compiladas e linguagens interpretadas. O Java uma mistura
de ambas. Ele uma linguagem compilada (na 1 etapa) e interpretada (na 2 etapa).

Curso Bsico de JAVA

14

PARTE II Fundamentos da Programao

Programao Estruturada X Programao Orientada a Objeto
As primeiras linguagens de programao que surgiram tinham cada uma as suas
prprias caractersticas e regras, mas seguiam todas o mesmo conceito: a Programao
Estruturada.
As Linguagens de Programao Orientadas a Objeto criaram um novo conceito bem
mais avanado (a Orientao a Objetos) e com isso modificaram a forma de programar.
Antes de tentar entender o conceito mais avanado (e mais difcil) da Programao
Orientada a Objeto, temos que dominar o conceito mais simples (e bem mais fcil) da
Programao Estruturada.
Quando temos um problema e queremos resolv-lo usando um computador,
escrevemos um programa. Atravs do programa passamos ao computador uma srie de
informaes (dados) e de instrues de como lidar com essas informaes.
Tomemos como exemplo uma calculadora. A calculadora nada mais do que um
computador muito simples que realiza apenas operaes de clculo.
Se eu quero somar os nmeros 2 e 5, eu aperto a tecla 2, depois a tecla + e
depois a tecla 5. Finalmente aperto a tecla = que seria equivalente a dizer execute o meu
programa, e ele mostra o resultado no visor: 7. O 2 + 5 que digitamos na calculadora seria
o equivalente a um programa em um computador, aonde os nmeros 2 e 5 representam os
dados do problema (no nosso exemplo, os dois operandos da operao de adio) e o sinal +
representa a ao, o que o computador deve fazer com os dados que foram informados (no
nosso exemplo, somar os dois dados).
Uma calculadora cientifica dispes de mais recursos que uma calculadora normal, como
funes trigonomtricas e estatsticas. Com ela podemos fazer clculos mais complexos como,
por exemplo, calcular o valor das prestaes de um financiamento a juros compostos. Para
fazer este clculo teremos que informar calculadora muito mais dados do que para a
operao de soma.
O computador, por sua vez, uma ferramenta muito mais elaborada do que uma
calculadora. Ele pode receber e manipular no s dados numricos, mas tambm alfanumricos (nmeros e letras) e caracteres especiais (parnteses, virgulas, etc). Tambm pode
realizar muito mais aes do que simplesmente fazer contas. Com ele podemos processar
textos, figuras, fotos, sons e etc. Mas do mesmo modo que na calculadora, o nosso programa
precisa passar ao computador as informaes sobre os dados e as instrues sobre o que fazer
com esses dados.
Normalmente a estrutura de um programa era dividida em dois blocos bem definidos: o
bloco dos dados e o bloco das aes.
No primeiro bloco eram definidos os campos para armazenar os dados do problema a
ser resolvido. Quando dizemos resolver um problema no s fazer contas, qualquer coisa
que voc queira fazer com um computador, at mesmo um jogo.
Imaginem que ns vamos fazer um programa para controlar uma locadora de DVDs.
Precisaremos coletar e armazenar dados sobre clientes e sobre os filmes. Em relao ao cliente
precisaremos saber o n do cliente, o nome , o endereo, o telefone, etc. Sobre os filmes
precisaremos saber o n do filme, o ttulo, a categoria (ao, romance, comdia...), a
classificao etria (livre, proibido para menores de 18 anos...), a indicao de preo de
locao (promoo, normal, lanamento, srie-ouro, etc.) entre outros.

Curso Bsico de JAVA

15

Uma vez definidos os dados com os quais vamos trabalhar temos que definir o que
fazer com eles. preciso definir os procedimentos para cada tipo de situao e escrever as
instrues que o computador deve seguir dentro de cada procedimento.
Por exemplo, se um cliente aluga um DVD eu tenho que ter um procedimento para
registrar isso no computador.
Se algum perguntar se ns temos um determinado filme para alugar, precisamos de
um procedimento para fazer uma pesquisa no nosso acervo de filmes para ver se ns temos
aquele filme e se ele est disponvel ou alugado.
Se eu quero um relatrio que me mostre quais os filmes mais alugados naquele ms,
eu preciso ter definido um procedimento para pesquisar os dados e gerar um relatrio.
Para ser um bom programador, independente da Linguagem que voc escolher para
escrever os seus programas, voc ter que aprender e dominar dois aspectos da programao:
o algoritmo e a estrutura de dados.

ALGORITMO: escrevendo instrues que os outros vo seguir

tarefa.

Um algoritmo uma seqncia de passos, bem definidos, necessrios para realizar uma

Um programa de computador se encaixa perfeitamente nesta definio, pois o

programa composto por instrues que sero seguidas pelo computador para atingir
determinado objetivo.
Mas mesmo quem no trabalha com computadores, lida com algoritmos o tempo todo,
mesmo que no se d conta disso. Veja nas Figuras 14 e 15 dois exemplos de algoritmos bem
conhecidos.

1- Pr-aquea o forno a 180

2- Unte uma assadeira
3- Corte as cenouras em pedaos
4- Bata no liquidificador os ovos,
acar, leo e cenoura at obter um
creme liso
5- Coloque o creme em uma tigela e
acrescente o trigo e o fermento
6- Misture bem
7- Coloque a mistura na frma
8- Leve ao forno para assar por 40
minutos.

Fig. 14 Algoritmo para fazer bolo de cenoura

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.

Afrouxe os quatro parafusos

Pegue o macaco na mala do carro
Coloque o macaco do lado do pneu a
ser trocado
Levante o carro
Remova os quatro parafusos
Retire o pneu do suporte
Coloque o estepe no suporte
Coloque os quatro parafusos
Baixe o carro
Aperte os quatro parafusos
Guarde o macaco na mala do carro

Fig. 15 Algoritmo para trocar pneu

Releia a definio de algoritmo que demos no incio do tpico. Veja que usamos o adjetivo
bem-definidos. Pode parecer brincadeira, mas uma das coisas mais difceis escrever instrues
claras e precisas sem deixar margem a dvidas.
Na receita de bolo, a expresso at obter um creme liso pode fazer a diferena entre um
bolo bem feito e um desastre total. Expresses como at ficar com consistncia firme ou outras,
muito comuns em receitas, podem querer dizer uma coisa para quem est escrevendo a receita e ser

Curso Bsico de JAVA

16

entendidas de forma diferente por quem est lendo, principalmente se for uma pessoa com pouca
experincia em cozinhar.
J nas instrues para a troca de pneu, a instruo 4 (Levante o carro) deveria ter sido
escrita como Use o macaco para levantar o carro.
Voc deve estar pensando Pera, ningum vai ser burro a ponto de levantar o carro com as prprias
mos!. Pode ser, mas esse s um exemplo de algoritmo mal escrito. Se voc analisar direito vai
ver que a instruo 2 diz para pegar o macaco, a instruo 3 diz para colocar o macaco do lado do
pneu furado e a instruo 11 diz para guardar o macaco. Em nenhum lugar est dizendo para usar o
macaco.
Se eu tivesse escrito este algoritmo, poderia me defender dizendo Tudo bem, eu no deixei
claro, mas voc entendeu o que eu quis dizer .... Num exemplo como esse at d pra entender, mas
em outros no. s vezes, deixamos instrues claras e bem detalhadas para algum realizar alguma
tarefa e quando vamos ver a pessoa fez tudo diferente do que ns queramos. E a pessoa jura que
seguiu exatamente o que estava escrito nas instrues ... a que percebemos que o que estava claro
para ns no era assim to claro para os outros.
A nossa comunicao normal cheia de coisas no ditas mas que os outros entendem, como
no exemplo da troca de pneu. Ou ento de coisas ditas de um jeito mas querendo dizer outro. Se
dizemos a algum Coma um prato de arroz, bvio que queremos que a pessoa coma o arroz e
no o prato.
Porm temos que ter em mente que quando estamos escrevendo para o computador, estamos
passando orientaes para o usurio mais burro e confuso que existe. Ele leva tudo ao p da letra.
Com ele no tem essa de Voc entendeu o que eu quis dizer .... Para escrever para o computador,
voc no pode querer dizer apenas. Voc tem que dizer exatamente o que voc quer em instrues
claras, de preferncia curtas, sem deixar nenhuma margem erros de interpretao como Levante
o carro, Coma um prato e etc. Se estivssemos escrevendo um programa para um computadorcozinheiro, ao invs de passar uma instruo Coloque a mistura no tabuleiro quando estiver fria,
deveramos dizer Coloque a mistura no tabuleiro quando atingir a temperatura de 18 graus
Celsius..
Numa faculdade de informtica, antes de aprender uma linguagem de programao de
verdade, os alunos passam meses aprendendo a escrever algoritmos em pseudo-cdigo, uma
linguagem que no existe de verdade (da o termo pseudo-cdigo). Um programa escrito em
pseudo-cdigo no pode ser compilado e colocado para executar. tudo escrito em portugus
mesmo, simulando uma linguagem de computador, s pra pegar o jeito. A Figura 16 mostra um
exemplo.
Leia NOTA1
Leia NOTA2
MDIA = (NOTA1 + NOTA2) / 2
Imprima MDIA

Fig 16 Pseudo-cdigo para calcular a mdia de um aluno

Curso Bsico de JAVA

17

Nos algoritmos do bolo de cenoura e da troca de pneu fizemos uma lista de passos simples
para serem executados em seqncia. Problemas mais complexos exigem algoritmos mais
complexos com estruturas de deciso e de repetio.
Nas estruturas de deciso, testamos uma determinada condio e executamos (ou no) uma
ou mais instrues dependendo do resultado do teste. Veja na Figura 17 um trecho do algoritmo do
pneu alterado para incluir uma estrutura de deciso.
Pegue o estepe
Verifique se o estepe est cheio
SE o estepe est vazio ENTO Leve o estepe para encher no
borracheiro
Coloque o estepe no suporte
...
Fig 17 Pseudo-cdigo com estrutura SE-ENTO
A instruo Leve o estepe para encher no borracheiro s ser executada se o estepe estiver
vazio. Uma estrutura de deciso mais completa apresenta instrues para o caso da condio testada
ser verdadeira e para o caso dela ser falsa. Veja um exemplo aplicado Locadora de DVDs.
Verifique a classificao-etria do filme
Verifique a idade-cliente
SE (classificao-etria = proibido para menores de 18 anos) e
(idade-cliente < 18 )
ENTO Pea ao cliente para escolher outro filme
SENO Alugue o filme
Fig 18 Pseudo-cdigo com estrutura SE-ENTO-SENO
As estruturas de repetio permitem executar as mesmas instrues diversas vezes,
enxugando um cdigo que de outra forma ficaria muito grande. Na Figura 16 vimos um cdigo
para calcular a mdia das notas de um aluno. Imagine que queremos calcular a mdia de cada aluno
de uma turma com 50 alunos. Para no ter que escrever as mesmas instrues 50 vezes, usamos
uma estrutura de repetio. A Figura 19 mostra um exemplo.
ENQUANTO (existem-alunos-cuja-mdia-ainda-no-foi-calculada) FAA
Leia NOTA1
Leia NOTA2
MDIA = (NOTA1 + NOTA2) / 2
Imprima MDIA
Passe para o prximo aluno
FIM DO ENQUANTO
Fig 19 Pseudo-cdigo para calcular a mdia de cada aluno da turma
Uma boa idia escrever o pseudo-cdigo antes de escrever o programa. Isso ajuda a definir
a estrutura e a lgica do programa.

Curso Bsico de JAVA

18

ESTRUTURA DE DADOS: organizando as informaes

Depois de estudar o problema e identificar quais as informaes que vamos ter que coletar,
armazenar e processar, precisamos escolher que estruturas de dados vamos utilizar.
Um programa armazena as informaes em campos. Estes campos podem ser fixos ou
variveis.
Campos variveis so aqueles que podem ser alterados no decorrer do programa. No nosso
exemplo da Locadora de DVDs, imaginem que estou rodando um programa que verifica meu
acervo de DVDs e gera um relatrio informando quantas unidades eu tenho de cada filme (as
locadoras tem mais unidades daqueles filmes que so mais procurados). Durante a execuo do
programa eu vou usar um campo chamado QTDE_FILMES para fazer a contagem. A cada vez que
eu encontrar uma cpia daquele filme que eu estou contando, eu somo 1 em QTDE_FILMES.
Quando terminar de contar, eu imprimo no relatrio, passo para o ttulo seguinte, zero o campo
(zerar um campo significa atribuir o valor zero a ele) para recomear a contagem e comeo a contar
de novo, agora verificando o novo filme. A cada vez que eu terminar de contar um filme e for
imprimir no relatrio, QTDE_FILMES vai ter um valor diferente dependendo do resultado da
contagem. Para trabalhar com essa informao eu preciso de um campo que me permita alterar o
seu contedo, ou seja um campo varivel.
No jargo de informtica, no se usa ficar falando campo varivel, dizemos simplesmente
varivel. As variveis no armazenam apenas nmeros. Podemos ter variveis que trabalhem com
caracteres. No mesmo programa que verifica quantas unidades eu tenho de cada filme. Eu preciso
de uma varivel que guarde o nome do filme que eu estou contando naquele momento. Essa
varivel, pode ter o nome de TTULO_FILME, por exemplo. Quando o programa estiver fazendo a
contagem do primeiro filme da lista, TTULO_FILME pode conter Quarteto Fantstico. Quando
ele terminar de contar e passar ao prximo filme, TTULO_FILMES vai ter outro contedo, REI
LEO. E assim, por diante, a cada novo filme, o contedo da varivel TTULO_FILME muda.
Porm existem informaes que no mudam ao longo do programa. Essas informaes
devem ser armazenadas em campos fixos. Por exemplo, imaginem que eu quero um relatrio que
me indique quais os clientes esto atrasados na devoluo dos DVDs, para que eu possa telefonar
para eles cobrando. Mas eu no vou telefonar para um cliente que atrasou apenas um ou dois dias.
Ento eu estabeleo que o nmero de dias em atraso aps o qual eu vou telefonar cobrando 5
(cinco). O meu programa, vai ter um campo chamado LIMITE_DIAS_ATRASO aonde eu vou
registrar o limite tolerado para o atraso, no nosso exemplo, cinco dias. Este campo, no vai ter o seu
valor alterado ao longo do programa. Na verdade um campo que o programa vai consultar para
comparar com o numero de dias em atraso do cliente. Veja um exemplo de algoritmo na Figura 20.

Calcule a qtde de dias em atraso

SE qtde de dias em atraso > LIMITE_DIAS_ATRASO
ENTO imprima no relatrio os dados do cliente
Fig 20 Verifica se o cliente ultrapassou o limite de atraso tolerado
Este campo, normalmente definido no incio do programa, fixo. Se depois eu resolvo
aumentar a tolerncia para 7 dias, eu tenho que alterar o programa e recompilar. A partir da

Curso Bsico de JAVA

19

recompilao, o valor de LIMITE_DIAS_ATRASO ser 7, em todas as vezes que eu executar o

meu programa.
Para definir as variveis e campos fixos a serem usadas no programa, precisamos conhecer
as caractersticas dos dados que vamos processar para poder definir o nome e o tipo da varivel.
Toda Linguagem de Programao tem suas regras sobre como deve ser o nome da varivel
(umas s permitem maisculas, outras s minsculas, umas limitam o tamanho do nome em 8
caracteres, outras podem ter tamanho indefinido, etc). O Java tambm tem as suas, que iremos
conhecer quando estudarmos as variveis no Java.
Do mesmo modo, toda Linguagem de Programao estabelece tambm o tipo de dados com
os quais podemos trabalhar. De uma forma geral os tipos mais bsicos so: inteiros, ponto
flutuante, caracteres e booleanos.
Se eu vou trabalhar com dados que s admitem nmeros inteiros como IDADE_CLIENTE,
QTDE_FILMES, LIMITE_DIAS_ATRASO, etc, vou usar variveis do tipo INTEIRO. Se vou
processar nmeros que podem ter casas decimais, como VALOR_LOCAO, MULTA_ATRASO
e etc, usarei variveis do tipo PONTO FLUTUANTE. Se vou armazenar informaes alfanumricas como TTULO_FILME, NOME_CLIENTE, etc criarei no meu programa variveis do
tipo CARACTER. O ltimo tipo para variveis que armazenam apenas um entre dois valores:
VERDADEIRO ou FALSO. Uma varivel do tipo BOOLEANO pode ser usada para armazenar o
resultado de uma comparao. No exemplo da Figura 20, eu poderia fazer uma alterao para
armazenar o resultado de (qtde de dias em atraso > LIMITE_DIAS_ATRASO) para ser usado em
outro ponto do programa. Veja na Fig. 21.
Calcule a qtde de dias em atraso
SE qtde de dias em atraso > LIMITE_DIAS_ATRASO
ENTO
imprima no relatrio os dados do cliente
ESTOUROU_LIMITE = VERDADEIRO
SENO
ESTOUROU_LIMITE = FALSO

Fig 21 Armazenando o resultado da comparao

. Em alguns casos, podemos agrupar as variveis criando uma espcie de super-varivel que
nada mais do que um agrupamento de variveis. Como exemplo podemos citar os dados cadastrais
do cliente. Eu posso ter uma varivel chamada ENDEREO que agrupa dentro de si outras
variveis (TIPO_LOGRADOURO (se Rua, Avenida, Alameda), NOME_LOGRADOURO,
NMERO, TIPO_MORADIA (casa,apto), BAIRRO, CEP, etc). Alm disso tenho variveis como
NOME_CLIENTE, DATA_NASCIMENTO, SEXO, ESTADO_CIVIL,
TELEFONE_RESIDNCIA, TELEFONE_TRABALHO, etc. Eu posso agrupar todas essas
variveis em uma varivel chamada DADOS_CADASTRAIS. Isto facilita a escrever um programa
porque mais fcil mandar o programa ler os DADOS_CADASTRAIS (basta uma instruo de
leitura) do que pedir pra ele ler NOME_CLIENTE, ler DATA_NASCIMENTO, ler SEXO, ler
ESTADO_CIVIL, e assim por diante. No so todas as Linguagens de Programao que permite
criar essas estruturas. No PASCAL esses agrupamentos de variveis so chamados de RECORDS
(registros).

Curso Bsico de JAVA

20

Com isso, tivemos uma idia dos conceitos bsicos da Programao Estruturada. No
prximo tpico vamos ver que as limitaes das Linguagens Estruturadas acabaram levando
criao da Programao Orientada a Objetos e vamos aprender o que Modularizao, uma das
caractersticas mais marcantes dessas linguagens.
Modularizao X Abstrao
Como vimos, quando temos um problema e queremos resolv-lo usando um computador,
escrevemos um programa atravs do qual passamos ao computador as informaes dos dados do
problema e de como lidar com esses dados. O grande desafio do programador estabelecer uma
relao entre o mundo real e o modelo que ele vai transportar para o computador.
Na nossa linguagem, s vezes encontramos dificuldade de expressar algo por que no
encontramos as palavras adequadas para isso. Uma criana que est aprendendo as primeiras
palavras naturalmente vai ter a maior dificuldade em descrever um acontecimento, pois ela conta
com um vocabulrio pequeno e no sabe bem como combinar as poucas palavras que conhece.
Na programao isto tambm acontece, afinal estamos lidando com linguagens que so
verses reduzidas da nossa prpria linguagem, lembram? Dependendo dos recursos disponveis para
cada linguagem de programao podemos ter uma maior ou menor dificuldade de reproduzir no
computador as informaes que observamos no mundo real, relativas ao problema que queremos
resolver. Isto geralmente levava o programador a tentar adaptar o problema ao modelo utilizado em
uma determinada linguagem. Se a linguagem escolhida fosse o LISP, o problema seria traduzido
como listas encadeadas. Se fosse PROLOG, o problema seria transformado em uma cadeia de
decises. Assim, as limitaes da linguagem acabavam limitando a representao do problema,
tornando a escrita muito difcil.
Antigamente, os problemas eram mais simples, pois se usavam os computadores para
utilidades especficas dentro das empresas. Ns tnhamos programas feitos para a rea
administrativa (que eram usados para auxiliar os administradores nas tarefas de controle e tomada
de decises), tnhamos programas desenvolvidos para os setores de produo de uma indstria,
tnhamos programas comerciais que eram usados em bancos e lojas, e etc. Mas de uma forma geral,
os programas atendiam apenas o setor para o qual foram desenvolvidos, de modo que era mais fcil
entender aquele universo especfico e transport-lo para dentro do computador, pois os setores no
interagiam tanto entre si e nem trocavam tanta informao como hoje.
Hoje, com o crescimento e a popularizao dos computadores e da internet, a informtica
est presente em todos os setores da nossa vida, e praticamente impossvel fazer qualquer
atividade que no dependa em algum grau de informaes processadas por computadores. Hoje, no
existem mais setores isolados, nem dentro da mesma empresa e nem entre as empresas e instituies
pblicas e privadas. Todo mundo troca informao com todo mundo o tempo todo. Com isso a
representao dos problemas ficou bem mais complicada porque alm de entender e representar os
dados e procedimentos de uma entidade especfica, temos que ver como ela se relaciona com as
outras entidades e como vamos fazer para traduzir estes relacionamentos para o computador.
Digamos que em uma grande empresa um dos setores, o Setor de Pessoal, desenvolveu um
programa que armazena e processa informaes sobre os funcionrios daquela empresa. Ela est
mais interessada nas informaes sobre a vida profissional do funcionrio dentro da empresa, como
data de admisso, cargo que ocupa, salrio, promoes que recebeu, se tem frias a tirar, e etc, alm
de informaes cadastrais como nome, endereo, data de nascimento, sexo ... Mas outros setores

Curso Bsico de JAVA

21

tambm precisam coletar e armazenar dados sobre os funcionrios, como por exemplo, o Setor
Mdico, que precisa de informaes especficas da sua rea (tipo sanguneo, histrico de doenas,
etc) mas tambm precisa conhecer e lidar com as informaes cadastrais. Um outro setor, o Setor de
Treinamentos, responsvel por capacitar os funcionrios atravs de cursos, precisa tambm de
informaes especficas de sua rea (nvel de escolaridade, formao acadmica, cursos que j
foram feitos dentro da empresa, etc) alm de informaes comuns a outros setores. E assim por
diante, vamos verificar que vrios setores coletam e processam algumas informaes em comum.
No passado, em uma situao como essa, era muito comum a duplicidade de cdigos.
O Setor de Pessoal definia e escrevia o seu programa, dentro do qual tinha um trecho de
cdigo que era o responsvel por incluir os dados de um funcionrio quando ele era admitido, um
outro trecho que era o responsvel por deletar os dados de um funcionrio que havia sido demitido,
etc. O Setor Mdico, ao escrever o seu programa, tambm tinha que escrever um trecho de cdigo
referente incluso e excluso de funcionrios. Ele no podia aproveitar o pedao de programa que
j tinha sido escrito pelo Setor de Pessoal, porque os programas eram estanques: cada programa
tinha o seu bloco de dados e o seu bloco de instrues e um programa no interagia com o outro.
Tambm o Setor de Treinamentos precisava escrever um cdigo semelhante, gerando desperdcio de
tempo, e recursos. Muitas vezes, os dados de um funcionrio eram alterados em um programa e no
eram alterados em outro, de modo que um Setor registrava que o funcionrio era solteiro enquanto
outro registrava que ele era casado.
Olhando assim, no parece um grande problema, mas imaginem um sistema enorme com
muitas informaes sensveis, como um sistema bancrio, por exemplo. A comunicao entre os
setores era vital e a duplicidade de cdigo uma porta aberta para problemas em potencial.
Para tentar suprir essas deficincias, surgiu a Orientao a Objetos. Ela geral o suficiente
para no impor um modelo de linguagem ao programador. Cada linguagem continua tendo suas
prprias caractersticas, mas todas tem em comum a mesma maneira de enxergar o mundo real e
transform-lo em um modelo virtual para ser implementado no computador.
As Linguagens de Programao Orientadas a Objetos so muito mais flexveis e permitem
uma comunicao e interao entre os programas permitindo uma implementao modular. Com
elas, o pedao de programa escrito pelo Setor de Pessoal, pode ser aproveitado por todos os demais
setores da companhia. Um mesmo trecho de cdigo, uma vez escrito, pode ser chamado por vrios
outros programas, gerando economia e acabando com o problema de informaes desencontradas
espalhadas por vrios setores.
A coisa funciona assim: criada uma biblioteca de programas onde so armazenados todos
os programas da empresa. Se o Setor de Pessoal precisou escrever um cdigo para
incluir/alterar/deletar dados cadastrais de um funcionrio, ela coloca o cdigo-executvel na
biblioteca de programas. Se eu estou escrevendo um programa que tambm precisa
incluir/alterar/deletar dados cadastrais de um funcionrio, no preciso ter o trabalho de escrever o
mesmo cdigo que j foi escrito pelo Setor de Pessoal. Basta eu incluir no meu programa uma
instruo dizendo ao meu programa para executar o cdigo que o Setor de Pessoal escreveu e que
est disponvel na biblioteca. O meu programa transfere a execuo para o programa do Pessoal.
Quando ele terminar de executar, volta a execuo para o meu programa e ele continua do ponto em
que estava quando fez o desvio para o programa do Pessoal. Para todos os efeitos como se eu
tivesse escrito aquelas instrues dentro do meu cdigo. Dessa forma, a economia e confiabilidade
dos programas muito maior.
Agora imagine que com o crescimento da biblioteca de programas, em um dado momento eu
tenho 30 programas diferentes fazendo meno a esse programa de cadastramento dentro dos seus

Curso Bsico de JAVA

22

cdigos. Suponha que acontea uma mudana na legislao que define as regras para
processamento de dados funcionais de empregados e que com isso eu e tenha que fazer alguma
alterao neste programa para refletir a mudana. Basta eu mudar aquele pequeno programinha do
Pessoal (responsvel pelo cadastro dos dados do funcionrio) que automaticamente todos os 30
programas tambm estaro ajustados nova legislao.
Isto possvel porque todas as Linguagens Orientadas a Objeto oferecem suporte
modularizao.
Dissemos que para ser um bom programador, na poca das Linguagens de Programao
Estruturadas, era preciso conhecer e dominar o algoritmo e a estrutura de dados. Com o surgimento
da Programao Orientada a Objetos, o bom programador precisa, alm do algoritmo e da estrutura
de dados, conhecer e saber aplicar a abstrao e a modularizao.
Modularizao a tcnica de dividir um grande problema em partes menores, e cada uma
delas em partes ainda menores, at que cada uma seja suficientemente simples de resolver.
Abstrao o oposto: a capacidade de manter o foco nas partes maiores do problema, evitando
olhar para a riqueza de detalhes das partes menores. Esta uma definio bem resumida. Vamos
explicar melhor
Quando escrevemos um programa temos que decidir se vale mais a pena colocar todo o
cdigo em um nico mdulo ou se melhor divid-lo em mdulos menores. Um problema simples
como calcular as mdias dos alunos de uma sala, ou imprimir um relatrio contendo a relao de
clientes atrasados pode tranquilamente ser resolvido usando um nico programa. Voc consegue
enxergar e escrever todos os passos necessrios dentro do mesmo bloco de programa sem
dificuldade. Para problemas maiores e mais complexos, porm, isto muito simplista. medida
que o problema cresce, vai ficando mais difcil visualizar todos os detalhes ao mesmo tempo.
A soluo para lidar com a complexidade a modularizao: ns dividimos o problema em
sub-problemas, depois novamente em sub-sub-problemas, e assim por diante, at que os problemas
individuais so pequenos o bastante para tornar fcil lidar com eles. Uma vez que resolvemos um
desses pedaos (sub-problemas), no pensamos mais nos detalhes daquele pedao, mas pensamos
nele como uma das peas de uma parte maior.
Vamos analisar estes dois conceitos atravs de um exemplo. Imagine que um fabricante de
carros determinou que uma equipe de engenheiros projete um novo carro. O engenheiro-chefe vai
pensar no problema tentando imaginar o carro como um todo: o desenho da carroceria, o nmero de
portas, o tamanho e a localizao do motor, a quantidade e tamanho das rodas e etc. Para ele, o
motor apenas uma das peas do carro que ele est desenhando. Ele no precisa se preocupar em
saber como vai ser feito o motor, ele s precisa saber que o carro vai ter um motor.
Por outro lado, um outro engenheiro, cuja tarefa justamente projetar o motor, vai se
preocupar em detalhar as vrias partes que compem um motor: os cilindros, o mecanismo de
injeo, o carburador, a bobina, etc. Para ele, o motor no um nico bloco, um complexo
conjunto de pequenas partes. Uma dessas partes a vela (a vela o componente que gera uma
fasca para produzir a queima do combustvel, como nos isqueiros a gs).
Existe um engenheiro (provavelmente em outra fbrica uma fbrica de velas para
automveis) que est trabalhando em desenvolver a vela. Ele enxerga a vela como um artefato
complexo com mltiplas partes. Ele pode estar realizando pesquisas para determinar exatamente
qual o melhor tipo de metal a ser usado para os contatos, ou qual o melhor material cermico a ser
empregado no isolamento da vela. E o mesmo est acontecendo com outras partes do carro.

Curso Bsico de JAVA

23

De volta ao engenheiro-chefe, para ele as rodas so uma das partes do carro. Ele sabe que o
carro tem quatro rodas e um estepe e s precisa saber qual o tamanho e espessura das rodas para
poder projetar o espao correspondente na carroceria do carro. Mas algum outro engenheiro l
embaixo na cadeia produtiva deve estar empregando os seus dias pensando na melhor composio
qumica para produzir a borracha dos pneus. Para ele, os pneus so uma coisa muito complexa,
cheias de detalhes a serem resolvidos.
Isso modularizao.
A fbrica de carros, provavelmente no vai fabricar pneus, vai compr-los de um fabricante
de pneus, e para ela o pneu apenas um componente. Ela no se preocupa com os detalhes deste
componente. Um dos engenheiros da fbrica de carros o responsvel pelas rodas. Ele se abstrai
dos detalhes da fabricao de um pneu, para poder se concentrar no projeto da roda. Ele no est
preocupado em saber como se produz um pneu, uma carcaa ou um parafuso. Ele est preocupado
apenas em juntar essas peas para fazer a roda.
Isso abstrao.
O engenheiro-chefe que est desenhando o carro como um todo, abstrai dos detalhes
tcnicos das rodas e do motor e se concentra no desenho do carro. Ele s est interessado em saber
o tamanho do motor e das rodas, para poder fazer o seu desenho de acordo. O mesmo acontece com
todos os outros componentes do carro. Enquanto algum est concentrado em desenhar o espao
interno do carro, tem algum outro trabalhando no material do revestimento dos bancos do carro.
A questo : se for visto em todos os seus inmeros detalhes, um carro tem tantas partes que
seria impossvel uma s pessoa conhecer todos os detalhes ao mesmo tempo. A razo pela qual os
carros so projetados e construdos com sucesso que os engenheiros usam modularizao e
abstrao. Eles dividem o carro em mdulos independentes (rodas, motor, caixa de marchas,
bancos, etc) e atribuem a pessoas diferentes o trabalho de desenvolver cada mdulo
independentemente. Quando um mdulo est construdo, eles usam abstrao. Eles enxergam
aquele mdulo como um simples componente a ser usado para construir componentes mais
complexos.
Modularizao e abstrao, portanto, complementam um ao outro. Modularizao o
processo de dividir partes maiores (problemas, por exemplo) em partes menores, enquanto
abstrao a habilidade de ignorar os detalhes para poder focar no quadro geral.
No prximo tpico vamos finalmente aprender o conceito de Classes e Objetos, que a
base de todas as Linguagens de Programao Orientadas a Objetos, e vamos ver como tudo isto se
encaixa para desenhar um programa.

Curso Bsico de JAVA

24

Classes e Objetos: trazendo o mundo real para dentro do computador

J vimos que em informtica, virtual uma representao computadorizada de algo do
mundo real. A Programao Orientada a Objetos foi criada para tentar aproximar o mundo real do
mundo virtual: a idia fundamental tentar simular o mundo real dentro do computador. Para isso,
usamos classes e objetos para tentar simular dentro do computador tudo aquilo que vemos no
mundo real.
Olhe sua volta. Voc capaz de identificar vrios tipos de objeto: uma mesa, uma cadeira,
uma televiso, um cachorro, uma lmpada, uma bicicleta, uma formiga ... Todos esses objetos
possuem caractersticas (atributos). Por exemplo, um cachorro tem os seguintes atributos: nome,
raa, idade, etc. J uma bicicleta tem outros atributos: marca, numero de marchas, cor, etc. Uma
lmpada tem como atributos (caractersticas) marca do fabricante, potncia (60 W, 100 W, ..),
voltagem (110 ou 220 V), tipo (incandescente, fluorescente) e assim por diante. Os objetos tambm
possuem comportamentos, ou seja, podem realizar aes. Um cachorro pode latir, pode balanar o
rabo, pode comer; uma bicicleta pode frear, pode acelerar, pode mudar de marcha; uma lmpada
pode acender ou pode apagar.
J posso ouvir voc dizendo Cachorro ?!? Mas cachorro no objeto ... verdade, mas
para a Programao Orientada a Objetos tudo que possui atributos e comportamentos considerado
um objeto. Se fssemos escolher uma outra palavra para designar aquilo que tem atributos e
comportamentos, poderamos talvez escolher a palavra seres. Teramos ento a Programao
Orientada a Seres. Mas a todo mundo iria reclamar: E desde quando bicicleta um ser? Talvez
fosse mais indicado usar a palavra coisa que bem abrangente. Mas pense bem, quem que iria
levar a srio uma Linguagem de Programao Orientada a Coisas ?
Enfim, escolheram a palavra objeto e pronto. Devemos ter em mente que objeto tudo
aquilo que possui atributos e comportamentos. Uma boa regra, para ver se aquilo que estamos
olhando pode ser considerado um objeto, perguntar se ele pode ser uma coisa. Se ele uma coisa,
ento ele um objeto.
Em Programao Orientada a Objetos preciso uma boa dose de abstrao e imaginao.
claro que a lmpada no realiza a ao de acender e apagar, mas na viso de objetos, quase como
se cada objeto fosse um ser vivo, capaz de realizar aes. Ento se eu digo ao objeto lmpada
Acenda !, ele entende o que eu quero e acende. Se eu digo a uma bicicleta Freie ! ela sabe o que
preciso fazer e ela freia. Na vida real os objetos no entendem o que falamos e no realizam eles
mesmos as aes, mas no mundo virtual sim. Cada representao de uma coisa no mundo real, se
transforma, no mundo virtual, em um objeto, um ser pensante dotado de caractersticas prprias
(atributos) e capaz de executar aes (comportamentos) que ns pedimos a eles para executar. Eles
no fazem qualquer ao que ns pedimos, somente aquelas que eles sabem executar (um lmpada
no sabe acelerar ou latir, ela sabe apenas acender e apagar).
Existe uma linguagem chamada UML que foi criada para ajudar a desenhar problemas do
mundo real dentro do mundo virtual do computador. A UML uma linguagem composta de
smbolos e desenhos que usamos para representar as classes e objetos que enxergamos no mundo
real. A Figura 22 mostra como seriam representados o cachorro, a lmpada e a bicicleta, usando os
smbolos de UML.

Curso Bsico de JAVA

Cachorro

25

cor
raa
idade

Bicicleta
marca
numMarchas
cor

Lmpada
marca
potncia
voltagem

latir
balanarRabo
comer

frear
acelerar
mudarMarcha

acender
apagar

Fig 22 Representao inicial de cachorro, bicicleta e lmpada em UML

A parte de cima do desenho contm o nome daquilo que estamos representando, a seguir
vm os atributos e por fim as aes. Na Programao Orientada a Objetos, as aes que um
determinado objeto pode realizar so chamadas de mtodos. meio esquisito, mas foi o nome que
escolheram. Cada ramo de atividade tem o seu jargo, e melhor a gente ir logo se acostumando
com ele. Daqui pra frente quando eu me referir aos mtodos de um objeto, estarei me referindo s
aes que aquele objeto capaz de realizar. Quando eu quero que um objeto realize uma
determinada ao (mtodo) eu fao uma chamada de mtodo. Para fazer isso eu preciso saber
quais so os nomes dos mtodos que aquele objeto capaz de implementar (executar). No adianta
eu virar para o objeto Cachorro e dizer mexa o rabo ou abane o rabo que ele no vai entender.
Eu preciso dizer exatamente como est definido: balanarRabo e a sim ele vai entender e
comear a abanar o rabo. No posso dizer para a bicicleta passe a marcha, tenho que usar
mudarMarcha porque assim que foi definido.
Alguns mtodos, como acender e apagar, so muito simples e basta chamarmos o mtodo
acender, que a lmpada acende. Mas outros so mais complexos e requerem alguma especificao
a mais alm do nome do mtodo apenas. Por exemplo, se eu disser bicicleta (chamar o mtodo)
mudarMarcha, como que ela vai saber para qual marcha eu quero que ela mude? Eu tenho que
passar para ela alguma informao adicional. Neste exemplo, eu preciso especificar o nmero da
marcha desejada. Essas informaes adicionais que s vezes temos que passar quando chamamos
um mtodo so chamadas de parmetros. Assim, eu chamaria o mtodo mudarMarcha do objeto
bicicleta assim: mudarMarcha(3). O numero 3 dentro dos parnteses o parmetro que o mtodo
requer para poder executar a ao corretamente. Neste caso, eu estou pedindo bicicleta que mude
para a 3 marcha. Toda a definio de mtodos inclui a lista de parmetros entre parnteses. Se a
lista estiver vazia, sinal de que aquele mtodo no requer nenhum parmetro, como por exemplo
acender e apagar. Mesmo que no receba parmetros, o mtodo precisa colocar os parnteses
ao lado do nome. A Fig, 23 mostra como ficaria a especificao do cachorro, bicicleta e lmpada,
seguindo esta simbologia.
Cachorro
String cor
String raa
int idade

Bicicleta
String marca
int numMarchas
String cor

Lmpada
String marca
int potncia
int voltagem

latir( )
balanarRabo( )
comer( )

frear(percent)
acelerar(percent)
mudarMarcha(numMarcha)

acender( )
apagar( )

Fig 23 Representao correta dos mtodos

Curso Bsico de JAVA

26

Veja que aproveitamos para especificar tambm, dentro dos mtodos frear e acelerar, um parmetro
contendo um percentual de diminuio ou de acrscimo de velocidade. Assim, frear(100), indicaria
bicicleta que para ela parar totalmente, ao passo que frear(50) indicaria para reduzir para a
metade da velocidade atual. J acelerar(20) provocaria um aumento de 20% na velocidade da
bicicleta. Uma chamada ao mtodo comer( ), dirigida ao cachorro, seria o suficiente para faz-lo
comer, no havendo necessidade de passar nenhum parmetro. Alis nem que eu quisesse passar um
parmetro, isso seria possvel, porque na definio do mtodo comer, ele foi definido como no
tendo parmetros (no h nada dentro dos parnteses na definio do mtodo).
Os objetos podem se relacionar uns com os outros. Dentro do conceito de abstrao que
vimos no tpico anterior, eu posso ter um ou mais objetos fazendo parte da relao de atributos de
um objeto. No caso do projeto do carro, eu posso ter um objeto carro que tem entre as suas
caractersticas atributos simples como marca, cor, ano de fabricao, tipo-de-combustvel (lcool,
gasolina ou flex) e etc. Mas tambm tenho atributos compostos como motor, roda, bancos e etc.
U, mas motor caracterstica ? sim. Eu posso ter um carro sem motor, no posso? Imaginem
que eu estou descrevendo um daqueles carrinhos de brinquedos de parque de diverses. Ele parece
um carro de verdade, tem rodas e tudo e fica girando, piscando os faris e etc, mas no tem motor.
Ento se eu vou fazer uma representao virtual desse carro no meu computador eu no vou colocar
que ele tem motor, porque ele no tem. J o carro que est sendo projetado na fbrica, vai ter motor,
ento eu preciso colocar entre as suas caractersticas que ele tem motor. Para isso eu uso um objeto
do tipo motor. E tambm quatro objetos do tipo roda. E assim por diante. Eu no preciso me
preocupar em descrever as caractersticas e mtodos de um objeto do tipo motor, porque algum j
teve esse trabalho(modularizao). Eu posso simplesmente pegar esse objeto e inclu-lo na relao
de atributos do meu objeto (abstrao). A Figura 24 mostra esse relacionamento entre dois dos
objetos que estamos descrevendo, a bicicleta e a lmpada.
Bicicleta
marca
numMarchas
cor
farol
luzDeFreio

Lmpada
marca
potncia
voltagem
acender( )
apagar( )

frear(percent)
acelerar(percent)
mudarMarcha(numMarcha)
acenderFarol( )
Fig 24 Objetos (farol e luzDeFreio) fazendo parte da descrio de outro
(bicicleta)
Da mesma forma que eu exemplifiquei o conceito de mtodos dizendo que eu chamava o
mtodo comer( ) do cachorro, para faz-lo comer e o mtodo acender( ) da lmpada para faz-la
acender, o mesmo acontece entre os objetos, Ou seja, os objetos se comunicam entre si. No caso da
Figura 24, eu estou descrevendo uma bicicleta com farol. Se est escurecendo eu digo a bicicleta
para acender o farol atravs de uma chamada ao mtodo acenderFarol( ). O mtodo uma ao,
ento a bicicleta vai realizar os passos necessrios para cumprir aquela ao. Entre esses passos est
includa uma chamada ao mtodo acender( ) do farol (que uma lmpada e portanto sabe acender).
Ou seja, eu peo bicicleta para acender o farol, chamando o mtodo acenderFarol( ) da bicicleta, e
ela por sua vez vira pro objeto farol e pede pra ele acender, chamando o mtodo acender( ) do farol.
No sou em quem dou a ordem de acender ao farol. Eu dou a ordem para a bicicleta e ela quem
vira para o farol e d ordem para ele acender. meio doido n? Mas assim que acontece.

Curso Bsico de JAVA

27

Agora que j sabemos o que so objetos, vamos entender o que so Classes. Classe a
descrio dos atributos e mtodos que um determinado objeto pode ter. Olhe de novo as Figuras 22,
23 e 24. O que ns fizemos ao usar esses desenhos do UML? No foi justamente uma descrio de
atributos e mtodos? Exatamente. De onde se conclui que o que ns fizemos at agora foi definir
classes. Por exemplo, definimos a classe Cachorro (Fig. 23). Atravs da definio dessa classe eu
fiquei sabendo que um cachorro tem raa, ou seja, qualquer cachorro que existir, vai ter uma raa. E
sei que, se existir algum cachorro, ele vai saber latir, porque na definio da classe Cachorro est
definido o mtodo latir( ). Mas por enquanto eu tenho apenas uma definio. Eu j sei o que um
cachorro faz, mas cad os cachorros, pra eu poder mandar eles latirem, comerem ou balanarem o
rabo?
No nosso mundo virtual, eu preciso criar um objeto de uma determinada classe para ele
passar a existir. No mundo real eles j existem, vamos imaginar que enquanto ns estamos aqui
estudando, tem dois cachorros l na rua disputando um osso. Um deles o rex e o outro o tot.
Como eu fao para represent-los no mundo virtual? Em primeiro lugar eu tenho que ter uma
definio da classe Cachorro. Ok, isso ns j fizemos, est l na Figura 23. Agora eu estou
escrevendo um programa e quero interagir com esses dois cachorros, rex e tot. Pois bem, em
algum ponto do meu programa, eu vou escrever: Declaro que a partir deste momento passa a
existir o objeto da classe Cachorro chamado rex, sendo que ele da raa Pastor Alemo e tem 3
anos de idade. E logo a seguir eu escrevo : Declaro que a partir deste momento passa a existir o
objeto da classe Cachorro chamado tot, sendo que ele da raa Pequins e tem 1 ano de idade.
claro que no vamos escrever assim dessa maneira, existem um comando e uma forma correta de se
escrever, mas a idia essa.
Agora, o meu programa tem dois objetos da classe Cachorro. Ambos possuem as mesmas
caractersticas e sabem fazer as mesmas coisas mas cada um tem a sua prpria cpia de atributos e
comportamentos. A classe Cachorro descreve um atributo chamado idade. Isto significa que ao criar
o objeto rex, esse objeto tem um campo chamado idade, que armazena o valor 3. Ao criar o objeto
tot, esse objeto tambm tem um campo chamado idade que, no caso do tot, armazena o valor 1.
Se o meu programa usar a varivel idade, assim s escrevendo idade e mais nada, como vamos
saber se uma referncia idade do rex ou idade do tot? Portanto ao usar uma varivel de um
objeto em um programa, temos que associ-la ao objeto especfico que queremos. Fazemos isso
escrevendo o nome do objeto, mais um ponto e mais o nome do campo. Assim, se o meu programa
pede para mostrar na tela tot.idade, ele vai mostrar o valor 1. Se eu pedir rex.idade vai aparecer o
valor 3. A partir do momento da criao desse dois objetos eu passei a ter no meu programa 6
variveis para poder manipular: rex.cor, rex.raa, rex.idade, tot.cor, tot.raa e tot.idade.
A mesma coisa acontece com os mtodos. Se eu chamar o mtodo latir( ) simplesmente,
como que o programa vai saber se um comando para o rex ou para o tot? Aqui tambm eu
tenho que dirigir a ao quele objeto especfico e fazemos isso do mesmo modo que fizemos com
as variveis, escrevendo o nome do objeto, mais um ponto e mais o nome do mtodo. Agora eu
posso direcionar as minhas ordens, escrevendo rex.balanarRabo( ) e tot.latir( ). A partir do
momento da criao desses dois objetos eu passei a ter no meu programa 6 mtodos que eu posso
chamar: rex.latir( ), rex.balanarRabo( ), rex.comer( ), tot.latir( ), tot.balanarRabo( ) e
tot.comer( ).
Num programa, para ajudar a saber quando estamos nos referindo a uma classe e quando
estamos nos referindo a um objeto, escrevemos o nome da classe com a primeira letra em
maiscula, como em Cachorro. E quando estamos usando um objeto daquela classe escrevemos
tudo em minsculas, como em rex e tot. Um objeto chamado de instncia de classe. Assim, rex
uma instncia da classe Cachorro e tot uma outra instncia da mesma classe.

Curso Bsico de JAVA

28

Deu pra entender? A diferena entre classe e objeto sutil, normal no entender assim de
imediato. Note que uma classe no tem vida, s um conceito. Mas os objetos (cachorro, lmpada)
possuem vida (ok, lmpada normalmente no tem vida, mas no mundo virtual ela tem ...). A classe
Cachorro no pode latir, comer, etc, ela apenas especifica e define o que um Cachorro. Mas
objetos do tipo Cachorro, ou seja, instncias da classe Cachorro (rex, tot) estes sim, podem latir,
comer e balanar o rabo.
Agora s falta entender como isso tudo se aplica programao. Vamos l.
Os mesmos princpios de modularizao e abstrao que vimos no tpico anterior so
usados no desenvolvimento de um software. Ao olhar para um problema complexo ns tentamos
quebr-lo em sub-componentes que sejam mais fceis de ser codificados (programados) e que ns
iremos tratar como entidades independentes. Depois de criados esses sub-programas, ns iremos
us-los como se fossem simples peas de um programa maior, sem nos preocuparmos com suas
complexidades internas.
Se estivssemos tentando fazer um programa que implementasse no computador as funes
de um carro, tentaramos fazer como os engenheiros da fbrica de carros. Eles olharam para o carro
e viram que o carro era um objeto composto de outros objetos menores (motor, roda, etc). Primeiro
eles construram esses objetos menores e depois os usaram como peas para montar o objeto maior:
o carro. Ns tambm, ao invs de escrevermos um nico e enorme programa contendo todos os
inmeros detalhes da construo do carro, vamos tentar dividir o programa em mdulos menores e
escrever esses mdulos primeiro. Assim, teremos um mdulo para o motor, outro para a roda, outro
para o banco e assim por diante. No final, vamos pegar esses mdulos prontos e vamos us-lo para
escrever o programa principal, que monta o carro. O programa do carro agora vai ficar muito fcil
de ser escrito, porque ele basicamente tem que pegar um motor, quatro rodas, os bancos, a
carroceria e mont-los.
Esses mdulos, na Programao Orientada a Objetos, so as classes. Ento, para escrever
um programa composto de vrios mdulos, na verdade eu vou escrever classes. Normalmente, um
programa composto de um mdulo principal que chama outros mdulos, os quais por sua vez,
chamam outros mdulos e assim por diante. Esse programa principal a classe principal, que usa
outras classes, que tambm usam outras classes.
Uma classe uma descrio de atributos e mtodos. O programa (classe) comea com a
definio dos atributos e depois descreve os mtodos. Os mtodos compem a parte do programa
aonde a ao executada. dentro dos mtodos que eu vou descrever as instrues, os passos que o
computador vai executar em cada situao. A parte inicial, das definies de variveis, mais
descritiva: aqui que eu vou definir que tipo de atributos eu vou ter no programa e quais so eles.
Portanto, aqui que eu vou dizer que sub-classes (mdulos menores) a minha classe vai usar. Mas
aqui ele vai s definir, no vai usar. Para usar temos que ter chamadas de mtodos de objetos e isso
s vai acontecer dentro dos mtodos do nosso programa, que onde a ao se desenvolve.
Portanto eu defino as classes na parte inicial das definies de variveis. Mas as classes no
podem ser usadas, pois como vimos elas no executam aes, s os objetos fazem isso. Ento eu
tenho que criar os objetos das classes que definimos que iriam ser utilizadas. A partir da criao dos
objetos, a ao pode comear a acontecer pois os objetos podem realizar na prtica aquelas aes
que a classe definiu na teoria.
Agora um detalhe importante: quando eu crio uma instncia de uma classe, ou seja quando
eu crio um objeto, eu estou trazendo para dentro do meu programa a possibilidade de usar aqueles

Curso Bsico de JAVA

29

atributos e mtodos. Mas no quer dizer que eles vo ser automaticamente usados. Se eu estou
escrevendo um programa para um clnica veterinria, meu programa pode definir que vai usar a
classe Cachorro. Em um determinado momento do meu programa eu crio uma instncia da classe
Cachorro (rex, por exemplo). Na definio da classe Cachorro esto os mtodos latir( ),
balanarRabo( ) e comer( ). Isto no quer dizer que no momento da criao esses mtodos vo ser
executados. Eles esto l, disponveis, mas esperando para serem chamados. S se o meu programa
principal usar o comando rex.latir( ) que a instncia criada vai poder entrar em ao executando o
mtodo latir( ).
Para encerrar este tpico, uma ltima pergunta: se, como dissemos, na Programao
Orientada a Objetos escrever um programa significa escrever classes e sub-classes e sub-subclasses, ento porque no estamos falando de Programao Orientada a Classes? Simples. que as
classes no podem fazer nada, s os objetos podem. Como programar a arte de fazer acontecer, e
s os objetos podem fazer acontecer, ento ficou sendo Programao Orientada a Objetos.
Com isto encerramos esta parte conceitual dos fundamentos da programao. Existem
muitos outros conceitos a serem vistos dentro da Programao Orientada a objetos, como mtodo
principal, construtores, sobrecarga e outros, mas veremos estes conceitos medida que formos
conhecendo e aplicando os comandos e estruturas do Java.

Criando e executando um programa no console

Depois de tanto bl bl bl vamos fazer uma atividade prtica para vermos o Java em
ao. Como vimos, para executar um programa Java voc precisa ter uma JVM (Mquina
Virtual Java) instalada no seu computador. Para verificar se voc tem faa o seguinte:
se seu computador for Windows
V em Iniciar Programas Acessrios Prompt do DOS
se se seu computador for Linux
V em Iniciar Executar Comando digite konsole e tecle ENTER
Em ambos os casos, vai aparecer uma janela com fundo preto e um cursor piscando.
Essa janela uma simulao daqueles computadores antigos de quando ainda no existiam os
softwares grficos. Esta janela chamada de console e muito apropriada para pequenos
testes e verificao de configurao. Sempre que, nesta apostila ou em qualquer outro manual
ou tutorial, for pedido para voc abrir um console, para repetir esse procedimento.
Bom, depois de aberto o console, digite o comando abaixo e tecle ENTER:
java -version
Repare que no tem espao entre o sinal de menos e a palavra version. Esse comando
serve para verificar qual a verso da JVM que est instalada no seu computador. Se a JVM
estiver instalada, ela ir responder mostrando na tela uma (ou mais) linha(s), comeando por:
java version 1.5.0-02
Os nmeros podem variar dependendo da verso que voc tiver. Se a resposta for uma
mensagem de erro dizendo que java um comando desconhecido, porque no tem JVM
instalada. Para instalar a JVM s ir na pgina da Sun (desenvolvedora do Java) e fazer o
download do arquivo de instalao correspondente sua plataforma (Windows, Linux, etc). As
verses para Windows, Linux e Solaris podem ser encontradas em
http://java.sun.com/javase/downloads/index.jsp

Curso Bsico de JAVA

30

Se voc quiser apenas rodar programas JAVA que j esto prontos, basta escolher a
verso JRE 6 Update 7. Se voc quiser escrever e compilar seus prprios programas,
escolha a verso JDK 6 Update 7.
Depois de concludo o download, se sua mquina for Windows, basta clicar duas vezes
sobre o instalador e seguir as instrues. Se for Linux um pouco mais complicado, pea
ajuda a algum mais experiente.
Uma vez instalada a JVM (ou se a sua j estava instalada) abra o editor de texto mais
simples que tiver em seu computador.
se for Windows
V em Iniciar Programas Acessrios Bloco de Notas (notepad)
se for Linux
V em Iniciar Executar Comando digite kedit e tecle ENTER
O cdigo-fonte em JAVA deve ser salvo sempre com a extenso .java (ponto java), por
exemplo:
BomDia.java
Calculadora.java
BatalhaNaval.java
Repare que no h espaos em branco entre as palavras, tudo junto mesmo. Crie
uma pasta chamada CursoJava para armazenar os programas e exerccios que faremos ao
longo do curso. Entre na pasta. Anote o endereo da pasta, pois vamos precisar digit-lo no
console. Para saber qual o endereo, veja no topo da janela do Gerenciador de Arquivos.
se for Windows - est ao lado da palavra Endereo. Exemplo: c:\Documents and
Settings\Mauricio\Meus documentos\Curso Java
se for Linux est ao lado da palavra Localizao. Exemplo:
/home/users/Mauricio/CursoJava
Abra o editor de texto e copie as linhas abaixo (ateno para as maisculas e
minsculas, muito importante copiar exatamente como est escrito):
class BomDia {
public static void main(String[] args) {
System.out.println(Bom dia!);

}
}
No se preocupe em entender o cdigo; apenas um exemplo para voc ver como se
escreve, compila e executa um programa em Java. Explicaremos o significado dessas linhas
mais tarde. Salve o arquivo dentro da pasta CursoJava com o nome de BomDia.java.
Abra a pasta CursoJava. S h um arquivo l dentro, certo? o arquivo BomDia.java
contendo o cdigo que acabamos de escrever.
Agora vamos compilar o nosso cdigofonte (BomDia.java) para gerar o bytecode. Abra
o console e navegue at a pasta CursoJava. Para fazer isto preciso digitar o seguinte
comando:
cd endereo-que-voc-anotou

Curso Bsico de JAVA

31

Exemplo:
no Windows:
cd c:\Documents and Settings\Mauricio\Meus documentos\CursoJava
no Linux:
cd /home/users/Mauricio/CursoJava
Agora execute:
javac BomDia.java
Se no aparecer nenhuma mensagem de erro, sinal que correu tudo bem. Se
aparecerem mensagens de erro, abra de novo o BomDia.java (no editor de texto) e confira
para ver se no digitou nada errado, depois abra o console e compile novamente.
Se o prompt (cursor) voltar a ficar piscando porque o arquivo foi compilado com
sucesso.
Porm, se aparecer uma mensagem dizendo que javac um comando desconhecido,
porque o computador no sabe aonde est armazenado o programa javac. Voc vai ter que
indormar isto a ele. Para fazer isso, faa:
se for Windows
V em Iniciar Painel de Controle Sistema Avanado Variveis de
Ambiente na parte de baixo da janela que abrir, seleciona a linha que comea
com Path (clique na linha para selecion-la) Edit na janela que surgir clique
no final da linha (ao lado do cursor que est piscando), acrescente um ponto-evrgula (;) ao final da linha e digite o caminho do diretrio onde esto os binrios
do Java:
C:\Arquivos de programas\Java\jdk1.5.0_02\bin
O nmero pode variar em funo da verso que voc tiver. Use aqui o mesmo
nmero que aparece quando voc usa o comando java version.
Aps digitar, confirme clicando em OK, depois em OK e finalmente em OK.
se for Linux
Abra o console e digite
export PATH=$PATH:/usr/java/jdk1.5.0_02\bin e ENTER (o numero pode
variar em funo da verso que voc tiver. Use aqui o mesmo numero que aparece
quando voc usa o comando java version).
O problema que essa uma alterao temporria, ou seja, se voc desligar o
computador, perde a configurao e vai ter que repetir este procedimento da prxima
vez que ligar o computador. Uma maneira mais permanente de fazer isso editar o
arquivo profile, que est no diretrio /etc (voc dever estar logado como um usurio
que tenha permisso para fazer isso). Outra opo modificar o seu perfil no arquivo
.bashrc (arquivo oculto). Em ambos os casos, a modificao a mesma: adicione ao
final do arquivo o comando:
export PATH=$PATH:/usr/java/jdk1.5.0_02\bin
O numero pode variar em funo da verso que voc tiver. Use aqui o mesmo numero
que aparece quando voc usa o comando java version.
Este procedimento bem mais complicado, se tiver dificuldades pea ajuda a algum
mais experiente.

Curso Bsico de JAVA

32

Agora abra de novo a pasta CursoJava. Agora alm do arquivo BomDia.java

(cdigofonte) tem outro arquivo chamado BomDia.class. Este arquivo foi gerado pelo
compilador e, portanto, o bytecode (veja a figura 5). Para executar o programa, abra o
console e digite:
java BomDia
Vai aparecer na tela do console a frase Bom dia ! isso significa que est tudo certo
com o seu ambiente e que voc acabou de criar, compilar e executar o seu primeiro programa
em Java.
Tudo bem, no foi voc quem criou, voc apenas copiou... mas esse o primeiro passo.
Este programa muito simples e a nica coisa que ele faz imprimir um texto no console.
Mesmo sem entender o que significam as linhas que ns copiamos, abra o BomDia.java
e analise o seu contedo. Veja se voc consegue descobrir que pedao do programa
responsvel por imprimir o texto na tela. Tente alterar o programa para imprimir o seu nome
na tela. Altere, salve, compile e execute para ver se suas alteraes funcionaram. Se voc
conseguiu, abra de novo e altere o programa para que ele imprima o seu primeiro nome em
uma linha e o sobrenome em outra.
Essa uma das melhores maneiras de conhecer e aprender os comandos de uma
linguagem. Se a gente abre o cdigo de um programa que outra pessoa escreveu e v ali um
comando que a gente no conhece, pode ir fazendo alteraes (sempre segundo o roteiro:
altera-salva-compila-executa) e vendo o que acontece. Com base nas nossas observaes,
podemos at entender para que serve e como funciona um comando que nunca vimos antes.
Mas ateno: isso s funciona se a gente fizer uma alterao de cada vez. Altera uma
coisa, salvacompilaexecuta e v o que aconteceu. Depois volta ao que era antes e salvacompila-executa de novo para ver se ele voltou a fazer o que fazia antes da alterao. A voc
pode fazer outra alterao e testar para ver o resultado. Sempre uma de cada vez e sempre
voltando ao que era. importante anotar o comando original antes de alterar pra no correr o
risco de voc esquecer o que estava digitando e no ter mais como desfazer a sua alterao.
Tambm importante fazer apenas uma alterao de cada vez, por que se voc fizer cinco
alteraes de uma vez, como que vai saber qual delas provocou o efeito observado?
Uma boa idia para evitar problemas fazer uma cpia do programa antes de comear
a mexer nele. Assim, se voc fizer alguma mudana e no conseguir mais voltar atrs, ter
uma cpia do programa original para deixar tudo direitinho do jeito que estava.

Criando e executando um programa no BlueJ

Criar, compilar e executar programas pequenos como o BomDia.java usando o Kedit e o
console no traz grandes dificuldades. O cdigo do nosso programa foi todo escrito em um
nico arquivo (tambm, um programa de 5 linhas ...). Mas existem programas que so
divididos em vrios mdulos (arquivos), cada um contendo um trecho do cdigo. Esses
mdulos podem fazer referncia uns aos outros, estabelecendo vnculos entre eles. Um mdulo
pode apontar para um ou mais mdulos, os quais, por sua vez, podem apontar para outros e
assim por diante, formando um emaranhado de vnculos difcil de controlar se a quantidade de
mdulos for muito grande. Na hora de compilar ento uma confuso, porque ao alterar e
recompilar um mdulo preciso recompilar todos os mdulos que fazem referncia a ele e
depois todos os mdulos que fazem queles e assim por diante. Ou seja, muito fcil se
perder e esquecer de compilar um mdulo e a o programa ou vai dar erro ou no vai funcionar
como deveria.

Curso Bsico de JAVA

33

Com o crescimento do Java (bem como de outras linguagens de programao) foram

criados programas para ajudar os programadores nessa tarefa de edio, compilao e
controle dos relacionamentos entre os mdulos. Esses programas so chamados de IDE (do
ingls Integrated Development Environment) Ambiente Integrado de Desenvolvimento.
como naquelas propagandas em que aparece uma pessoa gripada comprando um
monte de remdios para gripe, e a aparece outra e diz: Pra que voc vai comprar tudo isso?
Leva esse, que ao mesmo tempo anti-trmico, analgsico, descongestionante, antibitico ...
O IDE assim. Ele ao mesmo tempo um editor de texto (para escrevermos o cdigofonte), um compilador (para gerarmos o bytecode), um depurador (depuradores so
programas que nos ajudam a encontrar e corrigir erros no cdigo-fonte), um linkador
(linkadores so programas que juntam todos os mdulos em um s arquivo que pode ser
levado para rodar em outro computador) e mais outras funes.
Existem IDEs que oferecem mais recursos que outros e que precisariam de um curso e
de uma apostila s para aprender a trabalhar com eles. No nosso curso vamos usar o BlueJ,
que um IDE bem simples e fcil de aprender e que tem tudo que a gente precisa para fazer
os nossos programas. Assim, no vamos ficar perdendo tempo aprendendo a lidar com o IDE e
poderemos nos concentrar em aprender o Java.
O BlueJ pode ser baixado no site:
http://www.bluej.org
Ele tm verses para Windows e Linux. Uma vez instalado, basta clicar no cone para
abr-lo e ele apresenta a seguinte tela inicial:

Fig. 7 Tela Inicial do BlueJ

A primeira coisa a fazer criar um projeto. Um projeto como uma pasta onde o BlueJ
armazena tudo que preciso para rodar o programa: o cdigo-fonte e o bytecode (ou os
cdigos-fonte e os bytecodes se o programa estiver dividido em mdulos). Vamos criar um
projeto para cada programa que fizermos ao longo do curso.

Curso Bsico de JAVA

34

Vamos fazer um programa bem simples s para ilustrar o processo. Clique em Project
e a seguir em New Project, navegue at a pasta desejada (no nosso caso CursoJava), digite o
nome do projeto e clique em Create (Fig. 8).

Fig.8 Criando um projeto

Veja que a barra de ttulo exibe o nome do projeto que est aberto. Na rea de trabalho
por enquanto s tem um arquivo. Esse arquivo serve para colocar informaes sobre o(s)
autor(es) do projeto, data de criao, nmero da verso e etc. mais para programadores
profissionais. No nosso curso no vamos perder tempo com ele.
Agora vamos escrever o nosso cdigo-fonte. Para isso temos que criar uma classe.
Vamos aprender o que classe mais adiante. Neste programa voc vai fazer o mesmo que fez
no BomDia.java, ou seja, vai copiar o que estamos fazendo mesmo que voc no entenda
exatamente o contedo do cdigo. A idia aqui apenas ilustrar o processo de edio,
compilao e execuo no BlueJ que precisaremos repetir vrias vezes no decorrer do curso.
Para criar uma classe, clique em NewClass. Escreva o nome da classe e clique em Ok
(Fig. 9). Observe que o nome da classe no precisa ser o mesmo do projeto. Nosso projeto
ter apenas uma classe, mas h projetos com dezenas de classes (mdulos), cada uma com
um nome diferente.

Figura 9 - Criando uma classe.

Curso Bsico de JAVA

35

Veja que agora existe um novo arquivo na rea de trabalho com o nome de classe que
criamos. Reparou que o arquivo est hachurado (cheio de listras diagonais)? Isto significa que
ele ainda no foi compilado.
D um duplo-clique no desenho da classe para abrir o editor de texto. J existe um cdigo
escrito na nossa classe. Este um cdigoexemplo que o BlueJ gera automaticamente ao criar
a classe. Vamos aproveitar apenas um pedao desse cdigo. Delete os as linhas em azul do
comeo do cdigo e todas as linhas que esto entre a primeira chave e a ltima. (para deletar,
selecione as linhas com o mouse e pressione a tecla Delete do seu teclado). O cdigo vai ficar
assim:

Figura 10 esqueleto do cdigo

Agora digite o texto do programa. O cdigo pronto deve ficar assim:

Curso Bsico de JAVA

36

Figura 11 cdigo - fonte

Para compilar clique no boto Compile. Aps uma pausa, se no houver erros vai aparecer no
rodap a mensagem Class compile no syntax errors, que quer dizer, Classe compilada
sem erros de sintaxe. Feche o editor de texto. Repare que a caixa que simboliza a classe
agora no tem mais as diagonais. Isso indica que o programa est compilado e pronto para ser
executado. Para rodar o programa clique com o boto direito na classe e escolha a opo void
main (string [ ] args) (Figura 12).

Figura 12 Executando o programa

Curso Bsico de JAVA

37

Clique em Ok na prxima janela e abrir uma nova janela com o resultado da execuo.

Figura 13 Resultado do execuo do programa

Como voc pode ver, um programa idntico ao BomDia.java, s que o texto mostrado
na tela diferente e impresso em 3 linhas ao invs de uma. Compare este cdigo com o do
BomDia.java para ver as diferenas. A partir de agora, todos os programas que mostrarmos ao
longo da apostila devero ser digitados, compilados e testados no BlueJ, seguindo este
procedimento.

PARTE III Regras de Sintaxe

Curso Bsico de JAVA

38

Comentrios
Exemplo de Comentrio

Descrio

int x; // posio no eixo X

Do // at o final da linha ser ignorado pelo compilador

/*
A varivel x um nmero
inteiro que representa a
posio no eixo x
*/
int x;

Todo texto compreendido entre o /* e o */ ser ignorado

pelo compilador

/**
A varivel x um nmero
inteiro que representa a
posio no eixo x

Todo texto compreendido entre o /** e o */ ser ignorado

pelo compilador , mas pode ser usado pelo javadoc

*/
int x;

O programa javadoc (que vem no pacote de instalao do Java), l todos os comentrios iniciados
por /** e gera um documento HTML contendo estas informaes.

Definio de Classe

Sintaxe da Definio de Classe

modificador class <Nome-da-classe>
{
<campos>...
<construtores>
<mtodos>
}

modificador : pode ser public (que significa que qualquer outra classe pode criar
objetos a partir dessa classe), ou private (que significa que no podem ser criados
objetos dessa classe).
class uma palavra-reservada do Java que significa que esta uma declarao de
uma classe.
<Nome-da-classe> : aqui entra o nome da classe, sempre comeando com letra
maiscula

Exemplo:
public class Cachorro

Curso Bsico de JAVA

39

{
// aqui entram as linhas do programa
}
Figura 25 Definio da Classe Cachorro
Definio de Mtodo
Sintaxe da Definio de Mtodo
modificador void <nome-do-mtodo>(<lista de parmetros>)
{
<comandos>...
}
modificador <tipo-de-retorno> <nome-do-mtodo>(<lista de parmetros>)
{
<comandos>...
}

modificador : pode ser public (que significa que qualquer classe externa pode
invocar este mtodo), ou private (que significa que este mtodo somente pode ser
invocado a partir da classe onde ele foi definido).
void uma palavra-reservada do Java que significa que este mtodo no retorna
nenhum dado ao final da execuo das instrues.
<tipo-de-retorno>: o tipo de dado que o mtodo retorna classe que o invocou, ao
final da execuo das instrues. Um mtodo s pode retornar um nico dado.
<nome-do-mtodo> : aqui entra o nome do mtodo, sempre comeando com letra
minscula e sendo de preferncia um verbo.
<lista de parmetros>: so os parmetros que o mtodo recebe da classe que o
chamou. Pode ter nenhum, um ou mais de um parmetro. Se houver mais de um
parmetro, eles devem estar separados por vrgulas. Cada parmetro composto do
tipo-de-dado do parmetro, seguido do nome-do-parmetro. (Ex: int nota, double
preo, String nome, etc).

Observe que a segunda informao que consta do cabealho do mtodo OU void OU o tipo-dedado de retorno. Ou seja, ou o mtodo retorna alguma informao (e nesse caso ele especifica no
cabealho do mtodo qual o tipo de dado) ou ento no retorna nada (e nesse caso ele usa a palavra
void, para indicar isto.).
Outra observao importante que aps o nome do mtodo sempre haver um par de parnteses,
mesmo que no haja nenhuma lista de parmetros.
A combinao do nome do mtodo mais a lista de parmetros chamada de assinatura do mtodo.

Curso Bsico de JAVA

40

Exemplos de mtodos:
public void latir() {
System.out.println(Au! Au!);
}
Figura 26 Definio do mtodo latir()

public double calculaMedia(double nota1, double nota2) {

media = (nota1 + nota2) / 2
return media
}
O primeiro exemplo uma definio de um mtodo que, ao ser invocado, imprime na tela a String
Au! Au!. O modificador public indica que este mtodo pblico e portanto pode ser invocado
por outras classes. A palavra reservada void indica que este mtodo no retorna nenhum valor para
a classe que o chamou. A lista de parmetros vazia indica que este mtodo no precisa receber
nenhuma informao adicional para cumprir as instrues.
O segundo exemplo uma definio de um mtodo que, ao ser invocado, recebe dois parmetros
(duas notas de prova), calcula a mdia dessas notas e retorna o resultado deste clculo, ou seja a
mdia. O modificador public indica que este mtodo pblico e portanto pode ser invocado por
outras classes. O tipo de dados double indica que este mtodo retorna um valor real (pode ter casas
decimais) para a classe que o chamou. A lista de parmetros contm dois valores reais (nota1 e
nota2) que so passados para o mtodo pela classe que fez a invocao do mtodo. Dentro do corpo
do mtodo, h a instruo return, que, neste exemplo, obrigatoriamente deve retornar um valor
real, de acordo com o que foi definido no cabealho do mtodo. Neste caso, a instruo return,
retorna o valor da mdia das notas recebidas como parmetro.

Invocao de Mtodo
Sintaxe da Invocao de Mtodo
<instancia>.<mtodo>()
<variavel> = <instancia>.<mtodo>(<parmetros>...)

Para dar uma ordem de latir a um co rex, por exemplo, o comando seria:
rex.latir();

Curso Bsico de JAVA

41

No caso de um mtodo que retorna um valor, eu tanto posso usar o valor diretamente, como posso
armazen-lo em uma varivel para uso futuro. Por exemplo, suponha que eu tenho uma classe
chamada Aluno, que tem no corpo da classe a definio de um mtodo chamado calculaMdia
(como no exemplo anterior). Eis alguns exemplos de invocao deste mtodo para um aluno
chamado aluno1:
System.out.println(aluno1.calculaMdia(9 , 8));
mediaAluno = aluno1.calculaMdia(6 , 10);
No primeiro exemplo, h uma instruo de impresso. Repare que a invocao do mtodo ocorre
dentro dos parnteses do comando de impresso println. Aps terminada a execuo do mtodo, o
valor retornado ser impresso na tela pois a instruo original ter se transformado em:
System.out.println(8.5), aonde 8.5 o valor retornado pelo mtodo, ou seja, a mdia entre as duas
notas passadas como parmetro.
No segundo exemplo o valor retornado pelo mtodo ser armazenado na varivel mediaAluno.
Aps a execuo do mtodo, a instruo original ter se transformado em: mediaAluno = 8, aonde
8 o valor retornado pelo mtodo, ou seja, a mdia entre as duas notas passadas como parmetro..

Mtodo Principal e Mtodo Construtor

Podemos criar quantos mtodos quisermos e temos total liberdade para usar o nome de mtodo que
desejarmos, porm existem dois mtodos especiais cujos nomes so reservados, ou seja, no
poderemos us-los para nomear os nossos mtodos. Esses mtodos especiais so:
Mtodo principal (main)
O mtodo principal o mtodo por onde comea a execuo do programa principal. Um
projeto pode ser composto de vrios programas (mdulos), como vimos quando estudamos a
modularizao. Um mdulo pode chamar outros mdulos e assim sucessivamente. Porm,
dentre todos os mdulos que compem aquele projeto, apenas um ser o programa principal,
e esse programa principal que ns iremos executar e que chamar os mdulos
subordinados. Esse programa principal pode ter vrios mtodos, mas obrigatoriamente ter
entre os seus mtodos o mtodo main (principal).
Ao executar o programa principal, o computador procura o mtodo main e inicia a execuo
do programa seguindo as instrues que estiverem no corpo deste mtodo.
O cabealho do mtodo principal sempre o mesmo, e se escreve assim:
public static void main(String[] args)

Mtodo Construtor
Toda classe tem que ter um mtodo construtor. Esse mtodo invocado toda vez que
criada uma instncia daquela classe, ou seja, um objeto daquela classe. Por exemplo, ao
definir uma classe Cachorro, devemos escrever, dentro do corpo da classe, um mtodo
construtor que ser executado toda vez que criarmos uma instncia de Cachorro. Como este
mtodo chamado no ato da criao de um objeto, o lugar ideal para fazer as
inicializaes das variveis da classe (veremos o conceito de inicializao mais adiante).

Curso Bsico de JAVA

42

Quando no criamos um mtodo construtor, o prprio Java cria um para ns. Neste caso,
ser um mtodo construtor vazio, que no executa nenhuma tarefa especfica.
O cabealho do mtodo construtor foge um pouco regra que vimos na sintaxe da definio
de mtodos. Ele no retorna nenhum tipo de dados, mas no precisa ter a palavra void para
indicar isto. O nome do mtodo sempre igual ao nome da classe. Como o nome da classe
escrito com a inicial em maiscula, o mtodo construtor o nico mtodo que tem o seu
nome comeando com letra maiscula (como vimos, todos os outros mtodos comeam com
letra minscula e tem nome de verbo). Portanto a sintaxe do mtodo construtor ser:
Sintaxe da Definio de Mtodo Construtor
modificador <Nome-da-classe>(<lista de parmetros>) {
<comandos>...
}

modificador : pode ser public (que significa que qualquer classe externa pode
invocar este mtodo), ou private (que significa que este mtodo somente pode ser
invocado a partir da classe onde ele foi definido).
<Nome-da-classe> : o nome do mtodo sempre ser igual ao nome da classe.
<lista de parmetros>: so os parmetros que o mtodo recebe da classe que o
chamou. Pode ter nenhum, um ou mais de um parmetro. Se houver mais de um
parmetro, eles devem estar separados por vrgulas. Cada parmetro composto do
tipo-de-dado do parmetro, seguido do nome-do-parmetro. (Ex: int nota, double
preo, String nome, etc).

Exemplos de cabealhos de mtodos construtores:

o
o
o
o

public Cachorro()
public Lmpada()
public Bicicleta()
public Circulo()

O mtodo construtor chamado na criao de um objeto e isto acontece no programa

atravs da instruo de criao new, que veremos mais adiante no tpico Criando
Instncias de Classe.

Declarao de variveis
Normalmente, a primeira coisa que fazemos em um programa (ou em um mtodo) declarar as
variveis que sero utilizadas. A instruo de declarao serve para dizer ao computador o nome e o
tipo de dados da varivel. Se tentarmos usar uma varivel que no foi declarada, o compilador vai
dar erro indicando que o computador no conhece aquela varivel. Somente a partir da instruo de
declarao que o computador toma conhecimento da existncia da varivel e s a partir da
poderemos us-la em instrues.
Sintaxes da Declarao de variveis
<tipo-de-dado> <variavel>;

Curso Bsico de JAVA

43

<tipo-de-dado> <variavel-1>, <variavel-2>, ..., <variavel-n>;

<tipo-de-dado> <variavel> = <valor-de-dado>;

No primeiro caso, temos a declarao de apenas uma varivel. Primeiro indicamos o tipo de dado e
a seguir indicamos o nome da varivel. No segundo caso temos a declarao de vrias variveis do
mesmo tipo em uma nica instruo. Os vrios nomes de variveis so separados por vrgulas. No
terceiro caso, temos, em uma mesma instruo a declarao de uma varivel e a inicializao da
varivel, ou seja, a atribuio de um valor inicial para a varivel. Note que todas as declaraes
terminam com ponto-e-vrgula.
O tipo-de-dado pode ser um tipo de dado primitivo (int, boolean, char, etc), um tipo de dado
definido pelo sistema (String, JLabel, JOptionPane, etc), ou um tipo de dado definido pelo
usurio (Cachorro, Triangulo, etc). O valor pode ser um literal, ou uma instncia de um tipo
definido pelo usurio, como Cachorro. Literal todo e qualquer valor que a gente escreve
diretamente em uma linha do programa (ex: 57, true, M, caloi, etc).
Exemplos:
int qtdeAlunos;
int idade = 9;
boolean terminou = false;
Cachorro rex = new Cachorro();

Os tipos de dados mais simples so chamados de primitivos. Existem oito tipos de dados primitivos
em Java, sendo seis numricos, um caracter e um booleano. O quadro a seguir mostra os oito tipos.
A primeira coluna mostra como eles so representados no Java, a segunda coluna mostra o tamanho
do espao de memria usado para armazenar o valor e a terceira coluna mostra a faixa de valores
permitidos.
Tipo de Dados

Tamanho

Faixa de Valores

byte

1 byte

-128 at 127

short

2 bytes

-32.768 at 32.767

int

4 bytes

-2.147.648 at 2.147.483.647

long

8 bytes

-9.223.372.036.854.775.808 at
9.223.373.036.854.775.807

float

4 bytes

-3.4x1038 at 3.4x1038

double

8 bytes

-1.8x10308 at 1.8x10308

char

2 bytes

letras, dgitos e caracteres

especiais

boolean

1 bit

true ou false

Curso Bsico de JAVA

44

Os quatro primeiros tipos so usados para armazenar valores numricos inteiros. A diferena entre
eles o espao ocupado na memria (e portanto a faixa de valores permitida).
Por exemplo, se eu estou escrevendo um programa para rodar em um celular, eu preciso economizar
espao de memria pois o celular no tem tanta memria quanto um computador. Ento se eu tenho
uma varivel numrica no meu programa e eu sei que o valor mximo que aquela varivel pode
assumir 100, eu posso usar o tipo byte que permite armazenar nmeros entre -128 e 127. Se eu
usasse o tipo int eu estaria reservando quatro vezes mais memria do que o necessrio, pois o tipo
int ocupa 4 bytes de memria enquanto o tipo byte ocupa apenas 1. Agora, se eu estiver escrevendo
um programa para contar quantas estrelas tem em uma galxia, eu no posso usar os tipos byte,
short ou int, porque eles no comportariam o nmero resultante da contagem. Eu teria que usar o
tipo long, que ocupa 8 bytes de memria, mas me permite armazenar nmeros at nove
quinquilhes, duzentos e vinte e trs quatrilhes, trezentos e setenta e dois trilhes, trinta e seis
bilhes, oitocentos e cinqenta e quatro milhes, setecentos e setenta e cinco mil e oitocentos e
sete ... Ufa!
Na prtica, o tipo mais usado para armazenar nmeros inteiros o int.
Os tipos float e double so usados para armazenar valores reais, ou seja, podem ter casas decimais.
Eles so representados de forma aproximada no computador usando o que chamamos de notao de
ponto flutuante. O tipo float o menor e permite representar nmeros com uma preciso de at 8
casas decimais. O double ocupa o dobro do espao de memria, mas permite armazenar nmeros
com preciso de at 15 casas decimais. No Java, a casa decimal representada com ponto e no
com vrgula. (Ex: 7.5 , 32.58 , 4.8759 , etc).
Na prtica, o tipo mais usado para armazenar nmeros reais o double.
O tipo char usado para armazenar um nico caracter. Este caracter pode ser uma letra
(m,A,etc), um dgito (2,9, etc) ou um caracter especial (/,!,*, etc). Nos programas,
atribumos valores uma varivel do tipo char usando aspas simples (Ex: resposta = A).
Finalmente, o tipo boolean serve para armazenar um dos dois valores booleanos: verdadeiro ou
falso. Como o Java todo em ingls, usam-se os valores true (verdadeiro) ou false (falso).
Nessa lista de tipos de dados est faltando um muito importante e muito utilizado que o string. O
string uma cadeia de caracteres, ou seja, usado para armazenar palavras ou frases. Para atribuir
um valor a uma varivel do tipo string, usam-se aspas duplas (Ex: nome = Joo da Silva, rua =
Avenida Presidente Vargas, etc). Em vrias linguagens de programao o string definido como
um tipo primitivo, porm no Java diferente. O Java definiu uma classe chamada String que est
na biblioteca java.lang. Como uma classe, ele tem uma srie de mtodos que nos permitem fazer
operaes as mais diversas como por exemplo, transformar todo o contedo da varivel em
maisculas, ou ento procurar dentro da String por uma determinada letra e substitu-la por outra.
Existem cerca de 50 mtodos que uma String capaz de realizar.
Esta classe String, to utilizada que no precisamos declarar, no incio do programa, a instruo de
importao de bibliotecas (como fazemos sempre que queremos usar no nosso programa uma das
classes definidas pelo Java). Ela quase como se fosse um tipo de dados primitivo, a diferena
que ela, por ser um objeto de uma classe, sabe realizar uma srie de aes. por isso que o tipo de
dados String escrito com a primeira letra em maiscula (como so todas as classes), ao contrrio
dos tipos de dados primitivos, que so todos escritos com a inicial em minscula.

Curso Bsico de JAVA

45

O nome da varivel deve comear com letra minscula e pode ter letras e nmeros, mas no deve
conter espaos, hfens, barras ou coisas assim. Pode ser um nome simples (nome, qtde, nota, etc) ou
composto (nomeCliente, qtdeDiasEmAtraso, notaProva1, etc). No caso de nomes compostos, o
primeiro tem a inicial com letra minsculas e os demais tem a inicial com letra maiscula. Note que
tudo colado mesmo, no h espao entre eles.
Devemos sempre tentar escolher um nome sugestivo, que indique o que aquela varivel ir
armazenar. Por exemplo, se eu vou usar no meu programa uma varivel para contar o nmero de
alunos em uma sala de aula, eu poderia criar uma varivel chamada numAlunos ou qtdeAlunos.
Porm uma varivel chamada num, qtde ou xyz, no indica claramente o contedo da varivel.
Outra coisa importante: o Java aceita qualquer caracter na composio do nome. Isto significa que
podemos criar nomes de variveis com acentos ou cedilhas. Porm devemos evitar usar esses
caracteres porque quando mudamos de plataforma normalmente esses caracteres so substitudos na
outra plataforma. Por exemplo, se eu estou escrevendo um programa usando um computador da
plataforma Windows, ao compilar e levar o bytecode para executar em um computador da
plataforma Linux pode ser que ele transforme os cedilhas, acentos agudos e etc em outros caracteres
e a o programa vai dar erro. O mesmo se eu estou escrevendo em um computador Linux, compilo e
levo o bytecode para executar em um computador Windows. Como queremos que nosso programa
execute em qualquer plataforma, devemos evitar o uso desses caracteres nos nomes das nossas
variveis. O mesmo vale para nomes de classes e nomes de mtodos.

Instruo de Atribuio
Depois de declaradas as variveis, devemos atribuir um valor inicial a elas. Para isso, usamos a
instruo de atribuio. Este procedimento conhecido como inicializao das variveis.
Sintaxe da Operao de Atribuio
<tipo-de-dado> <variavel> = <valor-de-dado>;
<tipo-de-dado> <variavel>;
<comandos diversos>...
<variavel> = <valor-de-dados>;

O sinal de igual (=) no Java no sinnimo de comparao mas sim de atribuio. Usamos a
instruo de atribuio para alterar o contedo de uma varivel. Quando o computador encontra em
uma linha o sinal =, ele pega o que est do lado direito do sinal e joga dentro da varivel que est do
lado esquerdo. Dizemos que ele atribui o que est do lado direito varivel que est do lado
esquerdo.
No primeiro caso eu estou definindo a varivel e fazendo a atribuio do valor inicial em uma nica
linha do meu programa.
No segundo caso, eu uso uma linha do programa para definir a varivel. Depois, seguem-se outras
linhas de comandos diversos (provavelmente outras linhas de definio das demais variveis) e
finalmente aparece uma linha contendo a instruo de atribuio. Ou seja, eu posso definir a
varivel em uma linha e atribuir o valor em outra.

Curso Bsico de JAVA

46

A instruo de atribuio no utilizada somente na inicializao das variveis. A qualquer

momento do meu programa, eu posso ter uma instruo de atribuio.

Exemplos:
int x = 4;
media = (n1 + n2) / 2;
temperatura = 21.4;
Qtde = qtde + 1;
rex = new Cachorro();

Observe que eu tanto posso ter do lado direito do sinal de igual um valor literal (como em
temperatura = 21.4 ou int x = 4), como posso ter uma expresso (como em media = (n1 + n2) / 2).
Se o computador encontra uma expresso do lado direito da instruo de atribuio, ele primeiro
resolve a expresso e depois atribui o resultado varivel do lado esquerdo. As regras de resoluo
de expresses so as mesmas aplicadas resoluo de expresses matemticas.

Criando Instncias de Classe

Vamos juntar o mtodo definido na Figura 26 (latir()) com a classe definida na Figura 25
(Cachorro). Teremos uma classe Cachorro com um mtodo latir():
public class Cachorro
{
public void latir()
{
System.out.println(Au! Au!);
}
}
Figura 27 Definio da Classe Cachorro com mtodo latir()
Abra o BlueJ e crie um novo projeto chamado Canil. Agora crie uma nova classe chamada
Cachorro, delete as linhas de exemplo criadas pelo BlueJ, deixando apenas o cabealho da classe e
as chaves e digite o cdigo da Figura 27. Vamos agora criar um programa principal para poder testar
o mtodo latir() da classe Cachorro. Para fazer isso crie uma nova classe dentro do projeto Canil e
d a ela o nome de VidaDeCachorro. Delete as linhas de exemplo e digite o cdigo da Figura 28
abaixo:
public class VidaDeCachorro
{
public static void main(String[] args)
{
Cachorro caozinho = new Cachorro();
caozinho.latir();
}

Curso Bsico de JAVA

47

}
Figura 28 Testando o mtodo latir() da classe Cachorro
Compile as duas classes para ver se no h erros de digitao e a seguir execute o programa
principal. Para executar o programa principal basta clicar sobre ele com o boto direito do mouse e
clicar na opo void main(String[] args) que aparece no menu (se tiver dvidas, consulte as
pginas 16 a 19 para ver como se faz). O programa principal, no nosso caso, a classe
VidaDeCachorro. Ao executar, o programa ir abrir uma tela de console para exibir a mensagem
que ns mandamos imprimir.Veja na Figura 29, o resultado da execuo:

Figura 29 Resultado da execuo do programa VidaDeCachorro

Agora vamos analisar o programa VidaDeCachorro. Como vimos, ao iniciar a execuo do
programa principal, o computador procura pelo mtodo principal para poder executar as instrues
que esto no corpo deste mtodo. No programa VidaDeCachorro s existe um mtodo, justamente o
mtodo principal. A primeira instruo do mtodo principal uma instruo de declarao de
varivel junto com a inicializao desta varivel:
Cachorro caozinho = new Cachorro();
A primeira parte da instruo (Cachorro caozinho) segue a sintaxe da instruo de declarao de
variveis que, como j vimos, especifica o tipo-de-dado e a seguir especifica o nome-da-varivel.
Neste caso, a varivel se chama caozinho e do tipo Cachorro. Uma varivel do tipo int (inteiro)
serve para armazenar valores inteiros, uma varivel do tipo char (caracter) armazena um caracter,
uma varivel do tipo String armazena uma cadeia de caracteres, e assim por diante. Uma varivel do
tipo Cachorro, serve para armazenar instncias da classe Cachorro, ou seja, objetos da classe
Cachorro.
A criao de um objeto (ou seja, de uma instncia de uma classe), feita atravs do comando new.
O comando new tem a seguinte sintaxe:
Sintaxe do comando new
new <tipo-de-dado>();
<tipo-de-dado> <variavel> = new <tipo-de-dado>();

No primeiro caso temos a criao de um objeto de uma classe. No segundo caso temos a criao de
um objeto e a atribuio deste objeto a uma varivel. A forma mais usada a segunda. Na maioria
das vezes, ao criarmos um objeto, armazenamos este objeto em uma varivel para que possamos dar
ordens (chamar os mtodos) deste objeto posteriormente. Foi o que fizemos no nosso programa
VidaDeCachorro.

Curso Bsico de JAVA

48

Ao encontrar o comando new, o computador j sabe que deve criar uma instncia de uma classe,
mas precisamos especificar que classe essa. Fazemos isto acrescentando, aps o comando new, o
nome do mtodo construtor. Como vimos, o mtodo construtor tem o mesmo nome da classe e
executado sempre que um novo objeto criado.
Portanto, a segunda parte da primeira linha do nosso mtodo principal (= new Cachorro();) uma
instruo de atribuio de um novo objeto da classe Cachorro. Ou seja, o computador ir criar uma
instncia da classe Cachorro e a seguir atribuir este novo objeto varivel caozinho.
Na linha seguinte, temos uma chamada do mtodo latir() direcionada ao objeto caozinho:
caozinho.latir();
Ao encontrar esta instruo o computador interrompe a execuo do mtodo principal do programa
principal e vai no programa Cachorro (classe Cachorro) procurar pelo mtodo latir() para poder
executar as instrues definidas neste mtodo. O mtodo latir() da classe Cachorro tem apenas uma
instruo, a instruo de impresso:
System.out.println(Au! Au!);
O comando System.out.println() mostra no console o que estiver especificado entre os parnteses.
No nosso caso, o computador ir abrir uma janelinha de console para poder imprimir Au! Au!.
Como vimos, o processo de atribuir uma valor inicial a uma nova varivel chamado de
inicializao. Quando esta nova varivel tem como tipo-de-dado uma classe (como no nosso
exemplo) este processo chamado de instanciao, para ficar bem caracterizado que estamos
atribuindo uma instncia (um objeto) nova varivel.

Sobrecarga de Mtodos
Dentro da minha classe eu posso dois ou mais mtodos com o mesmo nome desde que eles tenham
a assinatura diferente. Assinatura do mtodo corresponde ao nome-do-mtodo mais a lista de
parmetros. Veja por exemplo os cabealhos de mtodos abaixo:

public void latir()

public void mudarTamanho(int novotamanho)
public double calcularMedia(double nota1, double nota2)

No primeiro exemplo, a assinatura do mtodo latir(). Aqui temos o nome do mtodo e mais a lista
de parmetros, no caso, uma lista vazia porque no h parmetros.
No segundo caso, a assinatura do mtodo mudarTamanho(int novotamanho). Temos o nome do
mtodo seguido da lista de parmetros (int novoTamanho).
No terceiro caso a assinatura do mtodo calcularMedia(double nota1, double nota2). Temos o
nome do mtodo e mais a lista de parmetros (double nota1, double nota2).
Eu posso ter na minha classe Cachorro um segundo mtodo chamado latir desde que as assinaturas
dos dois mtodos latir sejam diferentes. Abra a classe Cachorro do nosso projeto Canil, e acrescente
um novo mtodo latir como descrito na Figura 30:

Curso Bsico de JAVA

49

public class Cachorro

{
public void latir()
{
System.out.println(Au! Au!);
}
public void latir(String latido)
{
System.out.println(latido);
}
}
Figura 30 Definio da Classe Cachorro com dois mtodos latir()
Esta nova verso da classe Cachorro com dois mtodos latir() perfeitamente vlida porque embora
os dois mtodos tenham o mesmo nome, a lista de parmetros diferente e portanto a assinatura
diferente. A assinatura do primeiro mtodo latir latir(), ou seja, o nome do mtodo mais a lista
vazia de parmetros. A assinatura do segundo mtodo latir latir(String latido), ou seja, o nome do
mtodo mais a lista de parmetros com o parmetro latido.
Como que o computador vai saber qual dos dois mtodos latir ele deve executar? Ele vai saber na
hora que invocarmos o mtodo. Se, ao chamar o mtodo latir, eu no passar nenhum parmetro
dentro dos parnteses, ele vai executar o mtodo latir sem parmetros. Se, ao chamar o mtodo latir,
eu passar uma String dentro dos parmetros, ele vai executar o mtodo latir com o parmetro String.
Ou seja, dependendo da forma que eu invocar o mtodo, ele vai saber se pra executar o primeiro
ou o segundo mtodo latir.
Vamos criar um programa para testar isto. Mas antes vamos fazer um pequeno ajuste no BlueJ.
Execute novamente o programa VidaDeCachorro que est no projeto Canil. Deve ter aparecido uma
janela igual a da Figura 31, n?

Figura 31 Resultado da segunda execuo do programa VidaDeCachorro

Isso aconteceu porque o BlueJ no limpou o resultado da execuo anterior. Se voc executar cinco
vezes o programa VidaDeCachorro ir aparecer na janela de console cinco vezes a String Au!
Au!. Isso no bom para os nossos testes, porque podemos nos confundir. Como vou saber o que
foi impresso agora e o que foi impresso nas execues anteriores? Para corrigir isso, execute o

Curso Bsico de JAVA

50

programa VidaDeCachorro mais uma vez. Quando aparecer a janela de console, clique em Options
l no alto da janela do console e depois clique em Clear screen at method call (Limpar tela a cada
chamada de mtodo). A partir de agora, cada vez que executarmos o programa, o BlueJ primeiro
apaga o resultado da execuo anterior. Para testar, execute novamente o VidaDeCachorro. Vai
aparecer a janela de console com apenas uma linha Au! Au! como na Figura 29.
Vamos ento prosseguir com os testes. V no projeto Canil e exclua o programa VidaDeCachorro
(basta clicar com o boto direito do mouse sobre a classe VidaDeCachorro e clicar em Remover no
menu que aparecer). Agora crie uma nova classe chamada CoralDeCachorros. Delete as linhas
criadas pelo BlueJ, deixando somente o cabealho da classe e as chaves. Digite o cdigo conforme a
Figura 32 abaixo:
public class CoralDeCachorros
{
public static void main(String[] args)
{
Cachorro rex = new Cachorro();
Cachorro toto = new Cachorro();
rex.latir();
toto.latir("Arf! AU! Arf! AU!");
rex.latir("AUUUUUUUUUUUU");
}
}
Figura 32 Testando a sobrecarga do mtodo latir()
Compile e execute o programa CoralDeCachorros. Se tudo correu bem, voc deve ter recebido
como resultado uma janela igual a da Figura 33.

Figura 33 Resultado da execuo do CoralDeCachorros

Vamos comentar as instrues do mtodo principal da classe CoralDeCachorros.
Na primeira linha temos a definio de uma varivel chamada rex (do tipo Cachorro) e a criao e
atribuio de um novo objeto da classe Cachorro a esta varivel.
Na segunda linha temos a definio de uma varivel chamada toto (do tipo Cachorro) e a criao e
atribuio de um novo objeto da classe Cachorro a esta varivel.
Na terceira linha temos a invocao do mtodo latir direcionado varivel rex. Como foi invocado
o mtodo sem passar nenhum parmetro, ser executado o primeiro mtodo latir, aquele que no

Curso Bsico de JAVA

51

tem parmetros na sua assinatura. Este mtodo latir sem parmetros tem apenas uma instruo:
System.out.println(Au! Au!), que vai imprimir na tela a string Au! Au!.
Na quarta linha temos uma chamada do mtodo latir direcionada varivel toto. Como foi invocado
o mtodo passando um parmetro (a String Arf! AU! Arf! AU!"), ser executado o segundo
mtodo latir, aquele que recebe uma String como parmetro.
Na quinta linha temos uma chamada do mtodo latir direcionada varivel rex. Como foi invocado
o mtodo passando um parmetro (a String AUUUUUUUUUUUU"), ser executado o segundo
mtodo latir, aquele que recebe uma String como parmetro.
Operadores Aritmticos, Relacionais e Lgicos
Operadores so smbolos usados para indicar uma determinada operao. Os operadores aritmticos
so bastante conhecidos pois j estamos habituados a utiliz-los nas expresses matemticas. Por
exemplo, em nota1 + nota2, o sinal de + um operador aritmtico usado para indicar uma operao
de adio. Os operadores usados no Java se dividem em aritmticos, relacionais e lgicos.
Operadores Aritmticos so usados para indicar operaes aritmticas tais como adio, subtrao,
multiplicao e diviso.
Operadores Relacionais so usados para indicar relaes entre valores, tais como maior que,
igual a, menor ou igual a e etc.
Operadores Lgicos so usados em instrues de deciso (SE-ENTO-SENO) ou instrues de
repetio (loop). Sempre que eu fizer um teste mais complexo, aonde eu testo mais de uma
condio, eu uso os operadores relacionais para combinar as vrias condies simples a fim de
formar uma condio complexa. Para isso vou usar os operadores relacionais para expressar a idia
de E, OU e NO.
As tabelas a seguir mostram os operadores mais usados no Java.
Operador
+
*
/
%

Descrio
soma dois nmeros
subtrai dos nmeros
multiplica dois nmeros
divide dois nmeros
Mostra o resto da diviso

Exemplo
3+5
qtde - 7
velocidade * tempo
3.75 / 1.92
7%2

O ltimo operador mostrado na tabela ( %) no tem o mesmo sentido de percentual que estamos
habituados a usar. No Java ele serve para indicar o resto inteiro de uma diviso. No exemplo
mostrado estamos dividindo 7 por 2. O resto da diviso neste caso 1.
O programa a seguir testa os operadores aritmticos.
public class TestaOperadoresAritmticos {
public static void main (String[] args){
int resultado = 1 + 2; // resultado igual a 3
System.out.println(resultado);
resultado = resultado - 1; // resultado agora igual a 2

Curso Bsico de JAVA

52

System.out.println(resultado);
resultado = resultado * 2; // resultado agora igual a 4
System.out.println(resultado);
resultado = resultado / 2; // resultado agora igual a 2
System.out.println(resultado);
resultado = resultado + 8; // resultado agora igual a 10
resultado = resultado % 7; // resultado agora igual a 3
System.out.println(resultado);
}

Crie um novo projeto no BlueJ e crie dentro deste projeto uma classe chamada
TestaOperadoresAritmticos para digitar, compilar e executar o programa acima.
O resultado da execuo ser o mostrado na Figura 34.

Figura 34 Resultado da execuo do TestaOperadoresAritmticos

Operador
==
!=
>
<
>=
<=

Descrio
igual a
diferente de
maior que
menor que
maior ou igual a
menor ou igual a

Exemplo
if (idade == 3)
while (Visivel != false)
if (qtdeAlunos > 50)
do {comandos} until (qtde > 30)
while (total >= 100)
if (nota <= 7.5)

Os operadores relacionais so usados em testes de comparao. So usados nas instrues de

deciso (if-then-else (se-ento-seno)) e nas instrues de repetio (while (enquanto), do-until
(faa-at) e etc). Veremos a sintaxe dessas instrues mais adiante.
Observe que o smbolo para testar a igualdade entre dois valores == e no =, como estamos
acostumados a usar em matemtica. O smbolo de diferente !=, em vez do que estamos
habituados a usar. O programa ComparaValores abaixo testa os operadores relacionais:
public class ComparaValores {
public static void main(String[] args){
int valor1 = 50;
int valor2 = 100;
if (valor1 == valor2) System.out.println("50
if (valor1 != valor2) System.out.println("50
if (valor1 > valor2) System.out.println("50
if (valor1 < valor2) System.out.println("50
if (valor1 >= valor2) System.out.println("50

igual a 100");
diferente de 100");
maior que 100");
menor que 100");
maior ou igual a 100");

Curso Bsico de JAVA

53

if (valor1 <= valor2) System.out.println("50 menor ou igual a 100");

Crie um novo projeto no BlueJ, crie uma classe chamada ComparaValores, digite, compile e
execute o cdigo acima. Voc deve receber como resultado uma janela igual a da Figura 35:

Figura 35 Resultado da execuo do ComparaValores

Vamos analisar o programa ComparaValores. Na primeira linha do mtodo principal declarada
uma varivel do tipo nmero inteiro (int) chamada valor1 e na mesma linha feita a inicializao
dessa varivel, atribuindo a ela o valor literal 50. Na segunda linha declarada outra varivel do
tipo nmero inteiro (int) chamada valor2 e na mesma linha feita a inicializao dessa varivel,
atribuindo a ela o valor literal 100.
A partir da usamos uma instruo de deciso, comum a todas as Linguagens de Programao. a
instruo SE-ENTO. Veremos mais adiante a sintaxe dessa instruo mas para podermos entender
o ComparaValores vamos explicar rapidamente a idia. A instruo SE-ENTO testa uma condio
e se ela for verdadeira ele executa o comando que est no ENTO (veja as Figuras 17 e 18 na
pgina 23). Em ingls SE vira IF e ENTO vira THEN. A maioria das linguagens faz esses testes
escrevendo if <condio> then <comando>. Porm o Java omite o THEN, ento em Java
escrevemos if <condio> <comando>. o que aparece nas linhas 3 at 8 do mtodo principal do
ComparaValores.
Na terceira linha feito o teste if (valor1 == valor2). Essa instruo testa se valor1 igual a valor2.
O computador ir substituir o nome da varivel pelo seu contedo para poder fazer o teste. Assim, a
instruo se transforma em if (50 == 100). Somente se o resultado do teste for verdadeiro (true)
que o computador executa o comando seguinte: a instruo de impresso System.out.println(50
igual a 100); Como (50 == 100) falso, ento o computador no executa o comando de
impresso.
Na quarta linha feito o teste if (valor1 != valor2). Essa instruo testa se valor1 diferente de
valor2. O computador ir substituir o nome da varivel pelo seu contedo para poder fazer o teste.
Assim, a instruo se transforma em if (50 != 100). Somente se o resultado do teste for verdadeiro
(true) que o computador executa o comando seguinte: a instruo de impresso
System.out.println(50 diferente de 100); Como (50 != 100) verdadeiro, ento o computador
executa o comando de impresso e imprime na janela de console a String 50 diferente de 100.
Na quinta linha feito o teste if (valor1 > valor2). Essa instruo testa se valor1 maior que
valor2. O computador ir substituir o nome da varivel pelo seu contedo para poder fazer o teste.
Assim, a instruo se transforma em if (50 > 100). Somente se o resultado do teste for verdadeiro
(true) que o computador executa o comando seguinte: a instruo de impresso

Curso Bsico de JAVA

54

System.out.println(50 maior que 100); Como (50 > 100) falso, ento o computador no
executa o comando de impresso.
Na sexta linha feito o teste if (valor1 < valor2). Essa instruo testa se valor1 menor que valor2.
O computador ir substituir o nome da varivel pelo seu contedo para poder fazer o teste. Assim, a
instruo se transforma em if (50 < 100). Somente se o resultado do teste for verdadeiro (true) que
o computador executa o comando seguinte: a instruo de impresso System.out.println(50
menor que 100); Como (50 < 100) verdadeiro, ento o computador executa o comando de
impresso e imprime na tela a String 50 menor que 100.
Na stima linha feito o teste if (valor1 >= valor2). Essa instruo testa se valor1 maior que ou
igual a valor2. O computador ir substituir o nome da varivel pelo seu contedo para poder fazer o
teste. Assim, a instruo se transforma em if (50 >= 100). Somente se o resultado do teste for
verdadeiro (true) que o computador executa o comando seguinte: a instruo de impresso
System.out.println(50 maior ou igual a 100); Como (50 >= 100) falso, ento o computador
no executa o comando de impresso.
Finalmente, na oitava linha feito o teste if (valor1 <= valor2). Essa instruo testa se valor1
menor que ou igual a valor2. O computador ir substituir o nome da varivel pelo seu contedo para
poder fazer o teste. Assim, a instruo se transforma em if (50 <= 100). Somente se o resultado do
teste for verdadeiro (true) que o computador executa o comando seguinte: a instruo de
impresso System.out.println(50 menor ou igual a 100); Como (50 <= 100) verdadeiro,
ento o computador executa o comando de impresso e imprime na tela a String 50 menor ou
igual a 100.

Operador
&&
||
!

Descrio
E
OU
NO

Exemplo
if ((x<3) && (y>7))
if ((nota1 < 5) || (nota2 < 5)
if (! estourouLimite)

Os operadores lgicos so usados para testar vrias condies (no caso do && e do ||) ou para
inverter um teste (no caso do !).
No primeiro exemplo, a condio ser verdadeira somente se x for menor que 3 e y for maior que 7.
Ou seja, as duas condies testadas tem que ser verdadeiras para que o resultado da expresso seja
considerado verdadeiro.
No segundo exemplo, a condio ser verdadeira se nota1 for menor que 5 ou se nota2 for menor
que 5. Basta que uma das duas condies seja verdadeira para que o resultado da expresso seja
considerado verdadeiro.
No terceiro exemplo estamos usando uma varivel booleana. As variveis booleanas s podem
armazenar um dos valores booleanos: true (verdadeiro) ou false (falso). O sinal de ! inverte o
contedo da varivel. Assim, supondo que a varivel estourouLimite armazene o valor true, o teste
do exemplo vai dar falso, porque ! true equivale a false. O programa TesteLgico testa os
operadores lgicos, tambm conhecidos como operadores booleanos porque trabalham com valores
verdadeiro ou falso.

Curso Bsico de JAVA

55

public class TesteLgico {

public static void main(String[] args){
int valor1 = 30;
int valor2 = 115;
if((valor1 == 30) && (valor2 > valor1))
System.out.println("30 igual a 30 E 115 maior que 30");
if((valor1 == 250) && (valor2 > valor1))
System.out.println("30 igual a 250 E 115 maior que 30");
if((valor1 == 250) || (valor2 > valor1))
System.out.println("30 igual a 250 OU 115 maior que 30");
if((valor1 == 250) || (valor2 == 7))
System.out.println("30 igual a 250 OU 115 igual a 7");
}
}

Crie um novo projeto no BlueJ, crie uma classe chamada TesteLgico, digite, compile e execute o
cdigo acima. Voc deve receber como resultado uma janela igual a da Figura 36:

Figura 36 Resultado da execuo do TesteLgico

Vamos analisar o programa TesteLgico. Na primeira linha do mtodo principal declarada uma
varivel do tipo nmero inteiro (int) chamada valor1 e na mesma linha feita a inicializao dessa
varivel, atribuindo a ela o valor literal 30. Na segunda linha declarada outra varivel do tipo
nmero inteiro (int) chamada valor2 e na mesma linha feita a inicializao dessa varivel,
atribuindo a ela o valor literal 115.
Na terceira linha feito o teste if (valor1 == 30) && (valor2 > valor1)). Essa instruo testa duas
condies e somente vai executar a instruo de impresso se as duas condies forem verdadeiras.
O computador ir substituir o nome da varivel pelo seu contedo para poder fazer o teste. Assim, a
instruo se transforma em if (30 == 30) && (115 > 30). Como (30 == 30) verdadeiro e (115 >
30) tambm verdadeiro, ento o computador executa o comando de impresso e imprime na tela a
String 30 igual a 30 E 115 maior que 30".
A seguir feito o teste if (valor1 == 250) && (valor2 > valor1)). Essa instruo testa duas
condies e somente vai executar a instruo de impresso se as duas condies forem verdadeiras.
O computador ir substituir o nome da varivel pelo seu contedo para poder fazer o teste. Assim, a
instruo se transforma em if (30 == 250) && (115 > 30). Aqui temos que (115 > 30) verdadeiro
porm (30==250) falso. Como o operador lgico && s resulta em verdadeiro se as duas
condies forem verdadeiras, ento o resultado do teste falso e o computador no executa o
comando de impresso.

Curso Bsico de JAVA

56

O prximo teste if (valor1 == 250) || (valor2 > valor1)). Essa instruo testa duas condies e
vai executar a instruo de impresso se uma das duas condies (ou as duas) forem verdadeiras.
Ao contrrio do && que s resulta verdadeiro se a primeira condio for verdadeira E a segunda
tambm, o || vai resultar verdadeiro se a primeira condio for verdadeira OU a segunda condio
for verdadeira. Basta que uma seja verdadeira para o resultado do teste dar verdadeiro. O
computador ir substituir o nome da varivel pelo seu contedo para poder fazer o teste. Assim, a
instruo se transforma em if (30 == 250) || (115 > 30). A primeira condio (30 == 250) falsa,
porm a segunda (115 > 30) verdadeira. O resultado do teste verdadeiro e o computador executa
o comando de impresso e imprime na tela a String "30 igual a 250 OU 115 maior que 30".
Finalmente, o ltimo teste if (valor1 == 250) || (valor2 == 7)). Essa instruo testa duas
condies e vai executar a instruo de impresso se uma das duas condies (ou as duas) forem
verdadeiras. O computador ir substituir o nome da varivel pelo seu contedo para poder fazer o
teste. Assim, a instruo se transforma em if (30 == 250) || (115 == 7). A primeira condio
(30 == 250) falsa e a segunda (115 == 7) tambm falsa. O resultado do teste falso e o
computador no executa o comando de impresso.

Operadores Aritmticos combinados com Atribuio

Quando eu quero somar um valor a uma varivel, geralmente usamos uma instruo de atribuio
somando o valor que queremos varivel e atribuindo o resultado da soma varivel. Exemplo:
qtdeAlunos = qtdeAlunos + 5
Mas existe uma maneira abreviada de fazer a mesma coisa no Java:
qtdeAlunos += 5
Esta instruo faz a mesma coisa que a instruo anterior, ou seja, soma 5 ao contedo da varivel
qtdeAlunos.
Posso fazer isso com todos os outros operadores aritmticos. Exemplos:
valor *= 10 o mesmo que escrever
valor = valor * 10
num -= 7
o mesmo que escrever
num = num 7
qtde /= 2
o mesmo que escrever
qtde = qtde / 2

Concatenao de Strings
O sinal de + no usado apenas para somar valores numricos. Ele tambm pode ser usado para
concatenar (juntar) Strings.
Imagine que eu tenho as seguintes instrues em um programa:
String nome = Joo;
String sobrenome = da Silva;
String nomeCompleto = nome + sobrenome

Curso Bsico de JAVA

57

System.out.println(nomeCompleto);
O resultado do comando de impresso seria Joo da Silva.

Incremento e Decremento
Outra forma de aumentar o valor de uma varivel o operador de incremento. Incrementar uma
varivel significa somar 1 ao valor dessa varivel. O Java usa o operador ++ para fazer isso.
Veja no exemplo:
int num = 17;
num++; // num agora vale 18
Aps a execuo da segunda linha, o valor de num passa a ser 18. Isto equivaleria a escrever
num = num + 1 ou ento num += 1.
A mesma coisa vale para o sinal -- . Neste caso estamos diminuindo o valor da varivel. Isto
chamado de decremento.
int num = 17;
num--; // num agora vale 16
O uso do incremento ou decremento depende da posio onde eles se encontram na expresso.
Existem casos em que eu quero que a expresso seja calculada primeiro e o valor seja incrementado
depois. Nesse caso eu uso o ++ depois da varivel. Em outros casos, o valor deve ser incremetado
primeiro e s depois que eu vou calcular a expresso. Nestes casos eu vou colocar o sinal de ++
antes da varivel. Acompanhe o exemplo:
int x = 7;
int y = 7;
int a = 2 * ++x; // a vale 16 e x vale 8
int b = 2 * y++; // b vale 14 e y vale 8
Veja que nos dois casos as variveis foram incrementadas, passando de 7 para 8. Mas no primeiro
caso, o valor de x foi incrementado primeiro, passando de 7 para 8 e s depois foi calculada a
expresso (2 * 8) resultando em 16. No segundo caso, o incremento vem depois de calculada a
expresso. Ou seja, primeiro efetuado o clculo da expresso (2 * 7) que resulta em 14 e s depois
a varivel y incrementada passando de 7 para 8.
Instrues e Blocos de Instrues
Um programa uma sequncia de instrues, ou seja, cada linha do meu programa contm uma
instruo. As instrues podem ser divididas em:

instruo de declarao
instruo de atribuio
instruo de incremento ou decremento (++ ou --)
invocao de mtodos

Curso Bsico de JAVA

58

criao de objetos

Veja alguns exemplos:

Circulo sol;
// instruo de declarao
double nota1;
// instruo de declarao
nota1 = 7.5;
// instruo de atribuio;
media = (nota1 + nota2) / 2 // instruo de atribuio
qtdeAlunos++; // instruo de incremento (equivale a qtdeAlunos = qtdeAlunos + 1)
altura--;
// instruo de decremento (equivale a altura = altura 1)
rex.latir();
// chamada de mtodo
sol.mudarTamanho(80); // chamada de mtodo
new Circulo();
// criao de objeto

Observe que todas as instrues terminam com ponto-e-vrgula. Ns podemos em uma mesma linha
combinar duas instrues:

double nota1 = 7.5;

Circulo sol = new Circulo();

// instruo de declarao e atribuio

// instruo de declarao, criao de objeto e atribuio

Blocos de instrues so uma ou mais instrues entre chaves. Elas podem ser usadas em qualquer
lugar em que uma instruo simples pode ser usada. Geralmente, usamos os blocos de instrues
quando, por exemplo, temos uma instruo de deciso (if) e temos mais de uma instruo a ser
realizada no then ou no else. Veja um exemplo no cdigo abaixo:
public class CalculaMdia {

public static void main(String[] args){

int qtdeAprovados = 0;
int qtdeReprovados = 0;
double nota1 = 7;
double nota2 = 10;
double media = (nota1 + nota2) / 2;
if (media >= 7)
{
System.out.println(Aprovado);
System.out.println(Boas Frias !);
qtdeAprovados++;
}
else
{
System.out.println(Reprovado);
System.out.println(Nos vemos na recuperao ...);
qtdeReprovados++;
}
}

Curso Bsico de JAVA

59

Instrues de Deciso

As instrues de deciso servem para executar um comando (ou bloco de comandos) dependendo
do resultado do teste de uma condio. A sintaxe a seguinte:

Sintaxe da Instruo de Deciso

if(<expresso>)
<comando (ou bloco de comandos)>
if (<expresso>)
<comando (ou bloco de comandos)>
else
<comando (ou bloco de comandos)>

expresso qualquer condio (ou grupo de condies) que resulte em um valor booleano
(verdadeiro ou falso). Pode ser simples (ex: x < 3, x == y , idade != 18 , etc) ou composta
(ex: ((x < 3) && (y == 15)) , ((nota1 < 5) || (nota2 < 5)) , etc). Tambm pode ser uma
varivel booleana. Neste caso a varivel ser substituda pelo seu contedo e ir executar o
comando (ou comandos) do then se o contedo da varivel for true (verdadeiro) e o
comando (ou comandos) do else se o contedo da varivel for false (falso)
(ex: if Visivel ...) .
comando (ou bloco de comandos) a instruo (ou instrues) a ser executada caso o
resultado da expresso seja true (verdadeiro). Se for uma instruo s no h necessidade de
usar chaves, porm no devemos esquecer que toda instruo termina com ponto-e-vrgula.
Exemplo: if media >= 7 System.out.println(Aprovado);
Caso haja mais de uma instruo a ser executada, preciso coloc-las entre chaves,
formando um bloco de comandos.
Exemplo: if media >= 7
{
System.out.println(Aprovado);
System.out.println(:Boas Frias !);
qtdeAprovados++;
}

A maioria das linguagens de programao usa as instrues de deciso escrevendo

if <expresso> then <comandos>. Porm o Java omite o THEN, ento em Java escrevemos
if <expresso> <comandos>, ou if <expresso> <comandos> else <comandos>, se estiver
usando a forma mais completa.
Uma observao importante: repare que a expresso vem sempre entre parnteses. No se escreve
if num > 3 , mas sim if (num > 3).

Curso Bsico de JAVA

60

Instrues de Repetio (loop)

As instrues de repetio so usadas para repetir a execuo de um comando (ou bloco de
comandos). Vamos ver duas dessas instrues, a instruo while e a instruo for.

Sintaxe da Instruo while

while (<expresso>)
{
<comando (ou bloco de comandos)>
}

Ao encontrar uma instruo while (while quer dizer enquanto, em portugus), o computador
resolve a expresso. Se o resultado for true (verdadeiro) ento ele executa as instrues que esto
dentro das chaves. Quando terminar de executar as instrues, ele volta a resolver a expresso. Se
ela for igual a true, ele torna a entrar no corpo do while e executar as instrues . E permanece
assim, resolvendo a expresso e executando as instrues at que o resultado seja falso. Quando, ao
resolver a expresso, o resultado for false, ento o computador no entra no corpo do bloco e segue
executando as linhas do meu programa. Veja um exemplo:
public class TestaWhile {
public static void main(String[] args){
int contador = 0;
while (contador < 10) {
System.out.println("Contador : " + contador);
contador++;
}
}
}

Crie um projeto no BlueJ e digite o cdigo acima em uma nova classe TestaWhile. Compile e
execute o programa e o resultado dever ser igual ao da Figura 37.

Figura 37 Resultado da execuo do TestaWhile

Curso Bsico de JAVA

61

Na primeira linha do mtodo principal declarada uma varivel inteira chamada contador que
inicializada com o valor zero. A seguir testamos a condio do while pela primeira vez. O
computador substitui a varivel pelo seu contedo e a expresso vira (0 < 10) o que verdadeiro e
portanto o computador executa as instrues que esto dentro do while. A primeira instruo dentro
do corpo do while uma instruo de impresso e o computador imprime na tela Contador : 0. A
segunda instruo incrementa o contador, ou seja, soma 1 ao seu valor e portanto contador passa a
guardar o valor 1.
Voltamos a testar a condio do while e agora a expresso (1 < 10) o que tambm verdadeiro, o
que significa que o computador vai imprimir Contador : 1 e vai incrementar o valor de contador
(que passar a ser igual a 2) e volta a testar a condio do while e assim por diante.
Quando o valor da varivel contador for igual a 9 o teste do while ser (9 < 10) o que verdade e o
computador entra novamente no corpo do while, imprime Contador : 9 e incrementa o valor do
contador, que passa a ser 10.
Dessa vez, quando for feito o teste do while (10 < 10) o resultado ser falso, o que vai interromper a
execuo do while e como no h mais nenhuma instruo para ser executada aps o while, o
programa termina.
Vamos ver outro exemplo. V no BlueJ e abra o projeto Canil. Abra a classe Cachorro e acrescente
um novo mtodo latir conforme o cdigo abaixo.
public void latir(int numVezes)
{
while (numVezes > 0)
{
System.out.println(AUAUAU);
numVezes--;
}
}

Agora a classe cachorro tem trs mtodos latir, mas cada um tem uma assinatura diferente. A
assinatura do primeiro o nome do mtodo (latir) mais uma lista de parmetros vazia. A assinatura
do segundo latir e mais o parmetro latido que do tipo String. Este terceiro mtodo latir, que
acabamos de criar, tem como assinatura o nome latir e mais o parmetro numVezes que um
inteiro. Como as assinaturas so diferentes, o computador vai saber qual mtodo latir deve executar
dependendo do(s) parmetro(s) que eu passar quando invocar o mtodo. Compile a classe Cachorro
para se certificar de que no h erros.
Agora abra a classe CoralDeCachorros e altere o seu contedo para ficar igual ao cdigo abaixo:
public class CoralDeCachorros {
public static void main(String[] args){
Cachorro bidu = new Cachorro();
Cachorro duque = new Cachorro();
bidu.latir();
duque.latir(auau);
bidu.latir(3);
}
}

Compile e execute o programa e o resultado deve ser igual ao da Figura 38.

Curso Bsico de JAVA

62

Figura 37 Resultado da execuo do TestaWhile

A primeira chamada de mtodo (bidu.latir()) direcionada ao bidu. Como no foi passado nenhum
parmetro, o computador executa o primeiro mtodo latir da classe Cachorro, aquele que no recebe
nenhum parmetro e que imprime Au! Au! na tela de console.
A segunda chamada de mtodo (duque.latir(auau)) direcionada ao duque. Como est passando
um parmetro, o computador no vai executar o primeiro mtodo latir, pois ele um mtodo sem
parmetros. No entanto temos, dentro da classe Cachorro, dois mtodos latir que recebem um
parmetro. Como o computador vai saber qual dos dois deve executar? Isso vai depender de qual
tipo de parmetro a gente passar na hora de chamar o mtodo. Repare que em duque.latir(auau)
est sendo passado ao mtodo latir um parmetro do tipo String (auau). Portanto, o computador
vai executar o segundo mtodo latir da classe Cachorro que o que recebe uma String como
parmetro.
Por fim temos outra chamada de mtodo direcionada ao bidu (bidu.latir(3)). Novamente temos uma
chamada ao mtodo latir passando um parmetro. S que desta vez no estamos passando uma
String mas sim um nmero inteiro (3). Portanto, j que estamos passando como parmetro um
nmero inteiro, o computador ir executar o terceiro mtodo latir da classe Cachorro, que foi
definido contendo um parmetro do tipo inteiro na assinatura do mtodo.
Este terceiro mtodo latir comea testando se numVezes maior que zero. A varivel numVezes
recebeu o valor que ns passamos na chamada do mtodo (3). Portanto, o teste se transforma em (3
> 0), o que verdadeiro e portanto o computador executa o bloco de instrues dentro do while. A
primeira instruo imprimir AUAUAU e a segunda decrementar a varivel numVezes, que
passa a ser igual a 2.
O computador volta a testar o while e dessa vez a expresso (numVezes > 0) se transforma em (2 >
0), que verdadeiro e ele executa as instrues do while, imprimindo AUAUAU e
decrementando numVezes. Novamente, torna a testar a condio do while que dessa vez ser (1 > 0)
que novamente verdadeiro e novamente o computador vai imprimir AUAUAU e decrementar
numVezes que passar a ser 0.
Desta vez, ao testar o while, a expresso (numVezes > 0) se transforma em (0 > 0) que falso e
portanto o computador termina a execuo do while e volta ao programa CoralDeCachorros. Como
no h mais nenhuma instruo aps o bidu.latir(3) o programa CoralDeCachorros termina.

Curso Bsico de JAVA

63

Sintaxe da Instruo for

for (<inicializao ; <expresso> ; <incremento ou decremento>)
{
<comando (ou bloco de comandos)>
}

inicializao - aqui so criadas e inicializadas as variveis que sero usadas para controlar
o numero de iteraes (repeties). Esses comandos so executados apenas uma vez, no
incio da execuo do loop (chamamos de loop um conjunto de instrues que executado
repetidas vezes, como no caso das instrues for e while).
expresso aqui feito o teste para ver se as instrues do corpo do for sero executadas ou
no. Se o resultado do teste for verdadeiro ento ele executa as instrues, seno ele termina
a execuo da instruo for. Ou seja, as instrues sero executadas repetidamente, at que o
teste da expresso resulte em falso. Quando acontecer isto a instruo termina.
incremento ou decremento esses comandos so realizados ao final de cada iterao (ou
seja ao final de cada execuo do bloco de instrues do corpo do for). Normalmente temos
aqui instrues de incremento (somar 1) ou decremento (subtrair 1) das variveis criadas na
inicializao.

Ao encontrar uma instruo for, o computador primeiro executa o(s) comando(s) especificado na
inicializao.
A seguir ele testa a expresso para ver se vai executar as instrues de dentro do loop. Se o
resultado for verdadeiro ele executa as instrues (faz uma iterao). Ao trmino da execuo das
instrues ele executa os comandos que esto na seo incremento ou decremento. Aps executar as
instrues de incremento ou decremento, ele volta a testar a expresso para saber se vai terminar o
loop (caso o resultado da expresso seja igual a falso) ou se vai realizar nova iterao (caso o
resultado da expresso seja verdadeiro). Se o resultado da expresso der verdadeiro ele faz nova
iterao (executa as instrues do corpo do for), depois executa as instrues de
incremento/decremento e torna a testar a expresso e assim por diante at que o teste da expresso
resulte em falso, quando ento o computador ir terminar a execuo da instruo for. O programa
TestaFor traz um exemplo de uso da instruo for.
public class TestaFor {
public static void main(String[] args){
for(int i=1; i<4; i++){
System.out.println("Esta a + i + a iterao do loop);
}
}
}

Crie um novo projeto no BlueJ, crie uma classe chamada TestaFor, digite o cdigo acima,compile e
execute. O resultado deve ser igual ao mostrado na Figura 38.

Curso Bsico de JAVA

64

Figura 38 Resultado da execuo do TestaFor

Vamos analisar este programa. A primeira instruo do mtodo principal uma instruo de
repetio for. Ao encontrar uma instruo for, o computador incialmente executa a(s) instruo(es)
contida(s) na primeira seo do for, a seo de inicializao. Neste caso, s h uma instruo, aonde
declarada a varivel inteira i e inicializada com o valor 1.
A seguir o computador ir testar e executar repetidas vezes as instrues do loop at que o teste
resulte em falso. No nosso caso a expresso (i < 4). Da primeira vez que for testar a expresso, ela
se transformar em (1 < 4) que verdadeiro e portanto as instrues de dentro do loop sero
executadas. No corpo do loop s h uma instruo de impresso. Veja que feita uma concatenao
de trs valores para poder gerar a String que ser impressa na tela. Primeiro vem a String Esta a
. Esta String concatenada (ligada, unida) ao contedo da varivel i (neste caso, 1). O resultado
desta concatenao concatenado String a iterao do loop. O resultado impresso ser a String
Esta a 1a iterao do loop.
Aps terminar a execuo da instruo de impresso o computador ir executar a(s) intruo(es)
de incremento/decremento. Neste caso s h uma instruo: i++ que ir incrementar o valor da
varivel i. Como i estava com o valor 1, ela agora passa a valer 2.
O computador volta a testar a expresso (i < 4), que agora vai resultar em (2 < 4) que verdadeiro e
ele volta a realizar uma iterao do loop (executar as instrues do corpo do for). Agora a instruo
de impresso se transforma em Esta a 2a iterao do loop. Depois a varivel i ser incrementada
mais uma vez passando a armazenar o valor 3.
O computador volta a testar a expresso (i < 4), que agora vai resultar em (3 < 4) que verdadeiro e
ele volta a realizar uma iterao do loop. Agora a instruo de impresso se transforma em Esta a
3a iterao do loop. Depois a varivel i ser incrementada mais uma vez passando a armazenar o
valor 4.
O computador volta a testar a expresso (i < 4). S que agora a expresso vai resultar em (4 < 4)
que falso e o computador interrompe a execuo do for.

Importando classes das bibliotecas do Java

Um dos pontos fortes de uma Linguagem de Programao Orientada a Objetos a possibilidade de
aproveitar o trabalho que foi desenvolvido por outros. Quando fazemos o download da JRE ou JDK
e instalamos em nosso computador, estamos instalando tambm as bibliotecas de classes do Java
que contam com cerca de 3.500 classes agrupadas em pastas e sub-pastas por categorias. Para
podermos utilizar em um programa uma dessas classes do Java, precisamos informar ao computador

Curso Bsico de JAVA

65

em que pasta se encontra a classe que pretendemos utilizar. Fazemos isso usando a instruo de
importao import.
O programa IdadeEmDias mostra um exemplo de utilizao de uma classe importada da biblioteca
do Java:
import javax.swing.JOptionPane;
public class IdadeEmDias
{
public static void main(String[] args)
{
String stringIdade;
int idadeAnos,idadeDias;
stringIdade = JOptionPane.showInputDialog("Digite sua idade");
idadeAnos = Integer.parseInt(stringIdade);
idadeDias = idadeAnos * 365;
}

JOptionPane.showMessageDialog(null,"Sua idade em dias : " + idadeDias);

Crie um novo projeto no BlueJ, crie uma nova classe chamada IdadeEmDias, digite, compile e
execute o programa. Ao executar o programa mostra uma janela para que o usurio digite a sua
idade. Veja na Figura 39:

Figura 39 Janela de Input (o usurio deve digitar sua idade e clicar em OK)
A seguir o programa calcula a idade em dias e mostra outra janela contendo o resultado. Por
exemplo, se o usurio digitar 42, o resultado ser:

Figura 40 Janela de Output com o resultado

Vamos analisar o programa IdadeEmDias. Este programa utiliza a classe JOptionPane que uma
classe grfica que est na biblioteca do Java na pasta javax e sub-pasta swing. A primeira instruo
do programa (antes mesmo do cabealho da classe) a instruo de importao que indica ao
computador onde encontrar esta classe: import javax.swing.JOptionPane.
Dentro do mtodo principal so declaradas trs variveis: uma String (stringIdade) e duas int
(idadeAnos e idadeDias).
A seguir feita a invocao do mtodo showInputDialog da classe JOptionPane. Ns aprendemos
que normalmente as classes no executam mtodos, s os objetos (instncias das classes) fazem
isto. Portanto, deveramos primeiro criar um objeto da classe JOptionPane para poder chamar o

Curso Bsico de JAVA

66

mtodo. Porm esta classe tem mtodos especiais que no precisam ser direcionados a nenhum
objeto, podem ser chamados somente mencionando o nome da classe. o que o programa faz, ao
invs de escrever nome-de-objeto.nome-do-mtodo, como estamos acostumados a fazer, ele escreve
nome-da-classe.nome-do-mtodo.Este mtodo abre uma janela de input (entrada) de dados, aonde
pede ao usurio para digitar a sua idade. O resultado ser atribudo varivel stringIdade. Foi usada
uma varivel do tipo String para armazenar o resultado porque qualquer coisa que o usurio digite
considerado uma String, mesmo que ele digite um nmero inteiro, como o caso aqui.
A prxima instruo um comando para transformar esta String em um nmero inteiro e o
resultado desta transformao ser atribudo varivel idadeAnos. Por exemplo, se o usurio
digitou 42 na janela, o 42 ser atribudo inicialmente varivel stringIdade como sendo a String
42. Essa String precisa ser transformada em nmero para que possamos fazer o clculo. O
comando Integer.parseInt transforma o 42 em 42. Esse 42 (nmero inteiro) ser armazenado na
varivel idadeAnos.
A seguir feita a converso para dias multiplicando o contedo de idadeAnos por 365. O resultado
armazenado na varivel idadeDias.
Finalmente a ltima instruo mostra uma janela com o resultado da converso da idade em anos
para a idade em dias. Note que showMessageDialog tambm um mtodo especial da classe
JOptionPane que tambm pode ser chamado diretamente sem necessidade da criao de objetos.
A instruo de importao pode importar apenas uma classe (como fizemos no programa
IdadeEmDias) ou um grupo de classes. Para importar um grupo de classes usamos um asterisco (*)
para indicar que queremos ter acesso a todas as classes daquela pasta. Exemplo: import java.awt.*;
No entanto se dentro da pasta indicada h sub-pastas, o uso do asterisco no nos d acesso
automtico a elas, mas somente s classes definidas dentro da pasta.
O ideal sempre colocar as instrues de importao individualmente, uma para cada pasta, mesmo
que haja vrias classes pertencentes mesma pasta. Isto ajudar a documentar o programa e a
mostrar de onde vieram as classes que estamos usando.
Para pesquisar as pastas e sub-pastas da biblioteca do Java basta ir em:
se for Windows
V em C:\Arquivos de Programas\java\jdk1.6.0_07\src.zip
O numero aps o jdk pode variar dependendo da verso que estiver instalada
se for Linux
V em /usr/java/jdk1.5.0_02/src.zip
O numero aps o jdk pode variar dependendo da verso que estiver instalada

Algumas pastas mais usadas so:

java.awt contm as classes necessrias criao de interfaces grficas
java.io classes para entrada e sada de dados
java.lang classes fundamentais. Estas classes so to utilizadas que no necessrios usar
a instruo de importao no incio do programa para usar classes dessa pasta.
java.math contm classes para realizar clculos aritmticos
java.util contm classes que so utilitrios como data e hora, gerador de nmeros
aleatrios, etc.
javax.sql classes para acesso a banco de dados.
Javax.swing classe de componentes grficos

Curso Bsico de JAVA

67

Porm muito difcil abrir entender o funcionamento das classes abrindo os fontes diretamente.
Existe na pgina de downloads do Java uma pasta com a documentao das classes em HTML. Essa
documentao lista todas as informaes sobre os campos, construtores e mtodos de cada classe.
Essa pasta tem o nome de jdk-6-doc e j est no CD do Curso Bsico Java. S que est tudo em
ingls, infelizmente no existe uma verso em portugus.

Criando um arquivo jar

Os programas que estamos criando para exemplificar os conceitos do Java so bem simples e cabem
em apenas uma ou duas classes. Porm programas maiores que so divididos em vrios mdulos
(como o BatalhaNaval) exigem que o usurio copie todos os mdulos para poder executar o
programa. O BlueJ tem um recurso que junta todos os mdulos em um nico arquivo que cabe at
em um disquete. Este arquivo compactado no formato jar. Vamos exemplificar criando uma
arquivo jar para o projeto BatalhaNaval que est no CD.
Abra o BlueJ, v em Open Project (Abrir Projeto), navegue at o CD e abra o projeto BatalhaNaval.
Agora clique em Project e depois em Create Jar File (Criar Arquivo Jar). Vai abrir uma janela como
a da Figura 41.

Figura 41 Janela de Criao do Arquivo Jar

preciso especificar qual dos mdulos o programa principal (aquele que contm o mtodo
principal). No caso do BatalhaNaval, o programa principal o BattleshipApp. Clique na seta para
baixo ao lado do campo Main class e clique em BattleshipApp na lista suspensa (Figura 42).

Figura 42 Especificando a classe principal

Curso Bsico de JAVA

68

A seguir clique no boto Continue. Ir abrir uma janela para especificar o nome e local aonde voc
vai salvar o arquivo criado. Navegue at a pasta desejada, digite um nome para o arquivo e clique
em Create (Figura 43).

Figura 43 Escolhendo um nome para o arquivo jar

O arquivo criado vai ter o nome que voc escolheu e final .jar. Este arquivo pode ser gravado em
um disquete, CD ou pendrive e levado para qualquer computador de qualquer plataforma. Se o
computador tiver JVM instalada basta clicar duas vezes no arquivo que ele vai executar. Nas vrias
verses do Windows e na maioria das verses de Linux isto funciona. Infelizmente no Metasys, no
basta clicar duas vezes no arquivo jar.
Para executar no Metasys preciso abrir o konqueror (casinha), navegar at onde est armazenado o
arquivo, clicar no menu Janela, depois em Mostrar Emulador de Terminal e ir abrir uma janela
de konsole na parte de baixo do konqueror. A seguir digite java jar <nome-do-arquivo-jar> e
tecle ENTER e o arquivo ir executar. Ateno, substitua o <nome-do-arquivo-jar> do comando
acima pelo nome que voc escolheu quando criou o arquivo jar.

Concluso
Esta apostila apresentou os aspectos bsicos da Programao e da linguagem Java. O objetivo
principal foi orientar os primeiros passos numa matria bastante extensa. Quem quiser realmente
escrever programas mais complexos ter que aprender vrias outras coisas que foram deixadas de
lado nesta apostila. Porm os conceitos e as idias bsicas por trs de um programa so sempre os
mesmos independente de sua complexidade ou tamanho.
Quem quiser apenas executar os programas criados por outras pessoas, j aprendeu o que est por
trs dos seus programas e jogos favoritos. Quem se interessar pela matria e quiser desenvolver seus
prprios programas ter um longo caminho de aprendizado e descobertas pela frente. Programar
uma das atividades mais criativas, prazerosas e divertidas da informtica. Boa Sorte e divirtam-se!

Curso Bsico de JAVA

69

Bibliografia
Curso de Java Bsico Mengue, Fbio. Centro de Computao da Unicamp
Lgica de Programao Celta Informtica (www.celtainformatica.com.br)
Curso de Programao em Java Figueiredo, Luclia Camaro de. Cadernos de Informtica
Secretaria de Estado de Educao MG
Beginning Programming with Java for Dummies Burd, Barry. Wiley Publishing, Inc.
Java Short Course JGuru. (jGuru.com)
The Java Tutorial java.sun.com. (http://java.sun.com/docs/books/tutorial/java/TOC.html)
Objects First with Java a practical introduction using BlueJ Barnes, David e Kolling, Michael.
Pearson Education / Prentice Hall.
Wikipedia www.wikipedia.com.br

Curso Bsico de JAVA

70

APNDICE A Dinmica com BlueJ

Nesta seo vamos usar os recursos do BlueJ e dois dos projetos do CD para mostrar na prtica os
conceitos de classes e objetos que vimos na teoria. O BlueJ permite que ns criemos, a partir de
uma classe, instncias (objetos) para que possamos dar ordens (invocar mtodos) sem a necessidade
de digitar um programa, compila-lo e executa-lo. Vamos fazer isto com os projetos formas e
pintura do CD.
Coloque o CD no drive de CDs e copie as pastas formas-pintura para alguma pasta no seu
computador.
Abra o BlueJ. Clique em Project e depois em Open Project (Abrir Projeto). Na janela que abrir,
navegue at a pasta aonde voc copiou as pastas formas e pintura. Repare que estas duas pastas tem
um cone diferente das outras pastas. Isto porque o BlueJ sabe que dentro desta pasta tem cdigosfonte e respectivos bytecodes. D um duplo-clique em formas (ou ento clique uma vez e em
seguida clique em Open (Abrir)).
A parte de cima da janela do BlueJ mostra as classes (programas) que compem este projeto.
Podemos ver que este projeto tm quatro classes. As setas mostram que as classes Circulo,
Quadrado e Tringulo usam objetos da classe Tela.
A parte de baixo o mundo virtual e nele habitam os objetos criados a partir das classes. Sabemos
que a classe no faz nada, ela meramente uma descrio dos atributos e mtodos. Quem pode
fazer alguma coisa (executar as ordens) o objeto. Portanto precisamos ter algum objeto no nosso
mundo virtual para que possamos dar ordens para ele.
No Java criamos objetos atravs do comando new. No BlueJ, podemos testar os mtodos, como se
ns fossemos o programa principal. Clicar nos mtodos de um objeto para dar ordens a ele o
equivalente a escrever as instrues de chamada de mtodo no programa. Os objetos so criados a
partir de uma classe, por isso clicamos com o boto direito do mouse em cima de uma classe e
escolhemos a opo new para criar um objeto (instncia) desta classe. Clique com o boto direito
em cima da classe Circulo e clique em new Circulo(). Todo objeto precisa de um nome, ento o
BlueJ ir abrir uma janela para voc digitar o nome do objeto. Veja que ele sugere um nome (neste
caso circulo1). Voc pode aceitar a sugesto e clicar em OK, ou pode escolher outro nome e clicar
em OK. Vamos aceitar a sugesto. Clique em OK.
Na parte de baixo do BlueJ (o mundo virtual) aparecer um objeto chamado circulo1. Veja que a
inicial do objeto minscula em contraste com a inicial da classe que maiscula. Para podermos
dar ordens ao objeto precisaramos pesquisar seus mtodos. O BlueJ faz isto para ns. Ele l o
cdigo-fonte da classe e anota os cabealhos dos mtodos. Ao clicarmos no objeto com o boto
direito ele mostra a lista de mtodos para que possamos escolher.
Clique com o boto direito do mouse em cima do objeto circulo1. Aparecer uma lista com doze
mtodos que so as aes que o circulo1 sabe executar. Agora vamos dar as ordens para ver o que
acontece. A partir do resultado, poderemos tirar concluses e aprender o que cada mtodo faz.
Clique no mtodo tornarVisvel(). Viu o que aconteceu? Agora clique no mtodo tornarInvisvel().
Torne a clicar no tornarVisivel(). J deu pra perceber o que eles fazem?

Curso Bsico de JAVA

71

Clique agora no mtodo moverDireita(). Viu o que ele faz. Clique de novo em moverDireita().
Clique uma terceira vez. Podemos perceber que a cada vez ele move um pouco para a direita. Ser
que ele move uma distncia diferente a cada vez ou sempre a mesma distncia?
Experimente agora os mtodos moverEsquerda(), moverCima() e moverBaixo().
Vamos agora experimentar o mtodo moverHorizontal(int distancia). Repare que ele tem um
parmetro que um valor inteiro. Quando voc clicar em moverHorizontal ir abrir uma janela para
voc digitar o valor do parmetro que voc est passando para o mtodo. Experimente
moverHorizontal(70). E se agora voc ordenar ao circulo1 para moverHorizontal(50), ser que ele
vai mover mais 50 posies (pixels) para a direita ou ser que ele vai para a posio 50 no eixo x ?
Ou seja, ser que o parmetro que estamos passando para o mtodo absoluto ou relativo?
E se agora eu quiser que o circulo1 se mova 100 pixels para a esquerda? Lembre-se que o parmetro
distancia um valor inteiro e valores inteiros podem ser tanto positivos como negativos.
Tente o mtodo moverHorizontalDevagar, passando tanto valores positivos como negativos.
Experimente agora os mtodos moverVertical e moverVerticalDevagar. Lembre-se que o eixo y, na
tela do Java, invertido, ou seja, medida que nos afastamos da origem (aumentamos o valor de y)
o circulo1 vai para baixo e medida que nos aproximamos da origem (diminumos o valor de y) ele
vai para cima.
O mtodo mudarTamanho pede um parmetro inteiro. Experimente este mtodo algumas vezes,
passando valores altos e baixos como 100, 10, 50, 200, 30, etc. O que acontece se passarmos um
valor negativo como parmetro? Ser que este parmetro relativo como o moverHorizontal, que
somava o valor passado como parmetro ao valor da posioX? Ou ser que este mtodo
(mudarTamanho) pega o valor passado como parmetro para ser o novo tamanho do crculo1? Neste
caso o parmetro de mudarTamanho absoluto ou relativo? Preste ateno no nome do parmetro
(novoDimetro). Existe crculo de dimetro negativo?
Por fim o mtodo mudarCor recebe como parmetro uma String. Lembre-se, na hora de passar o
parmetro, que toda String tem que estar entre aspas. Leia o comentrio do mtodo (que aparece no
topo da janela quando invocamos o mtodo) para saber quais as cores vlidas. O que acontece se
passarmos como parmetro uma cor que no est na lista de cores vlidas?
Agora criem instncias de Quadrado e Tringulo e experimentem os seus mtodos. Vocs vo
perceber que eles se comportam de forma idntica ao circulo. A exceo o mtodo
mudarTamanho, direcionado ao triangulo, que pede dois parmetros ao invs de um. Faa vrias
chamadas deste mtodo para tentar descobrir o que o primeiro parmetro e o que o segundo. O
que acontece se voc passar um valor negativo no primeiro parmetro (altura)? E no segundo
(largura)?
Quando j tiver aprendido a movimentar os objetos, clique em Project e Close (Fechar) para fechar
este projeto e depois em Project, Open Project e depois em formas para iniciar um novo teste.
Desta vez voc ter que criar objetos para fazer o desenho abaixo:

Curso Bsico de JAVA

72

Figura 44 Lar doce lar

Quantos objetos sero necessrios para fazer este desenho? Quantos da classe Circulo? E quantos da
classe Quadrado? E da classe Triangulo? Crie os objetos necessrios e d as ordens necessrias para
mover, mudar cor e mudar tamanho at formar o desenho. claro que no vai ficar idntico mas
procure fazer o mais aproximado que conseguir.
Depois de concludo o desenho, clique com o boto direito em cima do objeto circulo1 e clique em
Inspect. Vai abrir a janela do Inspetor que mostra os atributos e seus contedos. D algumas ordens
ao circulo1 e veja os contedos dos atributos modificarem medida que voc manda mover,
mudarTamanho, mudarCor, tornarInvisivel, e etc.
As duas ferramentas do BlueJ ajudam a saber tudo que queremos a respeito de uma classe
desconhecida. Basta criar um objeto da classe e usar o boto direito do mouse sobre o objeto criado
para ver a lista de mtodos e o Inspetor para ver o contedo dos atributos.
Agora feche o projeto (Project e Close) e torne a abri-lo (Project, Open Project, formas e Open).
Voc vai tornar a fazer o desenho mas agora ele tem que sair exatamente igual Figura 44.
Desta vez voc no vai usar os nomes que o BlueJ sugerir mas vai escolher nomes mais adequados
a cada objeto, como sol para o circulo, telhado para o triangulo e paredes e janela para os
quadrados.
Tambm precisar saber de alguns dados adicionais. Ao terminar o desenho, as paredes devero ter
o tamanho de 100, a posioX dever ser 60 e a posioY dever ser 130. A janela dever ter
tamanho 30, posioX 80 e posioY 150. O telhado dever ter tamanho 50 (altura) e 140 (largura),
posioX 110 e posioY 85 e o sol dever ter tamanho 60, posioX 200 e posioY 50.
Use o Inspetor nos objetos para saber em que posioX e posioY eles comeam quando so
criados.
Anote em uma folha os passos que voc der para cada objeto. Considere como passos apenas a
criao e as ordens que voc der aos objetos. Por exemplo, new Circulo() sol, sol.tornarVisivel(),
sol.mudarTamanho(60), etc.

Curso Bsico de JAVA

73

Uma vez terminado o desenho, se voc anotou direito, dever ter feito as paredes em 4 passos, a
janela em 5 passos, o telhado em 5 passos e o sol em 6 passos.
Feche o projeto formas e abra o projeto pintura. Crie uma instncia da classe Pintura. Veja quantos
mtodos tem o pintura1. Invoque o mtodo desenhar(). O que aconteceu? Invoque os mtodos
deixarPretoEBranco() e depois o deixarColorido().
Agora abra o fonte da classe Pintura (Clique na classe Pintura com o boto direito e depois em
Open Editor (Abrir Editor)). Encontre o mtodo desenhar() e veja o seu contedo. So os mesmos
20 passos que voc deu para fazer o seu desenho. Ou seja, para fazer qualquer programa basta
conhecer as classes e saber quais so os atributos e mtodos. Ento s criar objetos da classe e dar
ordens a eles, seguindo as regras e sintaxes do Java.
Tente imaginar quais as ordens que precisam ser dadas (e pra quem elas tem que ser dadas) para
alcanar o resultado do mtodo deixarPretoEBranco. E para o mtodo deixarColorido? Confira no
fonte do Pintura o que ele fez para conseguir este efeito.
Agora altere o mtodo desenhar acrescentando novas instrues. D uma (ou mais) nova ordem
para o sol para que, ao clicar em desenhar(), o computador, alm de desenhar a casinha com o sol,
mostre um efeito de pr-do-sol, ou seja, o sol deslizando lentamente para baixo at desaparecer no
horizonte. Lembre-se que o sol (que um objeto da classe Circulo) s sabe realizar os 12 mtodos
da classe Circulo. Portanto a ordem que voc vai dar tem que ser uma das 12 que ele sabe realizar.
Depois de conseguir este efeito, desfaa a alterao que voc fez, de modo que o mtodo desenhar
fique de novo do jeito que era (desenhe uma casa e um sol parados).
Crie um novo mtodo chamado entardecer() que produz o efeito de pr-do-sol. Ou seja, voc vai
fazer a mesma coisa que antes, mas s que em vez de alterar o mtodo desenhar(), vai criar um
novo mtodo para isso. Agora, ao clicar com o boto direito em cima do objeto pintura1, devero
aparecer quatro mtodos e no apenas trs. O quarto mtodo dever ser justamente o entardecer().
Ao clicar em entardecer() a deveremos ver o sol se pondo. Lembre-se que para testar temos
primeiro que clicar em desenhar() para poder aparecer a casinha e o sol. S ento vamos clicar em
entardecer para ver o sol se por.
Se voc conseguiu fazer o mtodo entardecer() funcionar, crie agora um mtodo chamado
amanhecer(), que faz o contrrio do entardecer(), ou seja, mostra o sol subindo no cu. Lembre-se
que para testar o amanhecer() preciso primeiro desenhar() e depois entardecer().
Estas so apenas algumas idias de atividades a serem feitas com objetos dos projetos formas e
pintura, mas outras podero ser criadas, basta usar a imaginao.

Curso Bsico de JAVA

74

APNDICE B Exemplos de Programas Comentados

Os programas (tambm chamados de aplicaes ou aplicativos) escritos em Java podem ser
divididos em trs categorias: aplicaes console, aplicaes grficas e applets.
Aplicaes Console so aquelas que usam a janela de console para receber dados do usurio ou
imprimir dados na tela. Se o programa pede para o usurio digitar alguma coisa, o cursor fica
piscando na janela de console indicando que est aguardando o usurio entrar com alguma
informao. Quando o usurio termina de digitar e tecla ENTER, o programa continua a executar.
Se o programa tem alguma instruo de impresso (System.out.println) o texto a ser impresso
aparece na janela do console. As aplicaes console so mais simples de aprender e quem est
iniciando na programao comea fazendo essas aplicaes para poder praticar e entender as regras
e sintaxes do Java.
Aplicaes Grficas so aquelas que usam recursos das classes grficas. Essas classes ficam
armazenadas na biblioteca de classes do Java nas pastas java.awt e javax.swing. Para fazer
aplicaes grficas preciso conhecer muito mais do que aprendemos nesta apostila bsica.
Normalmente s comeamos a aprender aplicaes grficas depois de ter dominado as aplicaes
console. Nestes programas-exemplo, vamos usar alguns recursos grficos, porm sem entrar em
muitos detalhes para no complicar.
Applets so aplicaes grficas feitas especificamente para rodar dentro de um browser. Os browser
so os programas usados para navegar na internet. Os mais conhecidos so o Internet Explorer do
Windows e o Firefox do Linux. Essas aplicaes usam classes grficas que esto na biblioteca
java.applet. Assim como as aplicaes grficas, normalmente comeamos a aprender a fazer applets
depois de termos aprendido bem as aplicaes console.
Vamos portanto criar alguns programas simples e vamos comenta-los passo-a-passo.

Programa 1 - ProgramaComEco
V no BlueJ, crie um novo projeto e crie uma nova classe dentro desse projeto chamada
ProgramaComEco. Delete as linhas de exemplo criadas pelo BlueJ e digite o cdigo abaixo:
import java.util.Scanner;
public class ProgramaComEco
{
public static void main(String[] args)
{
Scanner teclado = new Scanner(System.in);
System.out.println(Digite qualquer coisa e tecle ENTER);
String linha = teclado.nextLine();
System.out.println(linha);
}
}

Curso Bsico de JAVA

75

Compile e execute o programa. Este programa pede para voc digitar um texto e a seguir imprime
de volta o texto que voc digitou. O resultado deve ser algo parecido com o da Figura 45 abaixo:

Figura 45 Resultado da execuo do ProgramaComEco

Vamos analisar o programa. Na primeira instruo do mtodo principal criado um objeto chamado
teclado pertencente classe Scanner, que uma das 3.500 classes da biblioteca do Java. Para
podermos ter acesso esta classe temos que usar o comando import java.util.Scanner na primeira
linha do programa para indicar ao computador onde encontrar a classe Scanner. Esse objeto
(teclado) funcionar como entrada de dados do nosso programa, ou seja, atravs dele que o
usurio ir digitar os dados de entrada.
Na segunda instruo do mtodo principal h um comando de impresso que imprime na tela a
String Digite qualquer coisa e tecle ENTER. Como o comando System.out.println imprime na
tela de console e ns estamos executando o programa de dentro do BlueJ (e no de dentro da tela de
console como fizemos no programa BomDia na pg. 32), o BlueJ ir abrir uma janelinha de console
para poder imprimir a String.
Na terceira instruo declarada uma varivel do tipo String chamada linha e atribuda a ela o
resultado da chamada do mtodo nextLine() direcionada ao objeto teclado. Este objeto (teclado)
que criamos na primeira instruo da classe Scanner e portanto ele nasce sabendo executar todos
os mtodos da classe Scanner. Entre estes mtodos, h um chamado nextLine() que justamente o
mtodo que ns estamos invocando. Portanto teclado.nextLine() significa: Ei objeto teclado, quer
fazer o favor de executar o mtodo nextLine() ?.
O mtodo nextLine() aguarda o usurio digitar alguma coisa e teclar ENTER e a seguir retorna ao
programa principal uma String contendo o texto que o usurio digitou. Portanto nesta parte do
programa que o cursor fica piscando espera do usurio. Depois que o usurio terminar de digitar e
teclar ENTER, o mtodo nextLine() retorna uma String com o contedo. No exemplo da Figura 45
o usurio digitou a frase Testando ... 1,2,3 ... e teclou ENTER. Portanto, ao retornar a execuo
para o programa principal, a instruo String linha = teclado.nextLine(); ir se transformar em
String linha = Testando ... 1,2,3 ...; que uma instruo de atribuio. O computador ir
armazenar dentro da varivel linha a String Testando ... 1,2,3 ....
Finalmente, na quarta instruo, h um comando de impresso: System.out.println(linha);
Aps substituir a varivel linha por seu contedo, a instruo se transformar em
System.out.println(Testando ... 1,2,3 ...); que uma instruo de impresso na tela de console.
Como j estamos na tela de console, ir aparecer a String digitada e o resultado ser igual ao da
Figura 45. Note que h na tela do console duas vezes a mesma String. A primeira a String que foi
digitada pelo usurio e a segunda a String impressa pelo computador, que igual do usurio. Por
isso o programa se chama ProgramaComEco.

Curso Bsico de JAVA

76

Programa 2 - ProgramaGraficoComEco
Vamos agora criar uma verso deste programa usando recursos grficos. Ao invs de usar a janela
de console para receber dados do usurio ou imprimir frases na tela, vamos usar duas janelinhas
grficas da classe JOptionPane. V no BlueJ, crie um novo projeto e crie uma nova classe dentro
desse projeto chamada ProgramaGraficoComEco. Delete as linhas de exemplo criadas pelo BlueJ e
digite o cdigo abaixo:
import javax.swing.JOptionPane;
public class ProgramaGraficoComEco
{
public static void main(String[] args)
{
String linha = JOptionPane.showInputDialog("Digite qualquer coisa");
JOptionPane.showMessageDialog(null, "Voc digitou: " + linha);
}
}

Compile e execute o programa. Eu testei digitando a frase Testando programa grfico e obtive
como resultado a figura abaixo:
Vamos analisar o programa. Este programa pode ser considerado uma aplicao grfica porque usa
componentes grficos. Os programas grficos so bem mais complexos que as aplicaes console.
Neste exemplo vamos usar apenas umas poucas instrues grficas para no dificultar demais.
A classe JOptionPane uma classe grfica que fica armazenada na biblioteca javax.swing, portanto
comeamos o programa com a instruo de importao import javax.swing.JOptionPane;
Esta classe possui 61 mtodos. Entre eles existem alguns mtodos estticos. Um mtodo esttico
um mtodo que pode ser chamado sem a necessidade de criar um objeto e direcionar a chamada do
mtodo a este objeto. Como vimos, o normal criar um objeto (exemplo: Circulo sol = new
Circulo()) e depois chamar um mtodo direcionado quele objeto especfico
(ex: sol.tornarVisivel()).
Porm se o mtodo que pretendemos invocar esttico, no h necessidade de criar um objeto
daquela classe. Mas se no criamos um objeto quem que vai executar o mtodo? A prpria classe.
Ou seja, quem executa um mtodo esttico no o objeto mas sim a classe. A sintaxe de invocao
de um mtodo esttico : Nome-da-classe.nome-do-mtodo(). O que indica se um mtodo esttico
a presena da palavra static no cabealho do mtodo.
A primeira instruo do mtodo principal est declarando uma varivel chamada linha, do tipo
String, e est atribuindo a ela o valor retornado pelo mtodo showInputDialog da classe
JOptionPane. O mtodo showInputDialog mostra na tela uma janelinha e fica esperando o usurio
digitar na tela e clicar em OK (ou teclar ENTER) para retornar ao programa principal. Quando o
usurio digitar e clicar em OK (ou teclar ENTER) ele retorna uma String contendo o texto que o
usurio digitou. Esta String retornada pelo mtodo showInputDialog ser atribuda varivel linha.
Veja que quando chamamos o mtodo showInputDialog, passamos uma String como parmetro.
Essa String ser impressa na janelinha e normalmente digitamos um texto informando ao usurio o
que ele deve digitar. Neste programa passamos como parmetro a String Digite qualquer coisa.
Ao executar o mtodo ir aparecer na tela uma janela igual da Figura 46 abaixo:

Curso Bsico de JAVA

77

Figura 46 janela de input (entrada de dados) do ProgramaGraficoComEco

Se no aparecer nada pode ser que a janela esteja encoberta pela janela principal do BlueJ ou por
outra janela qualquer. Minimize todas as janelas abertas at que fique somente a janelinha de Input.
Na segunda instruo do mtodo principal h uma invocao ao mtodo showMessageDialog que
tambm um mtodo esttico da classe JOptionPane. Este mtodo mostra outra janelinha na tela
contendo a String que for passada como parmetro. No nosso caso a String que est sendo passada
como parmetro Voc digitou : + linha. Ou seja, feita uma concatenao (unio) da String
Voc digitou: com o contedo da varivel linha (que armazena a String digitada pelo usurio na
janela de input (entrada de dados)). O resultado da concatenao ser impresso na janelinha
Message (mensagem).
Por exemplo, se for digitado na janela de input a frase Testando programa grfico, o resultado da
janela de mensagem ser igual ao da Figura 47:

Figura 47 janela de mensagem do ProgramaGraficoComEco

Note que a String a ser impressa na janela o segundo parmetro do mtodo showMessageDialog O
primeiro parmetro a palavra null. No vamos explicar para que serve este null, porque precisaria
explicar um monte de coisas primeiro. Basta saber que a ordem da passagem de parmetros esta:
primeiro a palavra null, depois a String a ser impressa na janela. Como so dois parmetros, eles
vem separados por vrgulas.

Programa 3 CalculaFatorial
Este programa pede ao usurio para digitar um nmero inteiro e imprime o fatorial deste nmero.
Fatorial de um nmero igual ao produto dos nmeros 1 at o nmero desejado. Exemplos:
Fatorial de 3 = 1 * 2 * 3 = 6
Fatorial de 7 = 1 * 2 * 3 * 4 * 5 * 6 * 7 = 5.040
Fatorial de 12 = 1 * 2 * 3 * 4 * 5 * 6 * 7 * 9 * 10 * 11 * 12 = 479.001.600
V no BlueJ, crie um novo projeto e crie uma nova classe dentro desse projeto chamada
CalculaFatorial. Delete as linhas de exemplo criadas pelo BlueJ e digite o cdigo abaixo:

Curso Bsico de JAVA

78

import java.util.Scanner;
public class CalculaFatorial
{
public static void main(String[] args)
{
Scanner teclado = new Scanner(System.in);
System.out.println(Digite um numero inteiro);
int num = teclado.nextInt();
int total = 1;
int contador = num;
while (contador > 0)
{
total = total * contador;
contador--;
}
System.out.println(O fatorial de + num + : + total);
}
}

Compile e execute o programa. Se voc digitar o nmero 7, o resultado dever ser igual Figura 48:

Figura 48 Resultado da execuo do CalculaFatorial

O incio do programa idntico ao programa 1 (ProgramaComEco). As mudanas comeam na
terceira instruo do mtodo principal: int num = teclado.nextInt();
Aqui est sendo declarada uma varivel inteira chamada num e est sendo atribuda a ela o valor
retornado pelo mtodo nextInt() do objeto teclado.
No ProgramaComEco fizemos uma chamada ao mtodo nextLine() do teclado, que aguardava o
usurio digitar alguma coisa e retornava o texto digitado em formato String. Aqui estamos
chamando o mtodo nextInt(). O mtodo nextInt() faz a mesma coisa que o nextLine(), ou seja
aguarda o usurio digitar alguma coisa e retorna o texto digitado. Porm ele retorna o texto digitado
no formato int (inteiro) em vez de String. Se quisssemos que o usurio digitasse um nmero real,
invocaramos o mtodo nextDouble. Se quisssemos que o usurio digitasse um valor true ou false,
invocaramos o mtodo nextBoolean() e assim por diante.
Veja que avisamos ao usurio que era para ele digitar um nmero inteiro. No entanto, se ele digitar
qualquer coisa diferente disto (uma String por exemplo) o programa vai dar erro.
A seguir declarada uma varivel inteira chamada total e inicializada com o valor 1. Normalmente,
quando criamos variveis para contar (somar) alguma coisa, costumamos inicializ-la com o valor

Curso Bsico de JAVA

79

zero. Porm aqui vamos usar a varivel total para multiplicar os nmeros de 1 at num, por isso
inicializamos com o valor 1.
Depois declarada uma varivel inteira chamada contador e inicializada com o valor de num.
Lembre que num est armazenando o numero digitado pelo usurio.
A seguir vem a instruo while. O computador vai executar os comandos dentro do while at que a
condio testada seja falsa. Da primeira vez que testar a condio (contador > 0). Supondo que o
usurio digitou o valor 7, a expresso se transformar em (7 > 0) que verdadeiro e o programa
executa as instrues de dentro do while. A primeira instruo total = total * contador;
Aps as substituies ela se transforma em total = 1 * 7; que resulta em 7 e portanto a varivel
total passar a armazenar o valor 7. A segunda instruo uma instruo de decremento sobre a
varivel contador, ou seja, contador vai ter seu valor diminudo de 1 e passar a valer 6.
Como no h mais instrues a serem executadas dentro do bloco do while, o programa volta a
fazer o teste da expresso (contador > 0) que desta vez se transforma em (6 > 0) o que verdadeiro
e o programa volta a entrar no corpo do while. A primeira instruo do while total = total *
contador; que desta vez se transforma em total = 7 * 6; que resulta em 42 e portanto a varivel
total passa a armazenar o valor 42. A segunda instruo decrementa o contador que passa a valer 5.
Novamente testada a condio do while e desta vez a expresso vira (5 > 0) que verdadeiro e o
programa torna a entrar no while e etc e etc.
O programa vai fazer isto at que na stima vez que ele for testar o while o contador estar valendo
1 e a expresso ser (1 > 0) o que ainda verdadeiro e o programa entra mais uma vez no while,
calcula o valor do total e decrementa o valor do contador. Desta vez contador passa a valer 0 (zero).
Quando for testar novamente a condio do while, a expresso (contador > 0) vai se transformar em
(0 > 0) o que falso e o programa termina de executar a instruo while e passa para a prxima
instruo.
A prxima instruo uma instruo de impresso que imprime o resultado da concatenao de O
fatorial de mais o contedo da varivel num (que 7) mais a String mais o contedo da
varivel total (que 5040). O resultado que vimos na Figura 48.

Programa 4 CalculaFatorial2
Vamos fazer uma outra verso do CalculaFatorial, desta vez usando os mtodos showInputDialog e
showMessageDialog em lugar da janela de console e a instruo for em lugar da instruo while.
V no BlueJ, crie um novo projeto e crie uma nova classe dentro desse projeto chamada
CalculaFatorial2 Delete as linhas de exemplo criadas pelo BlueJ e digite o cdigo abaixo:

Curso Bsico de JAVA

80

import javax.swing.JOptionPane;
public class CalculaFatorial2
{
public static void main(String[] args)
{
String numero = JOptionPane.showInputDialog("Digite um numero inteiro");
int num = Integer.parseInt(numero);
int total = 1;
for (int i = 1 ; (i <= num) ; i++)
{
total = total * i;
}
JOptionPane.showMessageDialog(null,O fatorial de + num + : + total);

Este programa faz a mesma coisa que o anterior, pede para o usurio digira um nmero inteiro,
depois calcula o fatorial deste nmero e mostra o resultado em uma janela.
No programa anterior usamos o mtodo nextInt() que retorna um valor digitado pelo usurio. Aqui
estamos usando o mtodo showInputDialog que retorna uma String digitada pelo usurio. A
primeira instruo do mtodo principal declara uma varivel do tipo String chamada numero e
atribui a ela o resultado da chamada do mtodo esttico showInputDialog, aonde pedimos ao
usurio para digitar um numero inteiro. No existe na classe JOptionPane um mtodo para retornar
um valor numrico, como o caso do nextInt usado na aplicao console anterior. Qualquer coisa
que o usurio digitar (mesmo que seja apenas um valor numrico) vai ser retornado para o programa
principal como sendo uma String. Acontece que no podemos fazer clculos em cima de Strings.
Temos que transformar essa String em um valor numrico.
A segunda instruo do mtodo principal, int num = Integer.parseInt(numero); faz exatamente
isto, transforma a String digitada pelo usurio (armazenada na varivel numero) em um nmero
inteiro e armazena este nmero na varivel inteira num.
A classe Integer possui um mtodo esttico chamado parseInt que recebe uma String como
parmetro e retorna um valor inteiro. Como um mtodo esttico, no precisamos criar um objeto
da classe Integer para chamar o mtodo, basta escrever o nome da classe (Integer) mais ponto e
mais o nome do mtodo (parseInt) passando como parmetro a String que queremos transformar em
um nmero inteiro (no nosso caso a varivel numero que guarda a String digitada pelo usurio).
Esta classe Integer est na biblioteca java.lang. Teoricamente deveramos iniciar o programa
escrevendo uma instruo de importao import java.lang.Integer; para podermos ter acesso
esta classe. Ocorre que a biblioteca java.lang armazena as classes mais fundamentais do Java. Elas
so to utilizadas que no preciso importa-las para poder fazer uso delas.Qualquer classe da
biblioteca java.lang pode ser usada sem a necessidade de escrever a instruo import java.lang.
Alis a instruo de impresso (System.out.println), uma das mais usadas nos programas Java
tambm usa uma destas classes. Na verdade ao usarmos o comando de impresso estamos
chamando o mtodo esttico println() direcionado uma varivel chamada out (sada) que foi
definida dentro da classe System. Esta classe System est definida dentro da biblioteca java.lang e
por isso podemos usar o System.out.println sem ter que importar a classe.
A instruo de repetio (que no programa anterior era o while) aqui o for. Na sintaxe do for,
definimos primeiro a varivel que vai contar o numero de repeties. Neste caso estamos
declarando uma varivel inteira chamada i e estamos inicializando com o valor 1. Depois definimos
a expresso que ser testada, neste caso, (i <= num). Por fim, definimos que instruo(es) deve ser

Curso Bsico de JAVA

81

executada aps a iterao (execuo dos comandos dentro do for). Neste caso, aps executar os
comandos de dentro do for, o programa vai incrementar o valor de i, ou seja, vai somar 1 ao valor
de i.
Como i foi inicializado com 1, da primeira vez que for testada a expresso (i <= num) ela se
transformar em (1 <= 7) que verdadeiro e o programa executar as instrues dentro do corpo do
for. S h uma instruo (total = total * i;) que aps as substituies virar total = 1 * 1; o que ir
armazenar o valor 1 dentro da varivel total. A seguir executada a instruo i++ que ir
incrementar o valor de i, que passar a valer 2.
No segundo teste, a expresso ser (2 <= 7) que tambm verdadeiro e o programa executar a
instruo total = total * i; que agora se transformar em total = 1 * 2; o que ir armazenar o valor 2
dentro da varivel total. A seguir i ser incrementado passando a valer 3.
No terceiro teste, a expresso ser (3 <= 7) que tambm verdadeiro e o programa executar a
instruo total = total * i; que agora se transformar em total = 2 * 3; o que ir armazenar o valor 6
dentro da varivel total. A seguir i ser incrementado passando a valer 4.
E assim por diante. Quando a varivel i estiver valendo 8, o teste da expresso (i <= num) resultar
em (8 <= 7) o que falso e o programa termina a execuo da instruo de repetio e segue em
frente.
A prxima instruo a JOptionPane.showMessageDialog que vai mostrar uma janelinha de
mensagem com o resultado do clculo.

Programa 5 CalculaRendimentoCarro

O programa a seguir pede ao usurio para digitar o numero de litros que foram necessrios para
abastecer o tanque de combustvel. A seguir pede que o usurio informe quantos quilmetros foram
rodados desde a ltima vez que ele completou o tanque. A seguir mostra o rendimento do carro, ou
seja, quantos quilmetros ele est fazendo por litro de combustvel.
import java.util.Scanner;
public class CalculaRendimentoCarro
{
public static void main(String[] args)
{
Scanner teclado = new Scanner(System.in);
System.out.println("Digite o nmero de litros");
double litros = teclado.nextDouble();
System.out.println("Digite o nmero de quilometros");
double quilometros = teclado.nextDouble();

litro");
}
}

double total = quilometros / litros;

System.out.println("Seu carro est fazendo " + total + " quilometros por

Curso Bsico de JAVA

82

A Figura 49 mostra o resultado de um teste do programa CalculaRendimentoCarro:

Figura 49 Resultado da execuo do CalculaRendimentoCarro

A nica novidade neste programa o uso do mtodo nextDouble() em vez de nextInt(), uma vez que
tanto os valores de litros quanto de quilometros rodados podem ser expressos usando casas
decimais. Repare que as variveis litros, quilometros e total foram definidas como sendo do tipo
doubl, ou seja, que aceitam valores numricos com casas decimais.

Programa 6 ImprimeInvertido
Este programa pede ao usurio para digitar qualquer coisa e depois imprime na tela o texto que ele
digitou, s que impresso ao contrrio.
import java.util.Scanner;
public class ImprimeInvertido
{
public static void main(String[] args)
{
Scanner teclado = new Scanner(System.in);
System.out.println("Digite qualquer coisa e tecle ENTER");
String texto = teclado.nextLine();
String textoInvertido = "";
int tamanho = texto.length() - 1;
for (int i=tamanho ; i >= 0 ; i--)
{
textoInvertido = textoInvertido + texto.charAt(i);
}
System.out.println(textoInvertido);
}

A Figura 50 mostra o resultado de uma execuo do programa ImprimeInvertido, digitando a

palavra varginha:

Curso Bsico de JAVA

83

Figura 50 Resultado da execuo do ImprimeInvertido

A idia aqui ler as letras ao contrrio, da ltima para a primeira e medida que vai lendo vai
somando as letras lidas a uma varivel chamada textoInvertido. A quarta instruo do mtodo
principal cria uma varivel do tipo String chamada textoInvertido e inicializa com uma String nula,
que seria o equivalente a incializar um contador numrico com o valor zero.
Quando o programa ler a ltima letra do texto digitado pelo usurio, vai concatenar aquela letra
com o contedo de textoInvertido que uma String sem letra nenhuma. O resultado ser a ltima
letra do texto. Isto seria o equivalente a somar zero a um nmero qualquer. O resultado seria o
prprio nmero. Quando o programa ler a penltima letra, vai concatenar o contedo de
textoInvertido com esta penltima letra e assim por diante at chegar primeira quando ento
textoInvertido vai estar armazenando o texto digitado ao contrrio.
Neste programa invocamos dois mtodos da classe String. A classe String tem 65 mtodos, alguns
deles bastante teis como toUpperCase() que converte todos os caracteres do String para
maisculas, o substring(int inicio, int fim) que retorna a substring (pedao da String original) que
vai da posio inicio at a posio fim passadas como parmetros, o replace(char antigo, char novo)
que percorre a String da primeira at a ltima posio procurando por ocorrncias do caracter antigo
(passado como parmetro) e quando encontra substitui o caracter antigo pelo caracter novo
(tambm passado como parmetro) e muitos outros.
Todo objeto definido como sendo do tipo String j nasce sabendo executar estes 65 mtodos. No
nosso programa definimos as variveis texto e textoInvertido como sendo do tipo String. Portanto
podemos invocar chamadas de mtodos da classe String direcionadas a essas duas variveis.
Vamos usar dois mtodos da classe String. O primeiro o mtodo length() que, quando invocado,
conta quantos caracteres tem a String e retorna um valor inteiro contendo o numero de caracteres. O
segundo mtodo o charAt(int n) que, quando invocado, retorna qual o caracter que ocupa a
n-sima posio do String.
Porm preciso conhecer um detalhe importante: as posies da String no so contadas
comeando da posio 1 em diante. Elas so contadas da posio 0 (zero) em diante. A primeira
posio da String contada como zero. Assim, a String BOLA, por exemplo, tem tamanho de 4
(length() = 4) e tem as seguintes posies: charAt(0) = B, charAt(1) = O, charAt(2) = L e
charAt(3) = A.
Vamos ao programa: comeamos como nas outras aplicaes console, importando a classe Scanner.
A classe String tambm uma classe da biblioteca do Java e a rigor tambm teria que ser declarada
uma instruo import para ela. Porm a classe String faz parte da biblioteca java.lang que, como
vimos no Programa 4, a biblioteca das classes fundamentais, to utilizadas que o Java permite que
sejam usadas sem a necessidade de escrever instrues import para elas.

Curso Bsico de JAVA

84

A seguir declarada a varivel teclado que vai ler os dados digitados pelo usurio e impressa na
tela do console uma mensagem pedindo ao usurio para digitar alguma coisa na tela de console.
Na terceira instruo do mtodo principal feita a leitura do texto digitado pelo usurio e esta
String atribuda varivel texto. A seguir definida a varivel textoInvertido, tambm do tipo
String, e inicializada com o valor , ou seja uma String vazia.
A instruo seguinte invoca o mtodo length() direcionado varivel texto, diminui o valor retorna
de 1 e armazena o resultado em tamanho. Por exemplo, se o usurio digitou varginha a instruo
int tamanho = texto.length() 1; se transformar, aps a chamada de mtodo, em
int tamanho = 8 1; o que armazenar 7 na varivel tamanho.
A prxima instruo a instruo de repetio for. Na primeira seo da instruo for, declarada a
varivel inteira i e inicializada com o valor tamanho (no nosso exemplo tamanho comea com o
valor 7, que o tamanho de varginha (8) menos 1). Na segunda seo definida a expresso a ser
testada: ( i >= 0). Na terceira seo definida a instruo a ser executada ao trmino da iterao:
i--, ou seja, i ter seu valor diminudo de 1.
Na primeira vez que for testar a expresso (i >= 0) o resultado ser (7 >= 0) (lembre-se que i foi
incializada com o contedo de tamanho (7 no nosso exemplo)). Como 7 maior que zero o
resultado verdadeiro e o programa executa as instrues do corpo do for. S h uma instruo de
atribuio que armazena na varivel textoInvertido o resultado da concatenao de textoInvertido
com o resultado da invocao do mtodo texto.charAt(i). Como i comea com o valor 7, o mtodo
invocado texto.charAt(7) que retorna o caracter que ocupa a stima posio da String varginha.
Como as posies so contadas de 0 at 7, a stima posio ocupada pelo caracter a que
retornado para a instruo.
Como a String textoInvertido foi inicializada com , a instruo de atribuio se transformar em
textoInvertido = + a; Concatenar um caracter com uma String transforma o resultado em
uma String. Assim, concatenar o caracter a com uma String vazia transforma o resultado na
Stringa que ser armazenada dentro da varivel textoInvertido. A seguir a varivel i ser
decrementada passando a valer 6.
No segundo teste da expresso (i >= 0) o resultado ser (6 >= 0) que verdadeiro e o programa
entra novamente no corpo do for. Agora o mtodo texto.charAt(6) retorna o caracter h. A instruo
de atribuio ser textoInvertido = a + h; que resultar na String ah que ser armazenada na
varivel textoInvertido. Aps ao decremento, o valor de i passar a ser 5.
No terceiro teste da expresso (i >= 0) o resultado ser (5 >= 0) que verdadeiro e o programa entra
novamente no corpo do for. Agora o mtodo texto.charAt(6) retorna o caracter n. A instruo de
atribuio ser textoInvertido = ah + n; que resultar na String ahn que ser armazenada na
varivel textoInvertido. Aps ao decremento, o valor de i passar a ser 4.
E assim por diante, at que quando o valor de i for igual a 0, a expresso (i >= 0) ser igual a
(0 >= 0) o que verdadeiro e o programa tornar a entrar no corpo do for. O mtodo charAt(0)
retornar o caracter v (lembre-se que o ndice 0 equivale primeira posio da String). A instruo
de atribuio ser textoInvertido = ahnigra + v; que resultar em ahnigrav que ser
armazenada na varivel textoInvertido. Aps o decremento, o valor de i passar a ser -1.
Desta vez, quando for testada a expresso (i >= 0) ela se transformar em (-1 >= 0) o que falso e o
programa termina a execuo da instruo de repetio for e passa para a instruo seguinte.

Curso Bsico de JAVA

85

A ltima instruo imprime na tela o contedo da varivel textoInvertido.

Programa 7 ParOuImpar

O programa a seguir simula um jogo de par ou mpar entre o usurio e o computador.

import java.util.Random;
import javax.swing.JOptionPane;
public class ParOuImpar
{
public static void main(String[] args)
{
String parOuImpar = JOptionPane.showInputDialog("Digite P para par ou I
para mpar");
parOuImpar = parOuImpar.toUpperCase();
String usuario = JOptionPane.showInputDialog("Digite um numero entre 0 e
10");
int numUsuario = Integer.parseInt(usuario);
Random aleatorio = new Random();
int numComputador = aleatorio.nextInt(11);
int soma = numUsuario + numComputador;
int resto = soma % 2;
System.out.println("Voc jogou " + numUsuario);
System.out.println("O computador jogou " + numComputador);
System.out.println("Total = " + soma);
if (parOuImpar.equals("P"))
if (resto == 0)
System.out.println("PAR !
Voc venceu !!!");
else
System.out.println("MPAR !
Voc perdeu !!!");
else if (resto != 0)
System.out.println("MPAR !
Voc venceu !!!");
else
System.out.println("PAR !
Voc perdeu !!!");
}

Logo no incio pedido ao usurio digitar P se ele quiser escolher PAR ou I se ele escolher
MPAR. O que o usurio digitar ser atribudo varivel parOuImpar.
A instruo parOuImpar = parOuImpar.toUpperCase(); uma chamada ao mtodo toUpperCase()
direcionada varivel parOuImpar. Ela ir transformar a String digitada pelo usurio em maiscula,
caso o usurio digite p ao invs de P (ou i ao invs de I).
A novidade aqui a classe Random que usada para gerar nmeros aleatrios (conhecidos como
nmeros randmicos). A instruo Random aleatrio = new Random() declara uma varivel do tipo
Random chamada aleatorio e a inicializa com um novo objeto da classe Random.. A instruo
int numComputador = aleatorio.nextInt(11); escolhe um nmero inteiro entre 0 e 10 e atribui
varivel numComputador.

Curso Bsico de JAVA

86

A instruo if comea testando se a varivel parOuImpar igual a P. Repare que no usamos o

sinal == que usamos quando comparamos dois valores numricos ou booleanos. O sinal de
igualdade == s pode ser usado para comparar variveis primitivas. Quando estamos comparando
dois objetos temos que usar o mtodo equals().
Como a varivel parOuImpar do tipo String e String uma das classes do Java, isso significa que
parOuImpar um objeto. A String P que estamos comparando com a varivel parOuImpar
tambm um objeto (toda String um objeto pertencente classe String). O mtodo equals()
invocado direcionado a um objeto passando como parmetro o outro objeto a ser comparado. O
mtodo equals() retorna true (verdadeiro) se os dois objetos forem iguais e retorna false (falso) caso
contrrio. No nosso programa estamos chamando o mtodo direcionado ao objeto parOuImpar e
passando como parmetro a String P.
Portanto o primeiro teste do if verifica se parOuImpar igual a P, ou seja, se o usurio escolheu
PAR. Se for verdadeiro ento o programa executa o prximo teste (if resto == 0). A varivel resto
foi defionida como sendo do tipo inteiro e foi inicializada com o resultado de soma % 2, onde soma
armazena a soma de numUsuario com numComputador. O operador % calcula o resto da diviso.
Como estamos fazendo uma diviso por 2, se o resto for zero isto significa que o nmero par.
Caso contrrio (resto diferente de zero) isto quer dizer que o nmero mpar.
Caso o segundo teste (resto == 0) seja verdadeiro o programa imprime PAR ! Voc Venceu !!!.
Caso contrrio, o programa entra no else e imprime MPAR ! Voc perdeu !!!.
Porm se o resultado do primeiro teste (parOuImpar.equals(P)) foi falso isto significa que o
usurio escolheu IMPAR. O programa entra no else do primeiro if e executa o teste (resto != 0) para
saber se o resto diferente de zero Se resto diferente de zero (soma mpar) o programa imprime
MPAR ! Voc venceu !!!. Caso contrrio, o programa entra no else e imprime PAR ! Voc
perdeu !!!.
A Figura 51 abaixo mostra um exemplo da execuo do programa:

Figura 51 Resultado da execuo do parOuImpar