Anda di halaman 1dari 75

Curso: Engenharia da Computao

Disciplina: Programao Orientada a Objetos


Material para consulta da linguagem Java.

ndice
Lio 1 .................................................................................................................... 3
1.

Objetivos ....................................................................................................... 3

2.

Explorando o Java ......................................................................................... 3

2.1.

Um pouco da histria ................................................................................... 3

2.2.

O que uma tecnologia JAVA? ..................................................................... 3

2.3.

Algumas Caractersticas do JAVA .................................................................. 4

2.4.

Fases do Java programa ............................................................................... 5

3.

Primeiro Programa Java ................................................................................ 6

3.1.

Utilizando a Console e um editor de texto..................................................... 6

3.2.

Erros........................................................................................................... 9

4.

Usando NetBeans ......................................................................................... 10

5.

Exerccios ..................................................................................................... 20

5.1 Melhorando o Hello World! ........................................................................... 20


5.2. A rvore ....................................................................................................... 20
Lio 2 ................................................................................................................... 21
1.

Objetivos ...................................................................................................... 21

2.

Entendendo meu primeiro programa em Java .............................................. 21

3.

Comentrios em Java ................................................................................... 22

4.

Instrues e Bloco em Java .......................................................................... 23

5.

Identificadores em Java ............................................................................... 25

6.

Palavras - chave em Java .............................................................................. 25

7.

Tipos de Dados em Java ............................................................................... 26

8.

Tipos de Dados Primitivos ............................................................................ 27

9.

Variveis ...................................................................................................... 29

10.

Operadores .................................................................................................. 32

11.

Operadores de Incremento e Decremento .................................................... 34

12.

Operadores Relacionais ................................................................................ 35

13.

Operadores Lgicos ...................................................................................... 37

14.

Operador Condicional ( ?: ) .......................................................................... 42

15.

Precedncia de Operadores .......................................................................... 43

16.

Exerccios ..................................................................................................... 44

Lio 3 ................................................................................................................... 47
1.

Objetivos ...................................................................................................... 47
1

2.

BufferedReader para capturar dados............................................................ 47

3.

Classe Scanner para capturar dados............................................................. 49

4.

Utilizando a JOptionPane para receber dados .............................................. 50

5.

Exerccios ..................................................................................................... 51

5.1.

As 3 palavras (verso Console) ................................................................... 51

5.2.

As 3 palavras (verso Interface Grfica) ...................................................... 52

1.

Objetivos ...................................................................................................... 53

2.

Estruturas de controle de deciso ................................................................ 53

2.1.

Declarao if ............................................................................................... 53

2.2.

Declarao if-else ...................................................................................... 54

2.3.

Declarao if - else - if .................................................................................. 56

2.4.

Erros comuns na utilizao da declarao if .................................................. 57

2.5.

Declarao switch ....................................................................................... 58

2.6.

Exemplo para switch................................................................................... 60

3.

Estruturas de controle de repetio ............................................................. 61

3.1.

Declarao while......................................................................................... 61

3.2.

Declarao do - while ................................................................................... 62

3.3.

Declarao for ............................................................................................. 63

4.

Declaraes de Interrupo ......................................................................... 65

4.1.

Declarao break......................................................................................... 66

4.2.

Declarao continue .................................................................................... 67

4.3.

Declarao return ........................................................................................ 68

5.

Exerccios ..................................................................................................... 68

5.1.

Notas ......................................................................................................... 68

5.2.

Nmero por Extenso ................................................................................... 69

5.3.

Cem vezes.................................................................................................. 69

5.4.

Potncias ................................................................................................... 69

Lio 5 ................................................................................................................... 70
1.

Objetivos ...................................................................................................... 70

2.

Introduo a Array ....................................................................................... 70

3.

Declarando Array ......................................................................................... 70

4.

Acessando um elemento do Array ................................................................ 71

5.

Tamanho do Array ........................................................................................ 73

6.

Arrays Multidimensionais ............................................................................. 74

7.

Exerccios ..................................................................................................... 74

7.1.

Dias da semana .......................................................................................... 74

7.2.

Maior nmero ............................................................................................. 74

7.3.

Entradas de agenda telefnica ..................................................................... 74


2

Lio 1
1. Objetivos
Nesta seo, vamos discutir os componentes bsicos de um computador, tanto em relao a
hardware como a software. Tambm veremos uma pequena introduo sobre linguagens de
programao e sobre o ciclo de vida do desenvolvimento. Por fim, mostraremos os diferentes
sistemas numricos e as converses entre eles.
Ao final desta lio, o estudante ser capaz de:
Identificar os diferentes componentes de um computador.
Conhecer as linguagens de programao e suas categorias.
Entender o ciclo de vida de desenvolvimento de programas e aplic-lo na soluo de problemas.
Conhecer os diferentes sistemas numricos e as converses entre eles.

2. Explorando o Java
2.1. Um pouco da histria
Java foi criado em 1991 por James Gosling da Sun Microsystems. Inicialmente chamada
OAK(Carvalho), em homenagem uma rvore de janela do Gosling, seu nome foi mudado para Java
devido a existncia de uma linguagem com o nome OAK.
Figura 1: James Gosling criador do Java

A motivao original do Java era a necessidade de uma linguagem


independente de plataforma que podia ser utilizada em vrios produtos
eletrnicos, tais como torradeiras e refrigeradores. Um dos primeiros
projetos desenvolvidos utilizando Java era um controle remoto pessoal
chamado *7 (Star Seven).
Ao mesmo tempo, a World Wide Web e a Internet foram ganhando
popularidade. Gosling achava que a linguagem Java poderia ser usada para
programao da Internet.

2.2. O que uma tecnologia JAVA?


2.2.1. Uma linguagem de programao
Como linguagem de programao, Java pode ser utilizado para criar
todos os tipos de aplicaes existentes, de programas de Inteligncia
Artificial para Robs at programas para aparelhos celulares.

2.2.2. Um ambiente de desenvolvimento


Como ambiente de desenvolvimento, a tecnologia Java fornece um grande conjunto de ferramentas:
um compilador, um interpretador, um gerador de documentao, ferramenta de empacotamento de
classes de arquivos e outros.

2.2.3. Um ambiente de aplicao


Aplicaes de tecnologia Java so tipicamente programas de propsito geral que executam sobre
uma mquina onde o Java Runtime Environment instalado.

2.2.4. Um ambiente de distribuio


H dois ambientes de distribuio principais: Primeiro, o JRE, fornecido atravs do Java 2 Software
Development Kit (SDK), contm um conjunto completo de arquivos de classes para todos pacotes de
tecnologia Java. Outro ambiente de distribuio o navegador web, ou seja, o browser. Os
navegadores web atuais fornecem interpretao tecnologia e ambiente Java em tempo de
execuo.

Figura 3: JDK e JRE

2.3. Algumas Caractersticas do JAVA


2.3.1. Mquina Virtual Java
A Mquina Virtual Java uma mquina imaginria que implementada atravs de um software
emulador em uma mquina real. A JVM prov especificaes de plataforma de hardware na qual
compila-se todo cdigo de tecnologia Java. Essas especificaes permitem que o software Java seja
uma plataforma independente pois a compilao feita por uma mquina genrica conhecida como
JVM.

O bytecode uma linguagem de mquina especial que pode ser entendida pela Mquina Virtual
Java (JVM). O bytecode independente de qualquer hardware de computador particular. Assim,
qualquer computador com o interpretador Java pode executar um programa Java compilado, no
importando em que tipo de computador o programa foi compilado.

2.3.2. Garbage Collection


Muitas linguagens de programao permitem ao programador alocar memria durante o tempo de
execuo. Entretanto, aps utilizar a memria alocada, deve existir uma maneira para desalocar o
bloco de memria de forma que os demais programas a utilizem novamente. Em C, C++ e outras
linguagens o programador o responsvel por isso. Isso, s vezes, pode ser difcil j que instncias
podem ser esquecidas de serem desalocadas da memria pelos programadores e resultar no que
chamamos de escapes da memria.
Em Java, o programador no possui a obrigao da retirar uma varivel criada das reas de
memria, isto feito por uma parte da JVM especfica que chamamos de Garbage Collection. O
Garbage Collection o grande responsvel pela liberao automtica do espao em memria.
Isso acontece automaticamente durante o tempo de vida do programa Java.

2.3.3. Segurana de cdigo


Segurana do Cdigo alcanada em Java atravs da implementao da Java Runtime Environment
(JRE). A JRE roda cdigos compilados para a JVM e executa o carregamento de classes (atravs do
Class Loader), verificao de cdigo (atravs do verificador de bytecode) e finalmente o cdigo
executvel.
O Class Loader responsvel por carregar todas as classes necessrias ao programa Java. Isso
adiciona segurana atravs da separao do namespace entre as classes do sistema de arquivos
local e aquelas que so importadas pela rede. Isso limita qualquer ao de programas que podem
causar danos, pois as classes locais so carregadas primeiro. Depois de carregar todas as classes, a
quantidade de memria que o executvel ir ocupar determinada. Isto acrescenta, novamente,
uma proteo ao acesso no autorizado de reas restritas ao cdigo pois a quantidade de memria
ocupada determinada em tempo de execuo.
Aps carregar as classes e definir a quantidade de memria, o verificador de bytecode verifica o
formato dos fragmentos de cdigo e pesquisa nestes fragmentos por cdigos ilegais que possam
violar o direito de acesso aos objetos.
Depois que tudo isso tiver sido feito, o cdigo finalmente executado.

2.4. Fases do Java programa


A figura seguinte descreve o processo de compilao e execuo de um programa Java. O primeiro
passo para a criao de um programa Java escrever os programas em um editor de texto.
Exemplos de editores de texto que podem ser utilizados: bloco de notas, vi, emacs, etc. Esses
arquivos so armazenados no disco rgido com a extenso .java.

Figura 1: Fases de um Programa Java.

Aps o programa Java ter sido criado e salvo, compile o programa utilizando o Compilador Java. A
sada desse processo um arquivo de bytecode com extenso .class. O arquivo .class ento lido
pelo Interpretador Java que converte os bytecodes em linguagem de mquina do computador que se
est usando.

Tarefa Ferramenta utilizada Sada


Escrever o programa Qualquer editor de texto Arquivo com extenso .java Compilar o programa
Compilador Java Arquivo com extenso .class (Java bytecode). Executar o programa Interpretador
Java Sada do programa

Tabela 1: Resumo das fases de um programa Java.

3. Primeiro Programa Java


Antes de explicar o que o programa significa, vamos escrev-lo e execut-lo.

3.1. Utilizando a Console e um editor de texto

Neste exemplo utilizaremos um simples editor de texto, que pode ser o gedit do Linux ou o notepad
do Windows, para editar o cdigo fonte. Em seguida ser necessrio abrir uma janela terminal para
compilar e executar os programas.
Passo 1: executar um editor de texto
Para iniciar um editor de texto no Linux selecione Applications
iniciar um editor de texto no Windows selecione Start

Accessories

Text Editor. Para

Programs Accessories Notepad.

Passo 2: Abrir a janela de console


Para abrir o terminal no Linux, selecione Applications
terminal no Windows, selecione Start
o boto OK.

Accessories

Terminal. Para abrir o

Run... e na janela que se apresenta, digite cmd e pressione

Passo 3: Escrever as instrues utilizando o Editor de Texto


Digite as seguintes instrues no editor de textos:
public class Hello
{
/**
* Meu primeiro programa Java
*/
public static void main(String[] args) {
// Mostra na tela o texto "Hello world"
System.out.println("Hello world!");
}
}
Passo 4: Salvar o programa Java
Chamaremos o programa de "Hello.java" e o colocaremos em uma pasta denominada
"myJavaPrograms". Caso esta pasta no tenha sido criada, retorne janela de terminal aberta e
insira as seguintes instrues:
Para o Linux:
$ md myJavaPrograms
Para o Windows:
C:\> md myJavaPrograms
Retorne ao Editor de textos e salve o programa. Para abrir a caixa de dilogo salvar selecione a
opo "File" localizada na barra de menus e depois clique na opo "Save". Selecione a nova pasta
criada como myJavaPrograms para entrar nela. A pasta deve estar vazia porque ainda no salvamos
nada dentro dela.
Na caixa de texto "Name", digite o nome do programa (Hello.java), e depois clique no boto salvar.
ATENO: Para o Notepad no Windows, mude o Tipo para "All Files" (em Save as Type).
Aps salvar o arquivo observe que o ttulo da janela mudou de "Untitled" para "Hello.java", caso de-

seje alterar novamente o arquivo basta edit-lo e depois salv-lo novamente clicando em File

Save.

Passo 5: Entrar na pasta que contm o programa


O prximo passo deve ser o de compilar o programa. Inicialmente, precisamos entrar na pasta que o
contm. Retorne janela do terminal.
Em Linux:
Normalmente, quando abrimos uma janela terminal, ela vai diretamente para sua pasta home
(identificada por $). Para ver o que tem dentro do diretrio digite ls (LS em minscula, significando
"List Sources") e pressione ENTER. Isso far com que sejam listados os arquivos e pastas da pasta
home. Verifique a existncia de uma pasta chamada "myJavaPrograms", criada a pouco, sendo esta
o local em que foi salvo o programa "Hello.java". Mudaremos o contexto para esta pasta.
Para entrar nesta pasta devemos utilizar o comando: cd [nome da pasta]. O comando "cd" significa
"Change Directory". Digitaremos:
$ cd myJavaPrograms
Agora que estamos dentro da pasta onde o arquivo do programa est, poderemos ento compil-lo.
Certifique-se de que o arquivo est realmente dentro desta, executando o comando ls (LS em
minscula) novamente.
Em Windows:
Normalmente, quando abrimos uma janela terminal ela vai diretamente para sua pasta raiz
(identificada por C:\). Para conhecer o contedo do diretrio digite dir (significando "directory") e
pressione ENTER. Isso far com que sejam listados os arquivos e pastas da pasta principal. Verifique
a existncia de uma pasta chamada "myJavaPrograms", criada a pouco, sendo esta o local em que
foi salvo o programa "Hello.java". Mudaremos o contexto para esta pasta.
Para entrar nesta pasta devemos utilizar o comando: cd [nome da pasta]. O comando "cd" significa
"Change Directory". Digitaremos:
C:\>cd myJavaPrograms

Agora que estamos dentro da pasta onde o arquivo do programa est, poderemos ento compil-lo.
Certifique-se de que o arquivo est realmente dentro desta, executando o comando dir novamente.
Passo 6: Compilar o programa
Para compilar o programa, utilizamos o comando: javac [Nome do Arquivo]. Ou seja:
javac Hello.java
Durante a compilao, criado o arquivo: [Nome do Arquivo].class, neste caso, Hello.class, que
contm o cdigo em linguagem de mquina (chamado de bytecode).
Passo 7: Executar o programa
Assumindo que no ocorreu problemas na compilao (caso tenha ocorrido qualquer problema refaa
os passos realizados), estamos prontos para executar o programa.
Para executar o programa, utilizamos o comando: java [nome do arquivo sem a extenso].
No caso do exemplo, digite:
java Hello
Veremos na mesma tela, em que foi executado o comando, a seguinte mensagem:
Hello world!

3.2. Erros
Vimos um pequeno programa Java, geralmente no encontraremos qualquer problema para compilar
e executar esses programas, entretanto nem sempre este o caso, como mencionamos na primeira
parte deste curso, ocasionalmente encontramos erros durante esse processo.
Como mencionamos antes, h dois tipos de erros: o primeiro pode ocorrer durante a compilao,
chamado de erro de sintaxe, o segundo pode ocorrer durante a execuo, chamado runtime error.

3.2.1 Erros de Sintaxe


Os erros de sintaxe normalmente so erros de digitao, ocasionados pelo programador que pode
ter se equivocado e digitar uma instruo errada, ou por esquecimento de alguma parte da
instruo, por exemplo, um ponto e vrgula. O Compilador tenta isolar o erro exibindo a linha de
instruo e mostrando o primeiro caractere incorreto naquela linha, entretanto, um erro pode no
estar exata- mente neste ponto. Outros erros comuns so a troca de letras, troca de letras
maiscula por minscula (a linguagem Java completamente case - sensitive, ou seja, o caractere
"a" completamente diferente do caractere "A", e o uso incorreto da pontuao.

Vamos retornar ao exemplo, o programa Hello.java. Intencionalmente, escreveremos a palavra


chave "static" de forma errada e omitiremos o ponto-e-vrgula em uma instruo e a deixaremos
errada.
public class Hello
{
/**
* Meu primeiro programa Java
*/
public statict void main(String[] args) {
// A linha abaixo foi retirado o ;
System.out.println("Hello world!")
}
}
Salve o programa e execute os passos necessrios para compil-lo. Observe a mensagem de erro
gerada ao se tentar compilar novamente o programa:
Hello.java:6: <identifier> expected
public statict void main(String[] args) {
^
Hello.java:10: ';' expected
}
^
1 error
A primeira mensagem de erro sugere que existe um erro na linha 6 do programa apontado para
apalavra void, entretanto esta palavra est correta. O erro na palavra anterior statict que deve ser
digitada como static.
A segunda mensagem de erro sugere que faltou um ponto-e-vrgula na linha 10, entretanto, esta
contm simplesmente o comando de fechar o bloco do mtodo main. O erro est exatamente na
linha anterior. Como regra, ao encontrar muitas mensagens de erros devemos corrigir o primeiro
erro da lista e tente novamente compilar o programa. Deste modo reduziremos o nmero total de
mensagens de erro dramaticamente, pois podem existir o que chamamos de erros derivados, ou
seja, um erro que tem por causa a instruo anterior.

3.2.2 Erros em tempo de execuo (Erros de run - time)


Os erros em tempo de execuo so erros que no aparecero at que tentemos executar o
programa. Os programas so compilados com sucesso, mas apresentaro respostas erradas, que
podem ter como causa se o programador no obedeceu uma lgica coerente ou no caso em erro de
estruturas do programa.

4. Usando NetBeans
Construmos o programa sem utilizar nenhum recurso sofisticado, iremos aprender como fazer todo
o processo da seo anterior utilizando uma IDE. Nesta parte da lio utilizaremos o NetBeans que
um Ambiente de Desenvolvimento Integrado (IDE - Integrated Development Environment).

10

Um ambiente de desenvolvimento integrado um software aplicativo que possui uma interface


construtora, um editor de texto, um editor de cdigo, um compilador e/ou interpretador e um
depurador.
Passo 1 : executar o NetBeans
Existem duas formas de executar o NetBeans: a primeira utilizando a linha de comandos de uma
janela terminal e segunda selecionar o cone de atalho encontrado na janela da rea de trabalho.
Para executar o NetBeans por intermdio da linha de comando, abra uma janela terminal (Os passos
para abrir a janela terminal foram discutidos anteriormente) e digite:

Figura 1: Executando o NetBeans pela linha de comandos

Para o Windows, este comando deve ser executado na pasta em que o NetBeans foi instalado, por
exemplo:
C:\Program Files\netbeans-5.5\bin>netbeans
A segunda maneira de executar o NetBeans clicando no cone de atalho encontrado na rea de
trabalho do computador.
Depois de abrir a IDE NetBeans ser mostrada a interface grfica GUI, conforme Figura 3:

Passo 2: construir o projeto

11

Clique em File New Project, depois de fazer isso, uma janela de dilogo aparecer. Neste
momento deve-se clicar em "Java Application" e em seguida clicar no boto "Next >".

Figura 3: Janela de Welcome do NetBeans

Ser mostrada uma nova janela de dilogo, conforme a figura 5.

Troque o local da aplicao clicando no boto "Browse...". Aparecer uma janela de dilogo para
localizao do diretrio. D um clique duplo no seu diretrio home.

12

Figura 5: Inserindo as informaes do projeto

Figura 6: Acertando a Localizao do Projeto

O contedo da raiz do diretrio ser apresentado. D um clique duplo no diretrio MYJAVAPROGRAMS e depois d um clique no boto "Open".

13

Veja que a localizao do projeto mudou para /home/florence/MYJAVAPROGRAMS. Finalmente, no


campo "Create Main Class", digite "Hello", que ser o nome da classe principal, e em seguida clique
no boto "Finish".

Figura 7: Definindo o Nome da Classe Principal

Passo 3: escrever os detalhes do programa


Antes de escrever o programa descreveremos a janela principal. Como mostrado na figura 8,
automaticamente, o NetBeans cria um cdigo bsico para o programa Java. Poderemos adicionar as
declaraes neste cdigo gerado. No lado esquerdo da janela visualizamos uma lista de pastas e
arqui- vos que o NetBeans gerou antes de criar o projeto. Tudo se encontra dentro da sua pasta
MYJAVA- PROGRAMS, onde foi configurado o local do projeto. No lado direito, visualizamos o cdigo
gerado.

14

Modifique o cdigo gerado pelo NetBeans, por hora ignoraremos as outras partes das instrues
discutindo os detalhes destas posteriormente. Insira a seguinte instruo:
System.out.println("Hello world!");
Isto significa que voc deseja que seja mostrada a mensagem "Hello world!" na sada padro do
computador, em seguida seja feito um salto de linha. Poderamos substituir esta instruo por duas
equivalentes:
System.out.print("Hello");
System.out.println(" world!");
O mtodo print() faz com que no seja provocado o salto de linha, utilizaremos para este exemplo a
primeira instruo. Insira esta instruo aps a linha de comentrio (que ser desprezada pelo
compilador):
//TODO code application logic here.

15

Figura 8: Viso do projeto criado

Passo 4 : compilar o projeto


Para compilar o programa, a partir do Menu Principal selecione Build Build Main Project, ou utilize
a tecla de atalho F11, ou utilize o boto de atalho para compilar o cdigo.

16

Figura 10: Boto de Atalho para executar o Projeto

Figura 9: Inserindo sua instruo

Se no existir erros no programa, veremos a mensagem de sucesso na janela de sada.

17

Passo 5: Executar o projeto


Para executar o programa, clique em Run Run Main Project, ou utilize a tecla de atalho F6, ou
utilize o boto de atalho para executar o programa.

Figura 11: Verificando o Sucesso da Compilao

18

Figura 12: Executando o projeto

O resultado final do programa, ser mostrado na janela de sada

Figura 13: Resultado final da execuo do projeto

19

5. Exerccios
5.1 Melhorando o Hello World!
Utilizando o NetBeans crie uma classe chamada [SeuNome], o programa dever mostrar com o
resultado a mensagem:
Welcome to Java Programming [SeuNome]!!!

5.2. A rvore
Utilizando o NetBeans, crie uma classe chamada TheTree. O programa dever mostrar as seguintes
linhas na sada:
I think that I shall never see,
[Eu acho que nunca verei,]
a poem as lovely as a tree.
[um poema to adorvel quanto uma rvore.]
A tree whose hungry mouth is pressed
[Uma rvore cuja boca faminta pressionada]
Against the Earths sweet flowing breast.
[Contra a Terra fluindo em seu seio docemente.]

20

Lio 2
1. Objetivos
Nesta lio iremos discutir um pouco da histria de Java e o que a tecnologia Java. Tambm iremos discutir as fases de um programa Java.
Ao final desta lio, o estudante ser capaz de:
Descrever as caractersticas da tecnologia Java como a JVM - Mquina Virtual Java, Garbage
Collection e segurana do cdigo;
Descrever as diferentes fases de um programa Java.

2. Entendendo meu primeiro programa em Java


Tentaremos compreender este primeiro programa.
public class Hello
{
/**
* Meu primeiro programa em Java
*/
public static void main(String[] args) {
// Exibir a mensagem "Hello world" na tela
System.out.println("Hello world!");
}
}
Esta primeira linha do cdigo:
public class Hello
Indica o nome da classe, que neste caso Hello. Em Java, todo e qualquer cdigo dever ser escrito
dentro da declarao de uma classe. Fazemos isso usando a palavra-chave class. Alm disso, a
classe usa um identificador de acesso public, indicando que a classe acessvel para outras classes
de diferentes pacotes (pacotes so colees de classes). Trataremos de pacotes e identificadores de
acesso mais tarde, ainda neste mdulo.
A prxima linha contm uma chave {. Indica o incio de um bloco de instrues. Neste programa
posicionamos a chave na linha aps a declarao da classe, entretanto, poderamos tambm colocla na mesma linha em que a declarao foi feita. Ento, o cdigo seria escrito da seguinte forma:
public class Hello
{
ou
public class Hello {

21

As prximas 3 linhas indicam um comentrio em Java. Um comentrio uma explicao do


programador usada na documentao de uma parte do cdigo. Este comentrio no propriamente
uma parte do cdigo, usado apenas para fins de documentao do programa.
uma boa prtica de programao adicionar comentrios relevantes ao cdigo.
/**
* Meu primeiro programa em Java
*/
Um comentrio pode ser indicado pelos delimitadores /* e */. Qualquer coisa entre estes
delimitadores ignorado pelo compilador Java e tratado como comentrio. A prxima linha,
public static void main(String[] args) {
que tambm pode ser escrita da seguinte forma:
public static void main(String[] args)
{
indica o nome de um mtodo no programa que o mtodo principal main. O mtodo main o ponto
de partida para qualquer programa feito em Java. Todo e qualquer programa escrito em Java, com
exceo de Applets, inicia com o mtodo main. Certifique-se de que a assinatura do mtodo
(conforme descrita acima) est correta.
A linha seguinte tambm um comentrio em Java,
// exibe a mensagem "Hello world" na tela
At agora, j aprendemos duas maneiras de fazer comentrios em Java. Uma posicionar o
comentrio entre /* e */, e a outra colocar // antes do comentrio. A linha de instruo
abaixo,
System.out.println("Hello world!");
escreve o texto "Hello World!" na tela. O comando System.out.println( ), escreve na sada padro do
computador o texto situado entre aspas duplas. As ltimas duas linhas, que contm somente uma
chave em cada, simbolizam, respectivamente, o fechamento do mtodo main e da classe.

Dicas de programao :
1. Os programas em Java devem sempre conter a terminao .java no nome do arquivo.
2. O nome do arquivo deve sempre ser idntico ao nome da classe pblica. Ento, por exemplo,
se o nome da classe pblica Hello o arquivo dever ser salvo com o nome: Hello.java.
3. Inserir comentrios sobre o que a classe ou mtodo realiza, isso facilitar o entendimento de
quem posteriormente ler o programa, incluindo o prprio autor.

3. Comentrios em Java
Comentrios so notas escritas pelo programador para fins de documentao. Estas notas no fazem
parte do programa e no afetam o fluxo de controle. Java suporta trs tipos de comentrios:
comentrio de linha estilo C++, comentrio de bloco estilo C e um comentrio estilo Javadoc
(utilizado compor a documentao do programa).

22

3.1. Comentrio de linha


Comentrios com estilo em C++ se iniciam por "//". Todo e qualquer texto colocado aps as //
ignorado pelo compilador e tratado como comentrio. Por exemplo:
// Este um comentrio estilo C++ ou comentrio de linha

3.2. Comentrio de bloco


Comentrios com estilo em C, tambm chamados de comentrios multilinhas, se iniciam com /* e
terminam com */. Todo o texto posto entre os dois delimitadores tratado como comentrio.
Diferente do comentrio estilo C++, este pode se expandir para vrias linhas. Por exemplo:
/*
* Este um exemplo de comentrio
* estilo C ou um comentrio de bloco
*
*/

3.3. Comentrio estilo Javadoc


Este comentrio utilizado na gerao da documentao em HTML dos programas escritos em
Java. Para se criar um comentrio em estilo Javadoc deve se iniciar o comentrio com /** e
termin-lo com */. Assim como os comentrios estilo C, este tambm pode conter vrias
linhas. Este comentrio tambm pode conter certas tags que do mais informaes
documentao. Por exemplo:
/**
Este um exemplo de um comentrio especial usado para \n
gerar uma documentao em HTML. Este utiliza tags como:
@author Florence Balagtas
@version 1.2
*/
Este tipo de comentrio deve ser utilizado antes da assinatura da classe:
public class Hello {
Para documentar o objetivo do programa ou antes da assinatura de mtodos:
public static void main(String[] args) {
Para documentar a utilidade de um determinado mtodo.

4. Instrues e Bloco em Java


Uma instruo composta de uma ou mais linhas terminadas por ponto-e-vrgula. Um exemplo de
uma simples instruo pode ser:

23

System.out.println("Hello world");
Um bloco formado por uma ou mais instrues agrupadas entre chaves indicando que formam
uma s unidade. Blocos podem ser organizados em estruturas aninhadas indefinidamente. Qualquer
quantidade de espaos em branco permitida. Um exemplo de bloco pode ser:
public static void main(String[] args) {
System.out.print("Hello ");
System.out.println("world");
Dicas de programao:
1. Na criao de blocos, a chave que indica o incio pode ser colocada ao final da linha anterior ao
bloco, como no exemplo:
public static void main(String [] args) {
ou na prxima linha, como em:
public static void main(String [] args)
{
2. uma boa prtica de programao organizar as instrues que sero colocadas apso incio de
um bloco, como por exemplo:
public static void main(String [] args) {
System.out.print("Hello ");
System.out.println("world");
}

24

5. Identificadores em Java
Identificadores so representaes de nomes de variveis, mtodos, classes, etc. Exemplos de
identificadores podem ser: Hello, main, System, out. O compilador Java difere as letras maisculas
de minsculas (case-sensitive). Isto significa que o identificador Hello no o mesmo que hello. Os
identificadores em Java devem comear com uma letra, um underscore _, ou um sinal de cifro
$. As letras podem estar tanto em maisculo quanto em minsculo. Os caracteres subsequentes
podem usar nmeros de 0 a 9. Os identificadores no podem ter nomes iguais s palavras-chave ou
palavras reservadas do Java, como: class, public, void, int, etc. Discutiremos mais sobre estas
palavras mais tarde.
Dicas de programao:
1. Para nomes de classes, a primeira letra deve ser maiscula. Nomes de mtodos ou variveis
devem comear com letra minscula. Por exemplo:
ExemploDeNomeDeUmaClasse
exemploDeNomeDeUmMetodo
2. No caso de identificadores com mais de uma palavra, a primeira letra de cada palavra, com
exceo da primeira, deve vir em maisculo. Por exemplo:
charArray fileNumber - className
3. Evite o uso de undescores no incio de um identificador. Por exemplo:
_NomeDeClasse.

6. Palavras - chave em Java


Palavras-chave so identificadores que, em Java, foram pr-definidas para propsitos especficos.
No se pode usar esses identificadores como nomes de variveis, mtodos, classes, entre outros. A
seguir, temos a lista com as palavras-chave em Java.

25

Figura 1: Palavras-Chave em Java

Ao longo dos tpicos seguintes, iremos abordar os significados destas palavras-chave e como so
usadas nos programas em Java.

Nota: true, false e null no so palavras-chave, porm, so palavras-reservadas, e, da mesma


maneira, no permitido seu uso na atribuio a nomes de variveis, mtodos ou classes.

7. Tipos de Dados em Java


Java possui 4 tipos de dados. Estes tipos de dados so divididos em: boolean, character, integer e
float - point.

7.1. Boolean
Um dado boolean poder assumir somente dois valores: true ou false.

7.2. Character
Os characters so representaes da tabela Unicode. Um smbolo da tabela Unicode um valor de
16 bits que pode substituir os smbolos da tabela ASCII (que possuem 8 bits). A tabela Unicode
permite a insero de smbolos especiais ou de outros idiomas. Para representar um caractere
usam-se aspas simples. Por exemplo, a letra "a" ser representada como 'a'. Para representar
caracteres especiais, usa-se a "\" seguido pelo cdigo do caractere especial. Por exemplo, '\n' para o
caractere de nova linha, '\'' representar o character ' (aspas simples) e '\u0061' representao
Unicode do smbolo 'a'.

7.3. Integer
Os dados do tipo integer vm em diferentes formatos: decimal (base 10), hexadecimal (base 16), e
octal (base 8). Ao usar estes diferentes tipos de dados Integer nos programas necessrio seguir
algumas notaes preestabelecidas. Para dados decimais no existe notao, basta escrever o
nmero. Os nmeros hexadecimais devero ser precedidos por "0x" ou "0X". E os octais devero ser
precedidos por "0".
Por exemplo, considere o nmero 12. Sua representao em decimal apenas o nmero 12, sem
nenhuma notao adicional, enquanto que sua representao em hexadecimal 0xC (pois o nmero
12 em hexadecimal representado pela letra C), e em octal ele representado por 014. O valor
padro para tipos de dados Integer o tipo int. Um int um valor, com sinal, de 32 bits.
Em alguns casos pode ser necessrio forar o dado Integer a ser do tipo long, para fazer isso basta
colocar a letra "l" (L minscula) ou "L" aps o nmero. Um dado do tipo long um valor com sinal
de 64 bits. Falaremos mais sobre os tipos de dados mais tarde.

7.4. Float - Point

26

Os tipos de float - point representam dados Integer com parte fracionria. Um exemplo o nmero
3.1415 (lembrando que o padro ingls utiliza o "." como divisor da parte fracionria).
Esses tipos podem ser expressos em notao cientfica ou padro. Um exemplo de notao padro
o nmero 583.45 enquanto que em notao cientfica ele seria representado por 5.8345e2. O valor
padro para um dado ponto-flutuante o double, que um valor de 64 bits.
Se for necessrio usar um nmero com uma preciso menor (32 bits) usa-se o float, que finalizado pela letra "f" ou "F" acrescida ao nmero em questo, por exemplo, 583.45f.

8. Tipos de Dados Primitivos


A linguagem Java possui 8 tipos de dados primitivos. Eles so divididos nas seguintes representaes:

Tabela 1: Representaes dos dados primitivos

8.1. Lgico
O tipo boolean pode representar dois estados: true (verdadeiro) ou false (falso). Um exemplo :
boolean resultado = true;
No exemplo demonstrado acima, declarado um atributo chamado resultado do tipo boolean e
atribudo a este o valor verdadeiro.

8.2. Inteiro
Os inteiros em Java podem ser representados em 5 formas, como j foi visto, e estas so: decimal,
octal, hexadecimal, ASCII e Unicode. Como por exemplo:
2 // valor 2 em decimal
077 // 0 indica que ele est representado em octal.
0xBACC // 0x indica que ele est representado em hexadecimal.
'a' // representao ASCII
'\u0061' // representao Unicode

27

O dado do tipo char um inteiro especial, sendo exclusivamente positivo e representa um nico
Unicode. Ele deve ser, obrigatoriamente, colocado entre aspas simples (''). Sua representao como
inteiro pode ser confusa para o iniciante, entretanto, o tempo e a prtica faro com que se acostume
com este tipo. Por exemplo:
char c = 97; // representa o smbolo 'a'
byte b = 'a'; // em inteiro representa o nmero 97
possvel definir para qualquer inteiro nas formas mostradas. O que difere o tipo char dos demais
inteiros que a sua sada sempre ser mostrada como um valor ASCII. Enquanto que os inteiros
sero sempre mostrados por nmeros decimais. Por exemplo:
char c = 97;
byte b = 'a';
System.out.println("char = " + c + " - byte = " + b);
Resultar:
char = a - byte = 97
Um cuidado deve ser tomado quanto aos inteiros: qualquer operao efetuada entre eles ter
sempre como resultado um tipo int. Por exemplo:
byte b1 = 1;
byte b2 = 2;
byte resultado = b1 + b2;
Esta instruo final causar um erro de compilao, devendo ser modificada para:
int resultado = b1 + b2;

8.3. Inteiro Longo


Os inteiros tm por padro o valor representado pelo tipo primitivo int. Pode-se represent-los como
long adicionando, ao final do nmero, um "l" ou "L". Os tipos de dados inteiros assumem valores nas
seguintes faixas:

Tabela 2: Tipos e faixa de valores dos Inteiros e Inteiro Longo

28

Dicas de programao:
1. Para declarar um nmero como sendo um long prefervel usar L maisculo, pois, se este
estiver em minsculo, pode ser difcil distingu-lo do dgito 1.

8.4. Nmero Fracionrio


Os dados do tipo ponto-flutuante possuem o valor double como padro. Os nmeros flutuantes
possuem um ponto decimal ou um dos seguintes caracteres:
E ou e // expoente
F ou f // float
D ou d // double
So exemplos,
3.14 // tipo double
6.02E23 // double com expoente
2.718F // float
123.4E+306D // double
No exemplo acima, o nmero 23 aps o E implicitamente positivo. equivalente a 6.02E+23. Os
dados de tipo ponto-flutuante podem assumir valores dentro das seguintes faixas:

Tabela 3: Tipos e faixa de valores dos Nmero Fracionrios

9. Variveis
Uma varivel um espao na memria usado para armazenar o estado de um objeto. Uma varivel
deve ter um nome e um tipo. O tipo da varivel indica o tipo de dado que ela pode conter. O nome
das variveis deve seguir as mesmas regras de nomenclatura que os identificadores.

9.1. Declarando e inicializando Variveis


A seguir, vemos como feita a declarao de uma varivel:
<tipo do dado> <nome> [= valor inicial];

29

nota: os valores colocados entre < > so obrigatrios, enquanto que os valores contidos entre [ ]
so opcionais.
Aqui vemos um exemplo de programa que declara e inicializa algumas variveis:
public class VariableSamples {
public static void main( String[] args ){
// declara uma varivel com nome result e tipo boolean
boolean result;
// declara uma varivel com nome option e tipo char
char option;
// atribui o smbolo C para a varivel
option = 'C';
// declara uma varivel com nome grade e tipo double
// e a inicializa com o valor 0.0
double grade = 0.0;
}
}
Dicas de programao:
1. sempre prefervel que se inicialize uma varivel assim que ela for declarada.
2. Use nomes com significado para suas variveis. Se usar uma varivel para armazenar a nota de
um aluno, declare-a com o nome 'nota' e no simplesmente com uma letra aleatria 'x'.
3. prefervel declarar uma varivel por linha, do que vrias na mesma linha. Por exemplo:
int variavel1;
int variavel2;
E no:
int variavel1, variavel2;

9.2. Exibindo o valor de uma Varivel


Para exibirmos em qualquer dispositivo de sada o valor de uma varivel, fazemos uso dos seguintes
comandos:
System.out.println()
System.out.print()
Aqui est um simples programa como exemplo:
public class OutputVariable {
public static void main( String[] args ){
int value = 10;
char x;
x = 'A';
System.out.println(value);
System.out.println("The value of x = " + x );
}
}

30

A sada deste programa ser a seguinte:


10
The value of x = A

9.3. System.out.println( ) e System.out.print( )


Qual a diferena entre os comandos System.out.println( ) e o System.out.print( )? O primeiro faz
iniciar uma nova linha aps ser exibido seu contedo, enquanto que o segundo no.
Considere as seguintes instrues:
System.out.print("Hello ");
System.out.print("world!");
Essas instrues apresentaro a seguinte sada:
Hello world!
Considere as seguintes:
System.out.println("Hello ");
System.out.println("world!");
Estas apresentaro a seguinte sada:
Hello
world!

9.4. Referncia de Variveis e Valor das Variveis


Iremos diferenciar os dois tipos de variveis suportados pelo Java. Estes podem ser de referncia ou
de valor. As variveis de valor, ou primitivas, so aquelas que armazenam dados no exato espao
de memria onde a varivel est. As variveis de referncia so aquelas que armazenam o
endereo de memria onde o dado est armazenado. Ao declarar uma varivel de certa classe
(varivel de classe), se declara uma varivel de referncia a um objeto daquela classe. Por exemplo,
vamos supor que se tenha estas duas variveis do tipo int e da classe String.
int num = 10;
String nome = Hello;
Suponha que o quadro abaixo represente a memria do computador, com seus endereos de
memria, o nome das variveis e os tipos de dados que ele pode suportar.
Endereo de memria Nome da varivel Dado
1001 num 10
: :
1563 nome Endereo (2000)
:
::
2000 "Hello"

31

A varivel (do tipo int) num o dado o atual valor contido por ela e, a referncia da varivel (do tipo
string) nome somente armazenado o endereo de memria que contm o valor da varivel.

10. Operadores
Em Java temos diferentes tipos de operadores. Existem operadores aritmticos, operadores
relacionais, operadores lgicos e operadores condicionais. Estes operadores obedecem a uma
ordem de precedncia para que o compilador saiba qual operao executar primeiro, no caso de
uma sentena possuir grande variedade destes.

10.1. Operadores Aritmticos


Aqui temos a lista dos operadores aritmticos que podem ser utilizados na criao de expresses
matemticas:

Tabela 4: Operadores aritmticos e suas funes

Aqui temos um programa que exemplifica o uso destes operadores:

public class ArithmeticDemo {


public static void main(String[] args) {
// alguns nmeros
int i = 37;
int j = 42;
double x = 27.475;
double y = 7.22;
System.out.println("Variables values...");
System.out.println(" i = " + i);
System.out.println(" j = " + j);
System.out.println(" x = " + x);

32

System.out.println(" y = " + y);


// adio dos nmeros
System.out.println("Adding...");
System.out.println(" i + j = " + (i + j));
System.out.println(" x + y = " + (x + y));
// subtrao dos nmeros
System.out.println("Subtracting...");
System.out.println(" i - j = " + (i - j));
System.out.println(" x - y = " + (x - y));
// multiplicao dos nmeros
System.out.println("Multiplying...");
System.out.println(" i * j = " + (i * j));
System.out.println(" x * y = " + (x * y));
// diviso dos nmeros
System.out.println("Dividing...");
System.out.println(" i / j = " + (i / j));
System.out.println(" x / y = " + (x / y));
// resto da diviso
System.out.println("Comuting the remainder...");
System.out.println(" i % j = " + (i % j));
System.out.println(" x % y = " + (x % y));
// misturando operaes
System.out.println("Mixing types...");
System.out.println(" j + y = " + (j + y));
System.out.println(" i * x = " + (i * x));
}
}
e como sada, temos:
Variables values...

i = 37
j = 42
x = 27.475
y = 7.22
Adding...
i + j = 79
x + y = 34.695

33

Subtracting...
i - j = -5
x - y = 20.255
Multiplying...
i * j = 1554
x * y = 198.37
Dividing...
i/j=0
x / y = 3.8054
Comuting the remainder...
i % j = 37
x % y = 5.815
Mixing types...
j + y = 49.22
i * x = 1016.58
Nota: Quando um nmero de tipo inteiro e um outro de nmero fracionrio so usados numa nica
operao, o resultado ser dado pela varivel de maior tipo, no caso, valor de nmero fracionrio. O
nmero inteiro implicitamente convertido para o nmero fracionrio antes da operao ter incio.

11. Operadores de Incremento e Decremento


Alm dos operadores aritmticos bsicos, Java d suporte ao operador unrio de incremento (++) e
ao operador unrio de decremento (--). Operadores de incremento ou decremento aumentam ou
diminuem em 1 o valor da varivel. Por exemplo, a expresso,

count = count + 1; // incrementa o valor de count em 1


equivalente a,

count++;

34

Tabela 5: Operadores de incremento e decremento

Como visto na tabela acima, os operadores de incremento e decremento podem ser usados tanto
antes como aps o operando. E sua utilizao depender disso. Quando usado antes do operando,
provoca acrscimo ou decrscimo de seu valor antes da avaliao da expresso em que ele aparece.
Por exemplo:

int i = 10,
int j = 3;
int k = 0;
k = ++j + i; //resultar em k = 4+10 = 14
Quando utilizado depois do operando, provoca, na varivel, acrscimo ou decrscimo do seu valor
aps a avaliao da expresso na qual ele aparece. Por exemplo:

int i = 10,
int j = 3;
int k = 0;
k = j++ + i; //resultar em k = 3+10 = 13
Dicas de programao:
1. Mantenha sempre as operaes incluindo operadores de incremento ou decremento de forma
simples e de fcil compreenso.

12. Operadores Relacionais


Os operadores relacionais so usados para comparar dois valores e determinar o relacionamento
entre eles. A sada desta avaliao ser fornecida com um valor lgico: true ou false.

Tabela 6: Operadores relacionais

O programa a seguir, mostra a utilizao destes operadores:

35

public class RelationalDemo {


public static void main(String[] args) {
// alguns nmeros
int i = 37;
int j = 42;
int k = 42;
System.out.println("Variables values...");
System.out.println(" i = " + i);
System.out.println(" j = " + j);
System.out.println(" k = " + k);
// maior que
System.out.println("Greater than...");
System.out.println(" i > j = " + (i > j)); //false
System.out.println(" j > i = " + (j > i)); //true
System.out.println(" k > j = " + (k > j)); //false
// maior ou igual a
System.out.println("Greater than or equal to...");
System.out.println(" i >= j = " + (i >= j)); //false
System.out.println(" j >= i = " + (j >= i)); //true
System.out.println(" k >= j = " + (k >= j)); //true
// menor que
System.out.println("Less than...");
System.out.println(" i < j = " + (i < j)); //true
System.out.println(" j < i = " + (j < i)); //false
System.out.println(" k < j = " + (k < j)); //false
// menor ou igual a
System.out.println("Less than or equal to...");
System.out.println(" i <= j = " + (i <= j)); //true
System.out.println(" j <= i = " + (j <= i)); //false
System.out.println(" k <= j = " + (k <= j)); //true
// igual a
System.out.println("Equal to...");
System.out.println(" i == j = " + (i == j)); //false
System.out.println(" k == j = " + (k == j)); //true
// diferente
System.out.println("Not equal to...");
System.out.println(" i != j = " + (i != j)); //true
System.out.println(" k != j = " + (k != j)); //false

36

}
}
A seguir temos a sada deste programa:
Variables values...

i = 37
j = 42
k = 42
Greater than...

i > j = false
j > i = true
k > j = false
Greater than or equal to...

i >= j = false
j >= i = true
k >= j = true
Less than...

i < j = true
j < i = false
k < j = false
Less than or equal to...

i <= j = true
j <= i = false
k <= j = true
Equal to...

i == j = false
k == j = true
Not equal to...

i != j = true
k != j = false

13. Operadores Lgicos


Operadores lgicos avaliam um ou mais operandos lgicos que geram um nico valor final true ou
false como resultado da expresso. So seis os operadores lgicos: && (e lgico), & (e binrio), ||
(ou lgico), | (ou binrio), ^ (ou exclusivo binrio) e ! (negao).
A operao bsica para um operador lgico :

37

x1 op x2
Onde x1 e x2 podem ser expresses, variveis ou constantes lgicas, e op pode tanto ser &&, &, ||,
| ou ^.

13.1. && (e lgico) e & (e binrio)

Tabela 7: Tabela para && e &

A diferena bsica do operador && para & que o && suporta uma avaliao de curto-circuito (ou
avaliao parcial), enquanto que o & no. O que isso significa?
Dado o exemplo:

exp1 && exp2


o operador e lgico ir avaliar a expresso exp1, e, imediatamente, retornar um valor false se a
operao exp1 for falsa. Se a expresso exp1 resultar em um valor false o operador nunca avaliar
a expresso exp2, pois o valor de toda a expresso ser falsa mesmo que o resultado isolado de
exp2 seja verdadeiro. J o operador & sempre avalia as duas partes da expresso, mesmo que a
primeira tenha o valor false.
O programa a seguir, mostra a utilizao destes operadores:

public class TestAND {


public static void main( String[] args ) {
int i = 0;
int j = 10;
boolean test = false;
// demonstrao do operador &&
test = (i > 10) && (j++ > 9);
System.out.println(i);
System.out.println(j);
System.out.println(test);
// demonstrao do operador &
test = (i > 10) & (j++ > 9);
System.out.println(i);
System.out.println(j);

38

System.out.println(test);
}
}
Como resultado, o programa produzir a seguinte sada:

0
10
false
0
11
false
Note que o comando j++, na linha contendo &&, nunca ser executado, pois o operador no o
avalia, visto que a primeira parte da expresso (i>10) retorna um valor booleano false.

13.2. | | ( ou lgico) e | ( ou binrio)

Tabela 8: Tabela para || e |

A diferena bsica entre os operadores || e |, que, semelhante ao operador &&, o || tambm


suporta a avaliao parcial. O que isso significa?
Dada a expresso,

exp1 || exp2
o operador ou lgico ir avaliar a expresso exp1, e, imediatamente, retornar um valor lgico true
para toda a expresso se a primeira parte for avaliada como verdadeira. Se a expresso exp1
resultar em verdadeira a segunda parte exp2 nunca ser avaliada, pois o valor final da expresso
ser true independentemente do resultado da segunda expresso.
O programa a seguir, mostra a utilizao destes operadores:

public class TestOR {


public static void main( String[] args ){
int i = 0;
int j = 10;
boolean test = false;
// demonstrao do operador ||

39

test = (i < 10) || (j++ > 9);


System.out.println(i);
System.out.println(j);
System.out.println(test);
// demonstrao do operador |
test = (i < 10) | (j++ > 9);
System.out.println(i);
System.out.println(j);
System.out.println(test);
}

Como resultado, o programa produzir a seguinte sada:

0
10
true
0
11
true
Note que a expresso j++ nunca ser avaliada na instruo que usa o operador ||, pois
primeira parte da expresso (i<10) j retorna true como valor final da expresso.

13.3. ^ (ou exclusivo binrio)

Tabela 9: Tabela para o operador ^

O resultado de uma expresso usando o operador ou exclusivo binrio ter um valor true somente
se uma das expresses for verdadeira e a outra falsa. Note que ambos os operandos so
necessariamente avaliados pelo operador ^.
O programa a seguir, mostra a utilizao deste operador:

public class TestXOR {


public static void main( String[] args ){
boolean val1 = true;
boolean val2 = true;

40

System.out.println(val1 ^ val2);
val1 = false;
val2 = true;
System.out.println(val1 ^ val2);
val1 = false;
val2 = false;
System.out.println(val1 ^ val2);
val1 = true;
val2 = false;
System.out.println(val1 ^ val2);
}

Como resultado, o programa produzir a seguinte sada:

false
true
false
true

13.4. ! (negao)

Tabela 10: Tabela para o operador !

O operador de negao inverte o resultado lgico de uma expresso, varivel ou constante, ou seja,
o que era verdadeiro ser falso e vice-versa. O programa a seguir, mostra a utilizao deste operador:

public class TestNOT {


public static void main( String[] args ){
boolean val1 = true;
boolean val2 = false;
System.out.println(!val1);
System.out.println(!val2);
}
}
Como resultado, o programa produzir a seguinte sada:

41

false
true

14. Operador Condicional ( ?: )


O operador condicional tambm chamado de operador ternrio. Isto significa que ele tem 3
argumentos que juntos formam uma nica expresso condicional. A estrutura de uma expresso
utilizando um operador condicional a seguinte:

exp1?exp2:exp3
Onde exp1 uma expresso lgica que deve retornar true ou false. Se o valor de exp1 for
verdadeiro, ento, o resultado ser a expresso exp2, caso contrrio, o resultado ser exp3. O
programa a seguir, mostra a utilizao deste operador:

public class ConditionalOperator {


public static void main( String[] args ){
String status = "";
int grade = 80;
//status do aluno
status = (grade >= 60)?"Passed":"Fail";
//print status
System.out.println( status );
}

Como resultado, o programa produzir a seguinte sada:

Passed
Veremos na Figura 2 um fluxograma que demonstra como o operador condicional funciona.

42

Figura 2: Fluxograma utilizando o operador condicional

Veremos outro programa que tambm utiliza o operador condicional:

public class ConditionalOperator {


public static void main( String[] args ){
int score = 0;
char answer = 'a';
score = (answer == 'a') ? 10 : 0;
System.out.println("Score = " + score );
}
}
Como resultado, o programa produzir a seguinte sada:

Score = 10

15. Precedncia de Operadores


A precedncia serve para indicar a ordem na qual o compilador interpretar os diferentes tiposde
operadores, para que ele sempre tenha como sada um resultado coerente e no ambguo.

43

TabelTabela 11: Precedncia de operadores

No caso de dois operadores com mesmo nvel de precedncia, ter prioridade o que estiver mais
esquerda da expresso. Dada uma expresso complexa como:

6%2*5+4/2+88-10
O ideal seria fazer uso de parnteses para reescrev-la de maneira mais clara:

((6%2)*5)+(4/2)+88-10
Dicas de programao:
1. Para evitar confuso na avaliao de suas expresses matemticas, deixe-as o
mais simples possvel e use parnteses.

16. Exerccios
16.1. Declarar e mostrar variveis

44

Dada a tabela abaixo, declare as variveis que se seguem de acordo com seus tipos correspondentes
e valores iniciais. Exiba o nomes e valor das variveis.

O resultado esperado do exerccio :

number = 10
letter = a
result = true
str = hello
16.2. Obter a mdia entre trs nmeros
Crie um programa que obtenha a mdia de 3 nmeros. Considere o valor para os trs nmeros como
sendo 10, 20 e 45. O resultado esperado do exerccio :

nmero 1 com o valor 10


nmero 2 com o valor 20
nmero 3 com o valor 45
A mdia 25
16.3. Exibir o maior valor
Dados trs nmeros, crie um programa que exiba na tela o maior dentre os nmeros informados.
Use o operador ?: que j foi estudado nesta sesso (dica: ser necessrio utilizar dois operadores ?:
para se chegar ao resultado). Por exemplo, dados os nmeros 10, 23 e 5, o resultado esperado do
exerccio deve ser:

nmero 1 com o valor 10


nmero 2 com o valor 23
nmero 3 com o valor 5
O maior nmero 23
16.4. Precedncia de operadores
Dadas as expresses abaixo, reescreva-as utilizando parnteses de acordo com a forma como elas
so interpretadas pelo compilador.

1. a / b ^ c ^ d e + f g * h + i
2. 3 * 10 *2 / 15 2 + 4 ^ 2 ^ 2

45

3. r ^ s * t / u v + w ^ x y++

46

Lio 3
1. Objetivos
Agora que j estudamos alguns conceitos bsicos e escrevemos alguns cdigos simples, vamos fazer
as aplicaes ficarem mais interativas comeando com a captura de dados digitados pelo usurio.
Nesta lio, discutiremos trs modos de obter dados de entrada (input). O primeiro atravs do uso
da classe BufferedReader do pacote java.util; o segundo, atravs do uso da nova classe Scanner no
mesmo pacote; e, por fim, envolveremos a utilizao da interface grfica utilizando JOptionPane.
Ao final desta lio, o estudante ser capaz de:
Criar cdigos para a captura de dados pelo teclado.
Usar a classe BufferedReader para captura, atravs de uma janela de console, dos dados digitados
no teclado.
Utilizar a classe Scanner para captura, atravs de uma janela de console, dos dados digitados no
teclado.
Utilizar a classe JOptionPane para captura, atravs da uma interface grfica, dos dados digitados no
teclado.

2. BufferedReader para capturar dados


Primeiramente, utilizaremos a classe BufferedReader do pacote java.io para capturar dados de
entrada atravs do teclado. Passos para capturar os dados digitados, tomemos por base o programa
visto na lio anterior:
1. Digite a seguinte instruo no incio do programa:
import java.io.*;
2. Adicione as seguintes instrues no corpo do mtodo main:
BufferedReader dataIn = new BufferedReader(
new InputStreamReader(System.in));
3. Declare uma varivel temporria do tipo String para gravar os dados digitados pelo usurio e
chame o mtodo readLine() que vai capturar linha por linha do que o usurio digitar.
Isso dever ser escrito dentro de um bloco try - catch para tratar possveis excees.
try {
String temp = dataIn.readLine();
} catch (IOException e) {
System.out.println("Error in getting input");
}
Abaixo, segue o programa completo:
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
public class GetInputFromKeyboard {
public static void main(String[] args) {
BufferedReader dataIn = new BufferedReader(new InputStreamReader(System.in));
String name = "";
System.out.print("Please Enter Your Name:");

47

try {
name = dataIn.readLine();
} catch (IOException e) {
System.out.println("Error!");
}
System.out.println("Hello " + name +"!");
}
}
Faremos uma anlise deste programa linha por linha:
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
Estas linhas acima mostram que estamos utilizando as classes BufferedReader, InputStreamReader e
IOException cada qual dentro do pacote java.io. Essas APIs ou Interfaces de Programao de
Aplicaes (Application Programming Interface) contm centenas de classes pr-definidas que se
pode usar nos programas. Essas classes so organizadas dentro do que chamamos de pacotes.
Pacotes contm classes que se relacionam com um determinado propsito. No exemplo, o pacote
java.io contm as classes que permitem capturar dados de entrada e sada. Estas linhas poderiam
ser reescritas da seguinte forma:
import java.io.*;
que importar todas as classes encontradas no pacote java.io, deste modo possvel utilizar todas
classes desse pacote no programa.
As prximas linhas:
public class GetInputFromKeyboard {
public static void main( String[] args ) {
j foram discutidas na lio anterior. Isso significa que declaramos uma classe nomeada
GetInputFromKeyboard e, em seguida, iniciamos o mtodo principal (main).
Na instruo:
BufferedReader dataIn = new BufferedReader(new InputStreamReader(System.in));
declaramos a varivel dataIn do tipo BufferedReader. No se preocupe com o significado da sintaxe,
pois ser abordado mais frente.
A seguir, declaramos a varivel name do tipo String:
String name = "";
na qual armazenaremos a entrada de dados digitada pelo usurio. Note que foi inicializada como
uma String vazia "". uma boa prtica de programao inicializar as variveis quando declaradas.
Na prxima instruo, solicitamos que o usurio escreva um nome:
System.out.print("Please Enter Your Name:");

48

As seguinte linhas definem um bloco try - catch:


try {
name = dataIn.readLine();
} catch (IOException e) {
System.out.println("Error!");
}
que asseguram, caso ocorram excees sero tratadas. Falaremos sobre o tratamento de excees
na ltima parte deste curso. Por hora, necessrio adicionar essas linhas para utilizar o mtodo
readLine() e receber a entrada de dados do usurio.
Em seguida:
name = dataIn.readLine();
capturamos a entrada dos dados digitados pelo usurio e as enviamos para a varivel String criada
anteriormente. A informao guardada na varivel name.
Como ltima instruo:
System.out.println("Hello " + name + "!");
montamos a mensagem final para cumprimentar o usurio.

3. Classe Scanner para capturar dados


Vimos uma maneira para obter dados de entrada atravs do teclado. O JDK 5.0 lanou uma nova
classe chamada Scanner que engloba diversos mtodos para facilitar este servio.
Abaixo, segue o programa completo utilizando esta classe:
import java.util.Scanner;
public class GetInputFromScanner{
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("Please Enter Your Name:");
String name = sc.next();
System.out.println("Hello " + name +"!");
}
}
Compare-o com o programa visto anteriormente. Percebe-se que fica mais simples conseguir amesma funcionalidade. Inicialmente, definimos a chamada ao pacote que contm a classe Scanner:
import java.util.Scanner;
Em seguida, as instrues que define a classe e o mtodo main:
public class GetInputFromScanner{
public static void main(String[] args) {

49

Definimos uma varivel, denominada sc, que ser criada a partir da classe Scanner e direcionada
para a entrada padro:
Scanner sc = new Scanner(System.in);
De forma semelhante, mostramos uma mensagem solicitando informao do usurio:
System.out.println("Please Enter Your Name:");
Utilizamos a varivel sc para chamarmos o mtodo que far o recebimento dos dados digitados:
String name = sc.nextLine();
A classe Scanner possui diversos mtodos que podem ser utilizados para realizar este servio. Os
principais mtodos que podemos utilizar, neste caso, so:
Mtodo
next()
nextInt()
nextByte()
nextLong()
nextFloat()
nextDouble()

Finalidade
Aguarda uma
Aguarda uma
Aguarda uma
Aguarda uma
Aguarda uma
Aguarda uma

entrada
entrada
entrada
entrada
entrada
entrada

em
em
em
em
em
em

formato
formato
formato
formato
formato
formato

String
Inteiro
Inteiro
Inteiro Longo
Nmero Fracionrio
Nmero Fracionrio

Tabela 1: Mtodos da Classe Scanner para obter dados

Por fim, mostramos o resultado e encerramos o mtodo main e a classe:


System.out.println("Hello " + name +"!");
}
}

4. Utilizando a JOptionPane para receber dados


Um outro modo de receber os dados de entrada utilizar a classe JOptionPane, que pertence ao
pacote javax.swing. A JOptionPane possui mtodos que conseguem criar caixas de dilogo na qual o
usurio pode informar ou visualizar algum dado.
Dado o seguinte cdigo:
import javax.swing.JOptionPane;
public class GetInputFromKeyboard {
public static void main( String[] args ){
String name = "";
name = JOptionPane.showInputDialog("Please enter your name");
String msg = "Hello " + name + "!";
JOptionPane.showMessageDialog(null, msg);
}
}
esta classe apresentar o seguinte resultado:

50

Figura 1: Aguardando dados no JOptionPane

Figura 2: Digitando florence no JOptionPane

A primeira instruo:
import javax.swing.JOptionPane;
mostra que estamos importando a classe JOptionPane do pacote javax.swing. Poderamos, de forma
semelhante, escrever estas instrues do seguinte modo:
import javax.swing.*;
A instruo seguinte:
name = JOptionPane.showInputDialog("Please enter your name");
cria uma caixa de entrada que exibir um dilogo com uma mensagem, um campo de texto para
receber os dados do usurio e um boto OK, conforme mostrado na figura 1. O resultado ser
armazenado na varivel do tipo String name.
Na prxima instruo, criamos uma mensagem de cumprimento, que ficar armazenada na varivel
msg:
String msg = "Hello " + name + "!";
Finalizando a classe, exibiremos uma janela de dilogo que conter a mensagem e o boto de OK,
conforme mostrado na figura 3.
JOptionPane.showMessageDialog(null, msg);

5. Exerccios
5.1. As 3 palavras (verso Console)
Utilizando a classe BufferedReader ou Scanner, capture trs palavras digitadas pelo usurio e
mostre-as como uma nica frase na mesma linha. Por exemplo:

51

Palavra
Palavra
Palavra
Goodbye

1: Goodbye
2: and
3: Hello
and Hello

5.2. As 3 palavras (verso Interface Grfica)


Utilizando a classe JOptionPane, capture palavras em trs caixas de dilogos distintas e mostre-as
como uma nica frase. Por exemplo:

Figura 4: Primeira Palavra

Figura 5: Segunda Palavra

Figura 6: Terceira Palavra

Figura 7: Mostrando a Mensagem

52

Lio 4

1. Objetivos

Nas lies anteriores, foram mostrados programas sequenciais, onde as instrues foram executadas
uma aps a outra de forma fixa. Nesta lio, discutiremos estruturas de controle que permitem
mudar a ordem na qual as instrues so executadas.
Ao final desta lio, o estudante ser capaz de:
Usar estruturas de controle de deciso (if e switch) que permitem a seleo de partes especficas
do cdigo para execuo
Usar estruturas de controle de repetio (while, do - while e for) que permitem a repetio da
execuo de partes especficas do cdigo
Usar declaraes de interrupo (break, continue e return) que permitem o redirecionamento do
fluxo do programa

2. Estruturas de controle de deciso


Estruturas de controle de deciso so instrues em linguagem Java que permitem que blocos
especficos de cdigo sejam escolhidos para serem executados, redirecionando determinadas partes
do fluxo do programa.

2.1. Declarao if
A declarao if especifica que uma instruo ou bloco de instrues seja executado se, e somente
se, uma expresso lgica for verdadeira. A declarao if possui a seguinte forma:
if (expresso_lgica)
instruo;
ou:
if (expresso_lgica) {
instruo1;
instruo2
...
}
onde, expresso_lgica representa uma expresso ou varivel lgica.

53

Figura 1: Fluxograma da declarao

If

Por exemplo, dado o trecho de cdigo:


int grade = 68;
if (grade > 60) System.out.println("Congratulations!");
ou:
int grade = 68;
if (grade > 60) {
System.out.println("Congratulations!");
System.out.println("You passed!");
}

Dicas de programao:
1. Expresso lgica uma declarao que possui um valor lgico. Isso significa que a execuo
desta expresso deve resultar em um valor true ou false.
2. Coloque as instrues de forma que elas faam parte do bloco if. Por exemplo:
if (expresso_lgica) {
// instruo1;
// instruo2;
}

2.2. Declarao if - else


A declarao if - else usada quando queremos executar determinado conjunto de instrues se a
condio for verdadeira e outro conjunto se a condio for falsa.
Possui a seguinte forma:

54

if (expresso_lgica)
instruo_caso_verdadeiro;
else
instruo_caso_falso;
Tambm podemos escrev-la na forma abaixo:
if (expresso_lgica) {
instruo_caso_verdadeiro1;
instruo_caso_verdadeiro2;
...
} else {
instruo_caso_falso1;
instruo_caso_falso2;
...
}
Por exemplo, dado o trecho de cdigo:
int grade = 68;
if (grade > 60)
System.out.println("Congratulations! You passed!");
else
System.out.println("Sorry you failed");
ou:
int grade = 68;
if (grade > 60) {
System.out.print("Congratulations! ");
System.out.println("You passed!");
} else {
System.out.print("Sorry ");
System.out.println("you failed");
}

55

Figura 2: Fluxograma da declarao if - else

Dicas de programao:
1. Para evitar confuso, sempre coloque a instruo ou instrues contidas no bloco if ou
entre chaves {}.
2. Pode-se ter declaraes if - else dentro de declaraes if - else, por exemplo:
if (expresso_lgica) {
if (expresso_lgica) {
...
} else {
...
}
} else {
...
}

if - else

2.3. Declarao if - else - if


A declarao else pode conter outra estrutura if - else. Este cascateamento de estruturas permite ter
decises lgicas muito mais complexas.
A declarao if - else - if possui a seguinte forma:
if (expresso_lgica1)
instruo1;
else if(expresso_lgica2)
instruo2;
else
instruo3;
Podemos ter vrias estruturas else - if depois de uma declarao if. A estrutura else opcional e
pode ser omitida. No exemplo mostrado acima, se a expresso_lgica1 verdadeira, o programa
executa a instruo1 e salta as outras instrues. Caso contrrio, se a expresso_lgica1 falsa, o
fluxo de controle segue para a anlise da expresso_lgica2.
Se esta for verdadeira, o programa executa a instruo2 e salta a instruo3. Caso contrrio, se a
expresso_lgica2 falsa, ento a instruo3 executada.

56

Figura 3: Fluxograma da declarao if - else - if

Observe um exemplo da declarao if - else - if no seguinte trecho de cdigo:


public class Grade {
public static void main( String[] args ) {
double grade = 92.0;
if (grade >= 90) {
System.out.println("Excellent!");
} else if((grade < 90) && (grade >= 80)) {
System.out.println("Good job!");
} else if((grade < 80) && (grade >= 60)) {
System.out.println("Study harder!");
} else {
System.out.println("Sorry, you failed.");
}
}
}

2.4. Erros comuns na utilizao da declarao if


1. A condio na declarao if no avalia um valor lgico. Por exemplo:
// ERRADO
int number = 0;
if (number) {
// algumas instrues aqui
}

57

a varivel number no tem valor lgico.


2. Usar = (sinal de atribuio) em vez de == (sinal de igualdade) para comparao. Por exemplo:
// ERRADO
int number = 0;
if (number = 0) {
// algumas instrues aqui
}
3. Escrever elseif em vez de else if.
// ERRADO
int number = 0;
if (number == 0)
// algumas
} elseif (number
// algumas
}

{
instrues aqui
== 1) {
instrues aqui

2.5. Declarao switch


Outra maneira de indicar uma condio atravs de uma declarao switch. A construo switch
permite que uma nica varivel inteira tenha mltiplas possibilidades de finalizao.
A declarao switch possui a seguinte forma:
switch (varivel_inteira) {
case valor1:
instruo1; //
instruo2; // bloco 1
... //
break;
case valor2:
instruo1; //
instruo2; // bloco 2
... //
break;
default:
instruo1; //
instruo2; // bloco n
... //
break;
}
onde, varivel_inteira uma varivel de tipo byte, short, char ou int. valor1, valor2, e assim por
diante, so valores constantes que esta varivel pode assumir.
Quando a declarao switch encontrada, o fluxo de controle avalia inicialmente a varivel_inteira e
segue para o case que possui o valor igual ao da varivel. O programa executa todas instrues a
partir deste ponto, mesmo as do prximo case, at encontrar uma instruo break, que interromper a execuo do switch.

58

Se nenhum dos valores case for satisfeito, o bloco default ser executado. Este um bloco opcional.
O bloco default no obrigatrio na declarao switch.

Notas:
1. Ao contrrio da declarao if, mltiplas instrues so executadas sem a necessidade das
chaves que determinam o incio e trmino de bloco {}.
2. Quando um case for selecionado, todas as instrues vinculadas ao case sero executadas.
Alm disso, as instrues dos case seguintes tambm sero executadas.
3. Para prevenir que o programa execute instrues dos outros case subsequentes, utilizamos a
declarao break aps a ltima instruo de cada case.

Dicas de Programao:
1. A deciso entre usar uma declarao if ou switch subjetiva. O programador pode decidir com
base na facilidade de entendimento do cdigo, entre outros fatores.
2. Uma declarao if pode ser usada para decises relacionadas a conjuntos, escalas de variveis
ou condies, enquanto que a declarao switch pode ser utilizada para situaes que envolvam
varivel do tipo inteiro. Tambm necessrio que o valor de cada clusula case seja nico.

59

Figura 4: Fluxograma da declarao switch

2.6. Exemplo para switch


public class Grade {
public static void main(String[] args) {
int grade = 92;
switch(grade) {
case 100:
System.out.println("Excellent!");
break;
case 90:
System.out.println("Good job!");
break;
case 80:
System.out.println("Study harder!");
break;
default:
System.out.println("Sorry, you failed.");
}
}
}

60

Compile e execute o programa acima e veremos que o resultado ser:


Sorry, you failed.
pois a varivel grade possui o valor 92 e nenhuma das opes case atende a essa condio. Note
que para o caso de intervalos a declarao if - else - if mais indicada.

3. Estruturas de controle de repetio


Estruturas de controle de repetio so comandos em linguagem Java que permitem executar partes
especficas do cdigo determinada quantidade de vezes. Existem 3 tipos de estruturas de controle de
repetio: while, do - while e for.

3.1. Declarao while


A declarao while executa repetidas vezes um bloco de instrues enquanto uma determinada condio lgica for verdadeira.
A declarao while possui a seguinte forma:
while (expresso_lgica) {
instruo1;
instruo2;
...
}

Figura 5: Fluxograma da declarao while

As instrues contidas dentro do bloco while so executadas repetidas vezes enquanto o valor de
expresso_lgica for verdadeira.
Por exemplo, dado o trecho de cdigo:

61

int i = 4;
while (i > 0){
System.out.print(i);
i--;
}
O cdigo acima ir imprimir 4321 na tela. Se a linha contendo a instruo i - - for removida, teremos
uma repetio infinita, ou seja, um cdigo que no termina. Portanto, ao usar laos while, ou
qualquer outra estrutura de controle de repetio, tenha a certeza de utilizar uma estrutura de
repetio que encerre em algum momento.
Abaixo, temos outros exemplos de declaraes while:
Exemplo 1:
int x = 0;
while (x<10) {
System.out.println(x);
x++;
}
Exemplo 2:
// lao infinito
while (true)
System.out.println("hello");
Exemplo 3:
// a instruo do lao no ser executada
while (false)
System.out.println("hello");

3.2. Declarao do - while


A declarao do - while similar ao while. As instrues dentro do lao do - while sero executadas
pelo menos uma vez.
A declarao do - while possui a seguinte forma:
do {
instruo1;
instruo2;
...
} while (expresso_lgica);

62

Figura 6: Fluxograma da declarao do - while

Inicialmente, as instrues dentro do lao do - while so executadas. Ento, a condio na


expresso_lgica avaliada. Se for verdadeira, as instrues dentro do lao do - while sero
executadas novamente. A diferena entre uma declarao while e do - while que, no lao while, a
avaliao da expresso lgica feita antes de se executarem as instrues nele contidas enquanto
que, no lao do - while, primeiro se executam as instrues e depois realiza-se a avaliao da
expresso lgica, ou seja, as instrues dentro em um lao do - while so executadas pelo menos
uma vez.
Abaixo, temos alguns exemplos que usam a declarao do - while:
Exemplo 1:
int x = 0;
do {
System.out.println(x);
x++;
} while (x<10);
Este exemplo ter 0123456789 escrito na tela.
Exemplo 2:
// lao infinito
do {
System.out.println("hello");
} while(true);
Este exemplo mostrar a palavra hello escrita na tela infinitas vezes.
Exemplo 3:
// Um lao executado uma vez
do
System.out.println(hello);
while (false);
Este exemplo mostrar a palavra hello escrita na tela uma nica vez.

Dicas de programao:
1. Erro comum de programao ao utilizar o lao do - while esquecer o ponto-evrgula
(;) aps a declarao while.
do {
...
} while (boolean_expression) // ERRADO -> faltou ;
2. Como visto para a declarao while, tenha certeza que a declarao do - while
poder terminar em algum momento.

3.3. Declarao for


A declarao for, como nas declaraes anteriores, permite a execuo do mesmo cdigo uma
quantidade determinada de vezes.

63

A declarao for possui a seguinte forma:


for (declarao_inicial; expresso_lgica; salto) {
instruo1;
instruo2;
...
}
onde:

declarao_inicial inicializa uma varivel para o lao


expresso_lgica compara a varivel do lao com um valor limite
salto atualiza a varivel do lao

Figura 7: Fluxograma da declarao for

Um exemplo para a declarao for :


for (int i = 0; i < 10; i++) {
System.out.print(i);
}
Neste exemplo, uma varivel i, do tipo int, inicializada com o valor zero. A expresso lgica "i
menor que 10" avaliada. Se for verdadeira, ento a instruo dentro do lao executada. Aps

64

isso, a expresso i ter seu valor adicionado em 1 e, novamente, a condio lgica ser avaliada.
Este processo continuar at que a condio lgica tenha o valor falso.
Este mesmo exemplo, utilizando a declarao while, mostrado abaixo:
int i = 0;
while (i < 10) {
System.out.print(i);
i++;
}

4. Declaraes de Interrupo
Declaraes de interrupo permitem que redirecionemos o fluxo de controle do programa. A
linguagem Java possui trs declaraes de interrupo. So elas: break, continue e return.

65

4.1. Declarao break


A declarao break possui duas formas: unlabeled (no identificada - vimos esta forma com a
declarao switch) e labeled (identificada).
4.1.1. Declarao unlabeled break
A forma unlabeled de uma declarao break encerra a execuo de um switch e o fluxo de controle
transferido imediatamente para o final deste. Podemos tambm utilizar a forma para terminar
declaraes for, while ou do - while.
Por exemplo:
String names[] = {"Beah", "Bianca", "Lance", "Belle",
"Nico", "Yza", "Gem", "Ethan"};
String searchName = "Yza";
boolean foundName = false;
for (int i=0; i < names.length; i++) {
if (names[i].equals(searchName)) {
foundName = true;
break;
}
}
if (foundName) {
System.out.println(searchName + " found!");
} else {
System.out.println(searchName + " not found.");
}

Neste exemplo, se a String Yza for encontrada, a declarao for ser interrompida e o controle do
programa ser transferido para a prxima instruo abaixo da declarao for.
4.1.2. Declarao labeled break
A forma labeled de uma declarao break encerra o processamento de um lao que identificado
por um label especificado na declarao break.
Um label, em linguagem Java, definido colocando-se um nome seguido de dois-pontos, como por
exemplo:
teste:
esta linha indica que temos um label com o nome teste.
O programa a seguir realiza uma pesquisa de um determinado valor em um array bidimensional.
Dois laos so criados para percorrer este array. Quando o valor encontrado, um labeled break
termina a execuo do lao interno e retorna o controle para o lao mais externo.

66

int[][] numbers = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};


int searchNum = 5;
boolean foundNum = false;
searchLabel: for (int i=0; i<numbers.length; i++) {
for (int j=0; j<numbers[i].length; j++) {
if (searchNum == numbers[i][j]) {
foundNum = true;
break searchLabel;
}
} // final do lao j
} // final do lao i
if (foundNum) {
System.out.println(searchNum + " found!");
} else {
System.out.println(searchNum + " not found!");
}

A declarao break, ao terminar a declarao for, no transfere o controle do programa ao final de


seu lao, controlado pela varivel j. O controle do programa segue imediatamente para a declarao
for marcada com o label, neste caso, interrompendo o lao controlado pela varivel i.

4.2. Declarao continue


A declarao continue tem duas formas: unlabeled e labeled. Utilizamos uma declarao continue
para saltar a repetio atual de declaraes for, while ou do - while.
4.2.1. Declarao unlabeled continue
A forma unlabeled salta as instrues restantes de um lao e avalia novamente a expresso lgica
que o controla.
O exemplo seguinte conta a quantidade de vezes que a expresso "Beah" aparece no array.
String names[] = {"Beah", "Bianca", "Lance", "Beah"};
int count = 0;
for (int i=0; i < names.length; i++) {
if (!names[i].equals("Beah")) {
continue; // retorna para a prxima condio
}
count++;
}
System.out.println(count + " Beahs in the list");

4.2.2. Declarao labeled continue

67

A forma labeled da declarao continue interrompe a repetio atual de um lao e salta para a
repetio exterior marcada com o label indicado.
outerLoop: for (int i=0; i<5; i++) {
for (int j=0; j<5; j++) {
System.out.println("Inside for(j) loop"); // mensagem1
if (j == 2)
continue outerLoop;
}
System.out.println("Inside for(i) loop"); // mensagem2
}
Neste exemplo, a mensagem 2 nunca ser mostrada, pois a declarao continue outerloop interromper este lao cada vez que j atingir o valor 2 do lao interno.

4.3. Declarao return


A declarao return utilizada para sair de um mtodo. O fluxo de controle retorna para a
declarao que segue a chamada do mtodo original. A declarao de retorno possui dois modos: o
que retorna um valor e o que no retorna nada.
Para retornar um valor, escreva o valor (ou uma expresso que calcula este valor) depois da palavra
chave return. Por exemplo:
return ++count;
ou
return "Hello";
Os dados so processados e o valor devolvido de acordo com o tipo de dado do mtodo. Quando
um mtodo no tem valor de retorno, deve ser declarado como void. Use a forma de return que no
devolve um valor. Por exemplo:
return;
Abordaremos as declaraes return nas prximas lies, quando falarmos sobre mtodos.

5. Exerccios
5.1. Notas
Obtenha do usurio trs notas de exame e calcule a mdia dessas notas. Reproduza a mdia dos
trs exames. Junto com a mdia, mostre tambm um :-) no resultado se a mdia for maior ou igual
a 60; caso contrrio mostre :-(
Faa duas verses deste programa:

68

1. Use a classe BufferedReader (ou a classe Scanner) para obter as notas do usurio, e System.out
para mostrar o resultado.
2. Use JOptionPane para obter as notas do usurio e para mostrar o resultado.

5.2. Nmero por Extenso


Solicite ao usurio para digitar um nmero, e mostre-o por extenso. Este nmero dever variar entre
1 e 10. Se o usurio introduzir um nmero que no est neste intervalo, mostre:
"nmero invlido".
Faa duas verses deste programa:
1. Use uma declarao if - else - if para resolver este problema
2. Use uma declarao switch para resolver este problema

5.3. Cem vezes


Crie um programa que mostre seu nome cem vezes. Faa trs verses deste programa:
1. Use uma declarao while para resolver este problema
2. Use uma declarao do - while para resolver este problema
3. Use uma declarao for para resolver este problema

5.4. Potncias
Receba como entrada um nmero e um expoente. Calcule este nmero elevado ao expoente.
Faa trs verses deste programa:
1. Use uma declarao while para resolver este problema
2. Use uma declarao do - while para resolver este problema
3. Use uma declarao for para resolver este problema

69

Lio 5
1. Objetivos
Nesta lio, abordaremos Array em Java. Primeiro, definiremos o que array e, ento, discutiremos
como declar-los e us-los.
Ao final desta lio, o estudante ser capaz de:
Declarar e criar array
Acessar elementos de um array
Determinar o nmero de elementos de um array
Declarar e criar array multidimensional

2. Introduo a Array
Em lies anteriores, discutimos como declarar diferentes variveis usando os tipos de dados
primitivos. Na declarao de variveis, frequentemente utilizamos um identificador ou um nome e
um tipo de dados. Para se utilizar uma varivel, deve-se cham-la pelo nome que a identifica.
Por exemplo, temos trs variveis do tipo int com diferentes identificadores para cada varivel:
int number1;
int number2;
int number3;
number1 = 1;
number2 = 2;
number3 = 3;
Como se v, inicializar e utilizar variveis pode torna-se uma tarefa tediosa, especialmente se elas
forem utilizadas para o mesmo objetivo. Em Java, e em outras linguagens de programao, pode-se
utilizar uma varivel para armazenar e manipular uma lista de dados com maior eficincia. Este tipo
de varivel chamado de array.
Um array armazena mltiplos itens de um mesmo tipo de dado em um bloco contnuo de memria,
dividindo-o em certa quantidade de posies. Imagine um array como uma varivel esticada que
tem um nome que a identifica e que pode conter mais de um valor para esta mesma varivel.

Figura 1: Exemplo de um array de inteiros

3. Declarando Array

70

Array precisa ser declarados como qualquer varivel. Ao declarar


um array, defina o tipo de dados deste seguido por colchetes []
e pelo nome que o identifica. Por exemplo:
int [] ages;
ou colocando os colchetes depois do identificador. Por exemplo:
int ages[];
Depois da declarao, precisamos criar o array e especificar seu
tamanho. Este processo chamado de construo (a palavra,
em orientao a objetos, para a criao de objetos). Para se construir um objeto, precisamos utilizar
um construtor. Por exemplo:

// declarao
int ages[];
// construindo
ages = new int[100];
ou, pode ser escrito como:
// declarar e construir
int ages[] = new int[100];
No exemplo, a declarao diz ao compilador Java que o identificador ages ser usado como um
nome de um array contendo inteiros, usado para criar, ou construir, um novo array contendo 100
ele- mentos.
Em vez de utilizar uma nova linha de instruo para construir um array, tambm possvel
automaticamente declarar, construir e adicionar um valor uma nica vez.
Exemplos:
// criando um array de valores lgicos em uma
// results. Este array contm 4 elementos que
// inicializados com os valores {true, false,
boolean results[] ={ true, false, true, false

varivel
so
true, false}
};

// criando um array de 4 variveis double inicializados


// com os valores {100, 90, 80, 75};
double []grades = {100, 90, 80, 75};
// criando um array de Strings com identificador days e
// tambm j inicializado. Este array contm 7 elementos
String days[] = {"Mon","Tue","Wed","Thu","Fri","Sat","Sun"};
Uma vez que tenha sido inicializado, o tamanho de um array no pode ser modificado, pois
armazenado em um bloco contnuo de memria.

4. Acessando um elemento do Array

71

Para acessar um elemento do array, ou parte de um array, utiliza-se um nmero inteiro chamado de
ndice. Um ndice atribudo para cada membro de um array, permitindo ao programa e ao
programador acessar os valores individualmente quando necessrio. Os nmeros dos ndices so
sempre inteiros. Eles comeam com zero e progridem sequencialmente por todas as posies at o
fim do array. Lembre-se que os elementos dentro do array possuem ndice de 0 a tamanhoDoArray 1.
Por exemplo, dado o array ages que declaramos anteriormente, temos:
// atribuir 10 ao primeiro elemento do array
ages[0] = 10;
// imprimir o ltimo elemento do array
System.out.print(ages[99]);
Lembre-se que o array, uma vez declarado e construdo, ter o valor de cada membro
inicializado automaticamente. Conforme a seguinte tabela:

Tipo primitivo

Iniciado com

boolean

false

byte, short e int


char

0
'\u0000'

long

0L

float

0.0F

double

0.0

Tabela 1: Valor de inicializao automatica para os tipos primitivos

Entretanto, tipos de dados por referncia, como as Strings, no sero inicializados caracteres em
branco ou com uma string vazia "", sero inicializados com o valor null. Deste modo, o ideal
preencher os elementos do arrays de forma explcita antes de utiliz-los. A manipulao de objetos
nulos pode causar a desagradvel surpresa de uma exceo do tipo NullPointerException, por
exemplo, ao tentar executar algum mtodo da classe String, conforme o exemplo a seguir:
public class ArraySample {
public static void main(String[] args){
String [] nulls = new String[2];
System.out.print(nulls[0]); // Linha correta, mostra null
System.out.print(nulls[1].trim()); // Causa erro
}
}

72

O cdigo abaixo utiliza uma declarao for para mostrar todos os elementos de um array.
public class ArraySample {
public static void main(String[] args){
int[] ages = new int[100];
for (int i = 0; i < 100; i++) {
System.out.print(ages[i]);
}
}
}

Dicas de programao:
1. Normalmente, melhor inicializar, ou instanciar, um array logo aps declar-lo.
Por exemplo, a instruo:
int []arr = new int[100];
prefervel, ao invs de:
int [] arr;
arr = new int[100];
2. Os elementos de um array de n elementos tem ndices de 0 a n-1. Note que no existe o elemento arr[n]. A tentativa de acesso a este elemento causar uma exceo do tipo ArrayIndexOu tOfBoundsException, pois o ndice deve ser at n-1.
3. No possvel modificar o tamanho de um array.

5. Tamanho do Array
Para se obter o nmero de elementos de um array, pode-se utilizar o atributo length. O atributo
length de um array retorna seu tamanho, ou seja, a quantidade de elementos. utilizado como no
cdigo abaixo:
nomeArray.length
Por exemplo, dado o cdigo anterior, podemos reescrev-lo como:
public class ArraySample {
public static void main (String[] args) {
int[] ages = new int[100];
for (int i = 0; i < ages.length; i++) {
System.out.print(ages[i]);
}
}
}

Dicas de programao:
1. Quando criar laos com for para o processamento de um array, utilize o campo length como
argumento da expresso lgica. Isto ir permitir ao lao ajustarse, automaticamente para
tamanhos de diferentes arrays.
2. Declare o tamanho dos arrays utilizando variveis do tipo constante para facilitar alteraes
posteriores. Por exemplo:
final int ARRAY_SIZE = 1000; // declarando uma constante
...
int[] ages = new int[ARRAY_SIZE];

73

6. Arrays Multidimensionais
Arrays multidimensionais so implementados como arrays dentro de arrays. So declarados ao
atribuir um novo conjunto de colchetes depois do nome do array. Por exemplo:
// array inteiro de 512 x 128 elementos
int [][] twoD = new int[512][128];
// array de caracteres de 8 x 16 x 24
char [][][] threeD = new char[8][16][24];
// array de String de 4 linhas x 2 colunas
String [][] dogs = {{"terry", "brown"},
{"Kristin", "white"},
{"toby", "gray"},
{"fido", "black"}};
Acessar um elemento em um array multidimensional semelhante a acessar elementos em
um array de uma dimenso. Por exemplo, para acessar o primeiro elemento da primeira linha
do array dogs, escreve-se:
System.out.print(dogs[0][0]);
Isso mostrar a String "terry" na sada padro. Caso queira mostrar todos os elementos deste array,
escreve-se:
for (int i = 0; i < dogs.length; i++) {
for (int j = 0; j < dogs[i].length; j++) {
System.out.print(dogs[i][j] + " ");
}
}

7. Exerccios
7.1. Dias da semana
Criar um array de Strings inicializado com os nomes dos sete dias da semana. Por exemplo: String
days[] = {"Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday",
"Sunday"};
Usando uma declarao while, imprima todo o contedo do array. Faa o mesmo para as declaraes do - while e for.

7.2. Maior nmero


Usando as classes BufferedReader, Scanner ou JOptionPane, solicite 10 nmeros ao usurio. Utilize
um array para armazenar o valor destes nmeros. Mostre o nmero de maior valor.

7.3. Entradas de agenda telefnica

74

Dado o seguinte array multidimensional, que contm as entradas da agenda telefnica:


String entry = {{"Florence", "735-1234", "Manila"},
{"Joyce", "983-3333", "Quezon City"},
{"Becca", "456-3322", "Manila"}};
mostre-as conforme o formato abaixo:
Name : Florence Tel. # :
735-1234
Address: Manila Name :
Joyce
Tel. # : 983-3333
Address: Quezon City Name :
Becca
Tel. # : 456-3322
Address: Manila

75