You are on page 1of 29

Tópico 1.

Estruturas de Decisão
e de Repetição

Algoritmos e Estruturas de Dados 2006-2007 , Gladys Castillo

Estruturas de Decisão
Conjunto de instruções que permitem o controle da
execução, de modo a que o programa possa fazer escolhas

O Java, tal como a maior parte das linguagens de alto


nível apresenta três variantes de estruturas de decisão:

„ Selecção simples (a instrução if)


„ Selecção em alternativa (a instrução if-
if-else)
else
„ Selecção múltipla (a instrução switch-
switch-case)
case

Algoritmos e Estruturas de Dados, 2007-2008 , Gladys Castillo 2

1
Selecção Simples
Permite decidir entre executar ou não um conjunto de
instruções em função do resultado de uma condição

if (condição) {
instruções;
}

condição := expressão lógica

Algoritmos e Estruturas de Dados, 2007-2008 , Gladys Castillo 3

Selecção em alternativa
Escolhe entre dois conjuntos de instruções qual deve ser
executado em função do resultado de uma condição

if (condição) {
instruções se condição verdadeira;
}
else {
instruções se condição falsa;
}

Algoritmos e Estruturas de Dados, 2007-2008 , Gladys Castillo 4

2
Expressão Lógica

O resultado da avaliação de uma expressão lógica é


um valor lógico (booleano):
true (verdadeiro) ou false (falso)

Tipo Memória Valores


Ocupada
boolean 1 bit true ou false

As expressões ló
lógicas constroem-
constroem-se mediante:

„ Operadores relacionais
„ Operadores lógicos
Algoritmos e Estruturas de Dados, 2007-2008 , Gladys Castillo 5

Operadores Relacionais
Operador Operação
Operam sobre operandos
== igual a
(constantes, variáveis, expressões)
!= diferente de
de diferentes tipos
(numé
(numéricos, caracteres) < menor que
e como resultado retornam um <= menor ou igual
valor de tipo lógico > maior que
>= maior ou igual

Exemplos
a b a == b a!=b a < b a<=b a > b a >= b
2 3 false true true true false false
‘a’ ‘d’ false true true true false false
33 33 true false false true false true

Algoritmos e Estruturas de Dados, 2007-2008 , Gladys Castillo 6

3
Precedência dos Operadores Relacionais

„ ( ) sub-expressões entre parêntesis avaliam-se primeiro


(maior nível de precedência)
„ <, <=, >, >=,==, != depois
(menor nível de precedência)

Exemplo: Para a = 31, b = -1, x = 3, y = 2

(a + b - 1) < (x * y) (a + b - 1) < (x * y)
R1
R1 == aa ++ bb R1
R1 == 31
31 ++ (-1)
(-1) == 30
30
R2
R2 == R1
R1 -- 11 R2
R2 == 30
30 -- 11 == 29
29
R3
R3 == xx ** yy R3
R3 == 33 ** 22 == 66
R4
R4 == R2
R2 << R3R3 →
→ resultado
resultado R4
R4 == 29
29 << 66 == falso
falso →
→ resultado
resultado

Algoritmos e Estruturas de Dados, 2007-2008 , Gladys Castillo 7

Exercício (I)

Determine o resultado das seguintes expressões lógicas:

1. (a + b / c) >= (x – y % c)
para a=3, b=5, c=2, x=1 e y=4

2. a – b != x + y
para a=10, b=1, x=5 e y=4

3. (a + b % c ) <= (x * y) + (y % 2)
para a=2, b=7, c=3, x=2, y=1, z=6

Algoritmos e Estruturas de Dados, 2007-2008 , Gladys Castillo 8

4
Operadores Lógicos
Operam sobre operandos Operador Operação
(constantes, variáveis, expressões) && conjunção (AND)
de tipo lógico || disjunção (OR)
e retornam um valor de tipo lógico ! Negação (NOT)

a b a && b a || b !a !b
true true true true false false
true false false true false true
false true false true true false
false false false false true true

Algoritmos e Estruturas de Dados, 2007-2008 , Gladys Castillo 9

Exemplos de Operadores Lógicos


Exemplo do operador AND
ifif ((x
((x <=
<= 5)
5) &&
&& (x
(x >=1))
>=1))
System.out.println(“x
System.out.println(“x está
está entre
entre 11 ee 5”);
5”);
else
else
System.out.println(“x
System.out.println(“x ee maior
maior que
que 55 ouou menor
menor que
que 1”);
1”);

Exemplo do operador OR
ifif ((x
((x >> 5)
5) |||| (x
(x << 1))
1))
System.out.println(“x
System.out.println(“x ee maior
maior que
que 55 ou
ou menor
menor que
que 1”);
1”);
else
else
System.out.println(“x
System.out.println(“x está
está entre
entre 11 ee 5”);
5”);

Algoritmos e Estruturas de Dados, 2007-2008 , Gladys Castillo 10

5
Precedência dos Operadores Lógicos

„ ( ) sub-expressões entre parêntesis avaliam-se primeiro


(maior nível de precedência)
„ &&, ||, ! depois
(menor nível de precedência)

Exemplo: Para x = 3 e y = 6
!(x < 5) && !(y >= 7) !(x < 5) && !(y >= 7)
R1
R1 == xx << 55 R1
R1 == 33 << 55 →
→ verdadeiro
verdadeiro
R2
R2 == yy >=
>= 77 R2
R2 = 6 >= 7 → falso
= 6 >= 7 → falso
R3
R3 == !R2
!R2 R3
R3 == !falso
!falso →→ verdadeiro
verdadeiro
R4
R4 == !R1
!R1 R4
R4 == !verdadeiro
!verdadeiro → → falso
falso
R5
R5 == R4
R4 &&&& R3
R3 →
→ Resultado
Resultado R5
R5 == verdadeiro
verdadeiro &&&& falso
falso == falso
falso

Algoritmos e Estruturas de Dados, 2007-2008 , Gladys Castillo 11

Exercício (II)

Determine o resultado das seguintes expressões lógicas:

1. !((i > 4) || (j <= 6))


para i=10 e j=3

2. !(a + b == c) || (c != 0) && (b - c > = 19)


para a=34, b=12 e c=8

Algoritmos e Estruturas de Dados, 2007-2008 , Gladys Castillo 12

6
Exercício (III)

O quê o seguinte código escreve no ecrã do monitor?

int
int xx == 0,
0, yy == 1,
1, zz == 2;
2;
ifif (((x
(((x !=0)
!=0) &&
&& (y(y ==
== 1))
1)) |||| (z
(z !=
!= 0))
0))
System.out.print("Ganhou");
System.out.print("Ganhou");
else
else
System.out.print("Perdeu");
System.out.print("Perdeu");
System.out.println("
System.out.println(" o prémio");

a. Ganhou b. Perdeu c. Ganhou o prémio d. Perdeu o prémio.

Algoritmos e Estruturas de Dados, 2007-2008 , Gladys Castillo 13

Encadeamento de Vários If-Else


Escolhe entre mais de duas alternativas qual
conjunto de instruções deve ser executado

ifif (condição1)
(condição1) {{
instruções
instruções se se condição1
condição1 verdadeira;
verdadeira;
}} else
else {{
ifif (condição2)
(condição2) {{
instruções
instruções se se condição2
condição2 verdadeira;
verdadeira;
}} else
else { {
ifif (condição3)
(condição3) {{
instruções
instruções se
se condição3
condição3 verdadeira;
verdadeira;
……
else
else {{
instruções
instruções se
se condição
condição falsa;
falsa;
}}

Algoritmos e Estruturas de Dados, 2007-2008 , Gladys Castillo 14

7
Exemplo 1
Idade Bilhete
Inferior a 6 Isento de pagamento

Bilhete Entre 6 e 12
Entre 13 e 65
Bilhete de criança
Bilhete normal
Mais de 65 Bilhete de 3ª idade
idade é uma
variável inteira
ifif (idade
(idade <= <= 5){
5){ //// terá
terá menos
menos de de 66 anos?
anos?
System.out.println
System.out.println ("Isento ("Isento de de pago");
pago");
}} else
else {{ //// terá
terá entre
entre 66 ee 12
12 anos?
anos?
quando usamos ifif (idade
(idade <= 12){<= 12){
apenas uma
instrução por bloco System.out.println
System.out.println ("Bilhete ("Bilhete de de criança");
criança");
podemos tirar as }} else
else {{ //// terá
terá entre
entre 12
12 ee 65
65 anos?
anos?
chavetas, e assim o ifif (idade
(idade <=
<= 65){
65){
programa fica
menos confuso System.out.println
System.out.println ("Bilhete ("Bilhete normal");
normal");
}} else
else {{ //// teráterá mais
mais do
do que
que 6565 anos?
anos?
System.out.println("Bilhete
System.out.println("Bilhete 3ª 3ª idade");
idade");
}} //// fecha
fecha bloco
bloco se se idade
idade >> 65
65
}} //// fecha bloco se idade
fecha bloco se idade > 12 > 12
}} //// fecha
fecha bloco
bloco se
se idade idade >> 55
Algoritmos e Estruturas de Dados, 2007-2008 , Gladys Castillo 15

Exemplo 2
Dado um número do mês retorna qual a estação do ano
mes é uma
variável inteira
ifif (mes
(mes == == 1212 |||| mes
mes == == 11 |||| mes
mes == == 2)2)
System.out.println
System.out.println ("A ("A estação
estação do do ano
ano éé oo Inverno");
Inverno");
else
else ifif (mes
(mes == == 33 |||| mes
mes == == 44 |||| mes
mes ==== 5)
5)
System.out.println
System.out.println ("A ("A estação
estação do do ano
ano éé aa Primaveira");
Primaveira");
else if (mes == 6 || mes == 7
else if (mes == 6 || mes == 7 || mes == 8) || mes == 8)
System.out.println
System.out.println ("A ("A estação
estação do do ano
ano éé oo Verão");
Verão");
else
else ifif (mes
(mes == == 99 |||| mes
mes == == 10
10 |||| mes
mes ==
== 11)
11)
System.out.println
System.out.println ("A ("A estação
estação do do ano
ano éé oo Outono");
Outono");

Em vez de usar
if-
if-then podemos usar a
estrutura de selecção
múltipla switch-
switch-case
Algoritmos e Estruturas de Dados, 2007-2008 , Gladys Castillo 16

8
Selecção Múltipla: Switch-Case
Quando a escolha for feita em função do valor de uma
expressão inteira ou cará
carácter,
cter é mais eficaz utilizar
uma estrutura de switch-case

switch
switch (expressão)
(expressão) {{
case
case valor_1:
valor_1:
instruções;
instruções;
break provoca o fim break;
break;
da instrução,
….
….
evitando que as
instruções das case
case valor_n:
valor_n:
outras opções instruções;
instruções; default é opcional.
sejam executadas break;
break; Caso exista, será
default:
default: executada se nenhum
instruções;
instruções; dos valores for igual
break; ao resultado da
break;
expressão
}}
Algoritmos e Estruturas de Dados, 2007-2008 , Gladys Castillo 17

Implementação de Menus
(usando JOptionPane)
String
String str
str == JOptionPane.showInputDialog(null,
JOptionPane.showInputDialog(null, "Indique
"Indique aa opção:
opção: \n"
\n" ++
"" 11 –– opção
opção 11 \n"
\n" ++


"" nn –– opção
opção nn \n“
\n“ ););
int op = Integer.parseInt(str);
int op = Integer.parseInt(str);
switch
switch (op)
(op) {{
case
case 1: 1:
System.out.println(“Seleccionou
System.out.println(“Seleccionou aa opção
opção 1");
1");
switch-case pode ser break;
break;
usada para implementar …
…..
um menu com várias
opções a escolher pelo case
case n:n:
utilizador. As opções System.out.println(“Seleccionou
System.out.println(“Seleccionou aa opção
opção n");
n");
podem ser números ou
break;
break;
caracteres.
default:
default::
default
System.out.println(“A
System.out.println(“A opção
opção seleccionada
seleccionada está
está incorrecta");
incorrecta");
break;
break;
}}
Algoritmos e Estruturas de Dados, 2007-2008 , Gladys Castillo 18

9
Problema 1: Dias de um mês
Escrever um programa que lê do teclado uma data
composta pelo nº de mês e ano, calcula e imprime
no ecrã o nº de dias desse mês.
Implementar duas versões:
uma usando if-then e a outra usando swicth-case
Ano bissexto: de 4 em 4 anos, com excepção dos finais de século,
que são bissextos de 4 em 4 séculos. Por exemplo, os anos 1600,
1996, 2000, 2004 são bissextos, mas os anos 1700, 1800 ou 1900
não o são.

Algoritmos e Estruturas de Dados, 2007-2008 , Gladys Castillo 19

Problema 1. Especificação

Variável de entrada: mes (número do mês)


valor numérico inteiro entre 1 e 12
ano (ano)
valor numérico positivo
Variável de saída: dias (nº de dias desse mês)
valor numérico positivo ou nulo

Solução:
# Mes # dias
1, 3, 5, 7, 8, 31
10, 12 Ano bissexto: de 4 em 4 anos, com excepção dos finais
de século, que são bissextos de 4 em 4 séculos.
4, 6, 9, 11 30
2 SE (ano bissexto) SE ((ano é múltiplo de 4)
dias = 29 E (ano não é múltiplo de 100))
caso contrario OU (ano é múltiplo de 400)
dias = 28
Algoritmos e Estruturas de Dados, 2007-2008 , Gladys Castillo 20

10
Programa: Dias de um mês (v.1)
(usando if-else e I/O com caixas de dialogo)
import javax.swing.*;
class Cap1Top4Pr1v1DiasMes {
Podemos unir a entrada e conversão
public static void main (String [ ] args) {
em inteiro numa única instrução
int mes, ano, dias;
// entrada de dados
mes = Integer.parseInt (JOptionPane.showInputDialog (null, "Introduza o mes: "));
ano = Integer.parseInt (JOptionPane.showInputDialog (null, "Introduza o ano: "));
// processamento
if ( (mes == 4) || (mes == 9) || (mes == 11) )
dias = 30;
else if (mes == 2)
if ( ((ano % 4 == 0) && !(ano % 100 == 0)) || (ano % 400 == 0) )
dias = 29;
else Ano bissexto
dias = 28;
else
dias = 31;
// saida de resultados
JOptionPane.showMessageDialog (null, "mes: " + mes + "\n" + "ano: " + ano + "\n + "nº dias: " + dias);
} }

Algoritmos e Estruturas de Dados, 2007-2008 , Gladys Castillo 21

Programa: Dias de um mês (v.2)


(usando if-else e I/O pela consola)
import java.io.*;
class Cap1Top4Pr1v2DiasMes{ Não ESQUECER
public static void main(String [ ] args) throws IOException { (estamos a usar readLine)
int mes, ano, dias;
BufferedReader input = new BufferedReader (new InputStreamReader (System.in));

// leitura do mes e ano Podemos unir a declaração do


System.out.print ("Introduza o mes: "); objecto input numa única instrução
mes = Integer.parseInt(input.readLine());
System.out.print ("Introduza o ano: ");
ano = Integer.parseInt(input.readLine());

// processamento usando if-else


if ( (mes == 4) || (mes == 9) || (mes == 11) )
dias = 30;
…..
// saida de resultados
System.out.println ("nº dias: " + dias);
}}

Algoritmos e Estruturas de Dados, 2007-2008 , Gladys Castillo 22

11
Programa: Dias de um mês (v.3)
(usando swith-case e I/O com caixas de diaologo
import javax.swing.*;
class Cap1Top4Pr1v3DiasMes {
public static void main (String [] args) {
int mes, ano, dias;
mes = Integer.parseInt (JOptionPane.showInputDialog (null, "Introduza o mes: "));
ano = Integer.parseInt (JOptionPane.showInputDialog (null, "Introduza o ano: "));
switch (mes) {
case 4:
case 6:
case 9:
case 11:
dias = 30;
break;
Processamento com switch-case
case 2:
if ( ((ano % 4 == 0) && !(ano % 100 == 0)) || (ano % 400 == 0) )
dias = 29;
else
dias = 28;
break;
default:
dias = 31;
}
JOptionPane.showMessageDialog (null, "mes: " + mes + "\n" + "ano: " + ano + "\n + "nº dias: " + dias);
} }
Algoritmos e Estruturas de Dados, 2007-2008 , Gladys Castillo 23

Problema 2

Escrever um programa que permita ao utilizador


seleccionar de um menu uma operação aritmética
(soma, resta, multiplicação ou divisão), introduzir
dois valores para os operandos, e que calcule e
mostre o resultado da operação seleccionada.

Algoritmos e Estruturas de Dados, 2007-2008 , Gladys Castillo 24

12
Programa: Menu de Operações (I)
(entrada usando caixa de dialogo)
import javax.swing.*;
class Cap1Top4Pr2v1MenuAritmetica{
public static void main(String [ ] args) {
int op, num1, num2;
Menu de Operações
char oper = ' ';
double res= 0;
String str = JOptionPane.showInputDialog (null, "Indique a operação: \n" +
" 1 - soma \n" +
entrada de dados

" 2 - resta \n" +


" 3 - multiplicação \n" +
" 4 - divisão \n");
op = Integer.parseInt(str);
if (op >= 1 && op <= 4) {
num1 = Integer.parseInt(JOptionPane.showInputDialog(null, "Introduza o primeiro operando: "));
num2 = Integer.parseInt(JOptionPane.showInputDialog(null, "Introduza o segundo operando: "));
}

Algoritmos e Estruturas de Dados, 2007-2008 , Gladys Castillo 25

Programa: Menu de Operações (II)


(processamento com switch-case)
switch (op){
case 1:
oper = '+';
res = num1 + num2;
break;
case 2:
oper = '-';
res = num1 - num2;
break;
case 3:
oper = '*';
res = num1 * num2;
break;
case 4:
oper = '/';
if (num2 !=0)
res = (double) num1 / num2;
break;
}

Algoritmos e Estruturas de Dados, 2007-2008 , Gladys Castillo 26

13
Programa: Menu de Operações (III)
(saída usando caixa de mensagem)
if (op != 4 || num2 !=0) {
JOptionPane.showMessageDialog (null, "1º operando: " + num1 + "\n" +
"2º operando: " + num2 + "\n" +
"operação: " + num1 + " " + oper + " " + num2 + " = " + res);
}
else
JOptionPane.showMessageDialog (null, " ERRO: divisão por zero ");
} // fecha if (op >= 1 && op <= 4)
else
JOptionPane.showMessageDialog (null, " ERRO: não existe essa operação");
} // close main
} // close class Este é o else caso a operação introduzida for
< 1 e > 4, ou seja estiver incorrecta

Algoritmos e Estruturas de Dados, 2007-2008 , Gladys Castillo 27

Estruturas de Repetição

Algoritmos e Estruturas de Dados 2006-2007 , Gladys Castillo

14
Estruturas de Repetição
As estruturas repetitivas ou ciclos permitem repetir
um conjunto de uma ou mais instruções

O Java apresenta três variantes de ciclos:

„ O ciclo while (pre-validação)


„ O ciclo do … while (post-validação)
„ O ciclo for (contador automático)

Algoritmos e Estruturas de Dados, 2007-2008 , Gladys Castillo 29

O Ciclo while e do … while


Permite repetir um conjunto de uma ou mais
instruções enquanto uma condiç
condição mantiver o
valor lógico verdadeiro

while (condição) { do {
instruções; instruções;
} } while (condição)

condição := expressão lógica

pre-validação:
pre-validação: oo teste
teste da
da post-validação:
post-validação: oo teste
teste da
da
condição feito antes da
condição éé feito da condição
condição só é feito
feito depois
execução
execução das
das instruções
instruções da
da execução
execução das
das instruções
instruções
Algoritmos e Estruturas de Dados, 2007-2008 , Gladys Castillo 30

15
Problema 3

Escrever um programa que leia uma sequencia de


números inteiros positivos introduzidos pelo
teclado, até que apareça o número zero
(indicador de paragem), e que determina e
escreva no monitor o número e a média
dos números lidos

Algoritmos e Estruturas de Dados, 2007-2008 , Gladys Castillo 31

Problema 3: Especificação
Entrada: uma sequencia de números inteiros positivos
introduzidos pelo utilizador.
Cada número é guardado na variável num
(valor numérico inteiro positivo)
Saída: contador – o número de números lidos (valor inteiro)
media - a média dos números lidos (valor real)
Algoritmo:
Inicializar a variável contador e a variável soma com zero
Repetir enquanto houver números
1º. ler o número (guardar na variável num)
num
2º. Incrementar contador
3º. Adicionar num a soma
Fim repetir
Se contador
contador é diferente de zero calcular a média pela fórmula:
media = soma / contador
Imprimir contador
contador e media
Algoritmos e Estruturas de Dados, 2007-2008 , Gladys Castillo 32

16
Problema 3. Pseudo-Código
Inicializar
Inicializar soma
soma comcom 0;0;
Inicializar
Inicializar contador
contador com com 0;
0;
Ler
Ler oo primeiro
primeiro número
número (numnum )) ;;
(num
Antes de testar a Enquanto
Enquanto num num != != 00
condição é preciso
ler o primeiro
Adiciona-lo
Adiciona-lo áá soma
soma ;;
número para poder Incrementar
Incrementar contador
contador emem um um ;;
avaliar a expressão
lógica Ler
Ler oo seguinte
seguinte número
número (num
num )) ;;
(num
Fim
Fim Enquanto
Enquanto ;;
Se
Se (contador !=
(contador
contador != 0)
0)
Calcular
Calcular média
média (( media
media == soma
soma // contador);
contador
contador);
Escrever
Escrever no no ecrã
ecrã oo total
total de
de números
números lidos
lidos (contador
contador);
(contador);
Escrever
Escrever no no ecrã
ecrã aa média
média dos
dos números
números lidos
lidos (media
media);
(media);
caso
caso contrá
contr ário
contrário
Escrever
Escrever aa mensagem
mensagem ““Não
Não foram
foram introduzidos dados”;”;
introduzidos dados

Algoritmos e Estruturas de Dados, 2007-2008 , Gladys Castillo 33

import
import java.io.*;
java.io.*;
import
import java.text.*;
java.text.*; //// para
para usar
usar DecimalFormat
DecimalFormat
class
class Cap1Top4Pr3v1MediaSeqInt
Cap1Top4Pr3v1MediaSeqInt {{
public
public static
static void
void main(String
main(String [][] args)
args) throws
throws IOException{
IOException{
int
int num,
num, soma
soma == 0, 0, contador
contador == 00 ;;
double
double media;
media;
//// criação
criação do
do fluxo
fluxo de
de dados
dados para
para poder
poder ler
ler dados
dados do
do teclado
teclado
BufferedReader
BufferedReader input
input == new
new BufferedReader
BufferedReader (new
(new InputStreamReader
InputStreamReader (System.in));
(System.in));
Problema 3 DecimalFormat
DecimalFormat df
//// entrada
df == new
new DecimalFormat("0.00");
DecimalFormat("0.00"); //// formato
formato dos
dos números
números decimais
decimais
entrada ee processamento
processamento dos
dos dados
dados
Programa (1) System.out.print
System.out.print ("Introduza
("Introduza oo primeiro
primeiro número
número inteiro
inteiro positivo:
positivo: ");
");
num
num == Integer.parseInt
Integer.parseInt (input.readLine()
(input.readLine() ););
while
while (num
(num !=!= 0)
0) {{
Precisamos soma
soma == soma
soma ++ num;
num; //// adiciona
adiciona num
num aa soma
soma
ainda validar
contador
contador == contador
contador ++ 1;1; //// incrementa
incrementa oo contador
contador em
em 11
que o
System.out.print
System.out.print (( "Introduza
"Introduza oo seguinte
seguinte número
número inteiro
inteiro positivo:
positivo: ");
");
número é
não negativo num
num == Integer.parseInt
Integer.parseInt (input.readLine());
(input.readLine());
}}
//// processamento
processamento ee saída
saída de
de resultados
resultados
ifif (contador
(contador !=!= 0)
0) {{
media
media == ((double)
((double) soma)
soma) // contador;
contador;
System.out.println
System.out.println ("Foram
("Foram lidos
lidos "" ++ contador
contador ++ "" números
números inteiros
inteiros positivos.");
positivos.");
System.out.println
System.out.println ("A
("A média
média dos
dos números
números lidos
lidos éé "" ++ df.format
df.format (media)
(media) ););
}} else
else
System.out.println
System.out.println ("Não
("Não foram
foram introduzidos
introduzidos dados");
dados");
}} //// fim
fim main()
main()
}} //// fim
fim class
class Pr_4_1_CalcularMedia
Pr_4_1_CalcularMedia
Algoritmos e Estruturas de Dados, 2007-2008 , Gladys Castillo 34

17
Usando do…while para validar a entrada

enquanto o número é //// entrada


entrada ee processamento
processamento dos
dos dados
dados
negativo vamos do
do {{
continuar a ler um
número do teclado System.out.print
System.out.print ("Introduza
("Introduza oo primeiro
primeiro número
número inteiro positivo:: ");
inteiro positivo ");
num
num == Integer.parseInt
Integer.parseInt (input.readLine()
(input.readLine() ););
}} while
while (num
(num << 0);
0);
Equivalente a:
while
while (num
(num !=
!= 0)
0) {{
soma = soma + num soma
soma +=
+= num;
num; //// adiciona
adiciona num
num aa soma
soma
Equivalente a: contador
contador ++;
++; //// incrementa
incrementa oo contador em 11
contador em
contador=contador + 1 do
do {{
System.out.print
System.out.print (( "Introduza
"Introduza oo seguinte
seguinte número
número inteiro positivo:: ");
inteiro positivo ");
num
num == Integer.parseInt
Integer.parseInt (input.readLine());
(input.readLine());
}} while
while (num
(num << 0);
0);
}}

Algoritmos e Estruturas de Dados, 2007-2008 , Gladys Castillo 35

A palavra chave break

Permite ao programa terminar a execução das instruções


e passa imediatamente o controlo fora do ciclo

//// outra
outra forma
forma de
de validar
validar os
os dados
dados
do
do { {
System.out.print
System.out.print (“ (“ Introduza
Introduza um um número
número inteiro
inteiro positivo:
positivo: ");
");
num
num == Integer.parseInt(input.readLine());
Integer.parseInt(input.readLine());
CUIDADO ao usar ifif (num
(num >= >= 0)
0)
while (true): break;
break;
o ciclo corre
System.out.println("O
System.out.println("O número número tem tem que
que ser
ser inteiro
inteiro positivo
positivo ouou zero
zero ");
");
indefinidamente e só
para quando }} while
while (true);
(true);
encontrar break //// sese oo número
número éé inteiro
inteiro positivo
positivo ou
ou zero,
zero, então
então
//// aa entrada
entrada está
está correcta,
correcta, por
por isso
isso oo ciclo
ciclo termina
termina ee oo programa
programa
//// continua
continua aa execução
execução aqui
aqui aa seguir
seguir dodo break
break

Algoritmos e Estruturas de Dados, 2007-2008 , Gladys Castillo 36

18
Problema 3. Programa Revisto
(versão 2 usando do…while e break)
CICLO EXTERNO //// entrada
entrada ee processamento
processamento dos
dos dados
dados
(para a entrada de do
do {{
números)
PARA se num == 0 //// leitura
leitura ee validação
validação dodo número
número entrada
entrada
do
do {{
System.out.print
System.out.print ("Introduza
("Introduza umum número
número inteiro
inteiro positivo:
positivo: ");
");
CICLO INTERNO num
num == Integer.parseInt
Integer.parseInt (input.readLine()
(input.readLine() ););
(para a validação
de uma entrada) ifif (num
(num >=>= 0)0)
PARA se a entrada break;
break;
é correcta, i.e.,
System.out.println
System.out.println ("O ("O número
número temtem que
que ser
ser inteiro
inteiro positivo
positivo ouou zero
zero ");
");
se num >= 0
}} while
while (true);
(true);
//// continua
continua depois
depois do
do break
break do
do ciclo
ciclo interno
interno
ifif (num
(num == == 0)
0)
break;
break; //// criterio
criterio de
de paragem
paragem da
da entrada
entrada
soma
soma += num; += num;
contador++;
contador++;
}} while
while (true);(true);

Algoritmos e Estruturas de Dados, 2007-2008 , Gladys Castillo 37

while versus do…while


Normalmente do…while é mais utilizado que while.
Mas, em princípio, qualquer problema que possa ser resolvido
usando do…while pode também ser resolvido usando while.

fazerAlgo;
fazerAlgo; do
do
while
while (( condição
condição )) {{ fazerAlgo
fazerAlgo }}
{{ fazerAlgo
fazerAlgo };
}; while
while (( condição
condição ))

while
while (( condição
condição )) ifif (( condição
condição ))
{{ fazerAlgo
fazerAlgo };
}; do
do
{{ fazerAlgo
fazerAlgo };};
while
while (( condição
condição ))

Algoritmos e Estruturas de Dados, 2007-2008 , Gladys Castillo 38

19
Erros na entrada de dados
O que acontece se introduzirmos, por exemplo, “ai” em
vez de um número inteiro, como é requerido?
do
do {{
System.out.print
System.out.print (“ (“ Introduza
Introduza um
um número
número inteiro
inteiro positivo:
positivo: ");
");
num
num == Integer.parseInt
Integer.parseInt (input.readLine()
(input.readLine() ););
ifif (num
(num >=>= 0)
0)
break;
break;
System.out.println("O
System.out.println("O númeronúmero tem
tem que
que ser
ser inteiro
inteiro positivo
positivo ou
ou zero
zero ");
");
}} while
while (true);
(true);

O programa interrompe a sua


Introduza um número inteiro positivo: ai execução ao tratar de executar
o método Integer.parseInt.
NumberFormatException: For input string: "ai"
Acontece um erro de conversão
at java.lang.NumberFormatException.forInputString(Unknown Source) pois estamos a converter um
string que não é um número
at java.lang.Integer.parseInt(Unknown Source)
para um número inteiro
at java.lang.Integer.parseInt(Unknown Source)
….
Algoritmos e Estruturas de Dados, 2007-2008 , Gladys Castillo 39

Capturar Erros usando Excepções


„ O mecanismo de excepções é a forma pela qual o Java
detecta e notifica erros.
„ Uma excepção é uma condição de erro que interrompe o fluxo
do programa
Introduza um número inteiro positivo: ai
NumberFormatException: For input string: "ai"
at java.lang.NumberFormatException.forInputString(Unknown Source)
at java.lang.Integer.parseInt(Unknown Source)
at java.lang.Integer.parseInt(Unknown Source)
….

„ Esta mensagem de erro indica que o sistema capturou uma


excepção chamada NumberFormatException: um erro que
ocorre quando nós tentamos converter uma String que não pode
ser convertida a um valor numérico

Algoritmos e Estruturas de Dados, 2007-2008 , Gladys Castillo 40

20
Usando try-catch para tratar erros
do
do {{
Esta é a única instrução que
System.out.print
System.out.print (“ (“ Introduza
Introduza um
um número
número inteiro
inteiro positivo:
positivo: ");
"); pode lançar uma excepção:
num
num == Integer.parseInt
Integer.parseInt (input.readLine()
(input.readLine() );); a excepção
ifif (num
(num >=>= 0)
0) break;
break; NumberFormatException.
System.out.println("O
System.out.println("O númeronúmero tem
tem que
que ser
ser inteiro
inteiro positivo
positivo ou
ou zero
zero ");
"); Podemos captura-la e tratar
}} while este erro usando try-catch
while (true);
(true);

do
do {{
System.out.print
System.out.print (( ““ Introduza
Introduza um
um número
número inteiro
inteiro positivo:
positivo: ");
");
try
try {{ //// aqui
aqui vai
vai oo código
código que
que pode
pode falhar
falhar
num
num == Integer.parseInt(input.readLine());
Integer.parseInt(input.readLine());
}} catch
catch (Exception
(Exception e){
e){
//// aqui
aqui oo codigo
codigo para
para tratar
tratar oo falho
falho
System.out.println
System.out.println (( "Erro...
"Erro... insira
insira um
um número
número válido...");
válido...");
}}
ifif (num
(num >=
>= 0)
0) break;
break;
System.out.println
System.out.println ("O
("O número
número tem
tem que
que ser
ser inteiro
inteiro positivo
positivo ou
ou zero
zero ");
");
}} while
while (true);
(true);

Algoritmos e Estruturas de Dados, 2007-2008 , Gladys Castillo 41

Exemplo para validar entrada


usando o ciclo while e try-catch
//// para
para poder
poder entrar
entrar no ciclo while
no ciclo while necessitamos
necessitamos inicializar
inicializar aa variável
variável
//// num
num com
com um
um número
número negativo
negativo
int
int num
num == -1;
-1;
while
while (num
(num << 0)
0) {{
System.out.print
System.out.print ("Introduza
("Introduza um
um número
número inteiro
inteiro positivo
positivo ou
ou zero:
zero: ");
");
try
try {{
//// aqui
aqui vai
vai oo codigo
codigo que
que pode
pode falhar
falhar
num
num == Integer.parseInt(input.readLine());
Integer.parseInt(input.readLine());
}} catch
catch (Exception
(Exception e){
e){
//// aqui
aqui oo codigo
codigo para
para tratar
tratar oo falho
falho
System.out.println
System.out.println ("Erro...
("Erro... insira
insira um
um número
número válido...");
válido...");
}}
}}

Algoritmos e Estruturas de Dados, 2007-2008 , Gladys Castillo 42

21
Problema 4

Escrever um programa que primeiro leia quantos


números reais serão introduzidos pelo utilizador e
depois de introduzidos os números, determine e
escreva no monitor a soma dos números lidos

Algoritmos e Estruturas de Dados, 2007-2008 , Gladys Castillo 43

Problema 4: Especificação
Entrada: n - o total de números que serão introduzidos
uma sequencia de n números reais introduzidos pelo
utilizador. Cada número é guardado na variável num
(valor numérico real)
Saída: soma - a soma dos números lidos (valor numérico real)

Algoritmo:
Inicializar o contador i e a variável soma com zero
Ler o total de números para a variável n
Fazer
1º. Incrementar o contador i em 1
2º. Ler o número i para a variável num
3º. Somar num a soma
Enquanto (i < n)
Imprimir soma
Algoritmos e Estruturas de Dados, 2007-2008 , Gladys Castillo 44

22
Problema 4. Programa
(versão 1: usando o ciclo do…while)
import
import java.io.*;
java.io.*;
class
class Cap1Top4Pr4v1SomaSeqInt
Cap1Top4Pr4v1SomaSeqInt {{
Para simplificar os public
public static
static void
void main(String
main(String [[ ]] args)
args) throws
throws IOException
IOException {{
programas vamos double
double num, num, soma
soma == 0;0;
obviar o tratamento int
int n,
n, ii == 0;
0;
de erro com BufferedReader
BufferedReader input input == new
new BufferedReader
BufferedReader (new(new InputStreamReader
InputStreamReader (System.in));
(System.in));
try-catch dodo {{
System.out.print
System.out.print ("Introduza
("Introduza um um número
número inteiro
inteiro positivo:
positivo: ");
");
nn == Integer.parseInt(input.readLine());
Integer.parseInt(input.readLine());
}} while
while (n (n <=0);
<=0);
Este ciclo termina
quando i toma o
valor de n. Podemos do
do {{
reescreve-o usando i++;
i++; //// incrementa
incrementa oo contador
contador
o ciclo for System.out.print
System.out.print (( "Introduza
"Introduza oo "" ++ ii ++ "" número
número :: ");
");
num
num == Double.parseDouble(input.readLine());
Double.parseDouble(input.readLine());
soma
soma += += num;
num; //// Adiciona
Adiciona num
num aa soma
soma
}} while
while (i(i << n);
n);
System.out.println
System.out.println (( "A "A soma
soma dos dos números
números lidos
lidos éé "" ++ soma
soma ););
}} //// fim
fim main()
main()
}}
Algoritmos e Estruturas de Dados, 2007-2008 , Gladys Castillo 45

O Ciclo for
for (inicialização; condição; actualização) {
instruções;
}

„
„ inicialização:
inicialização: inicializa
inicializa aa variável
variável de
de controlo
controlo
„
„ aa variável
variável de
de controlo,
controlo, controla
controla oo número
número de
de vezes
vezes que
que as
as
instruções
instruções vão
vão se
se repetidas
repetidas
„
„ condição:
condição: éé calculada
calculada antes
antes de
de cada
cada execução
execução das
das instruções.
instruções.
„
„ se
se oo seu
seu resultado
resultado for
for verdadeiro,
verdadeiro, as
as instruções
instruções são
são executadas
executadas
„
„ se
se for
for falso,
falso, oo ciclo
ciclo termina
termina
„
„ actualização:
actualização: éé executada
executada depois
depois da
da execução
execução das
das instruções
instruções
„
„ uma
uma acção
acção que
que incrementa
incrementa ou
ou decrementa
decrementa aa variável
variável de
de controlo
controlo

Algoritmos e Estruturas de Dados, 2007-2008 , Gladys Castillo 46

23
Problema 4. Programa
(versão 2: usando o ciclo for)
//// entrada
entrada ee processamento
processamento de
de dados
dados
do
do {{
System.out.print
System.out.print ("
("Introduza
Introduza um
um número
número inteiro positivo:: ");
inteiro positivo ");
nn == Integer.parseInt(input.readLine());
Integer.parseInt(input.readLine());
i é a variável de controlo.
}} while
while (n(n <=0);
<=0);
i é inicializada com o valor 1
Repetir:
Verificar a condição: i ≤ n ?
for
for (int
(int i=1;
i=1; i<=n;
i<=n; i++){
i++){
SE i≤n, o processo prossegue: System.out.print
System.out.print (( "Introduza
"Introduza oo "" ++ ii ++ "" número
número :: ");
");
1º. Executar as instruções num
num == Double.parseDouble
Double.parseDouble (input.readLine());
(input.readLine());
2º. Executar i++ soma
soma += += num;
num; //// Adiciona
Adiciona num
num aa soma soma
caso contrário (i>n): }}
⇒ o ciclo termina
//// saída
saída de
de dados
dados
System.out.println
System.out.println (( "A
"A soma
soma dos
dos números
números lidos
lidos éé "" ++ soma
soma ););
}} //// fim
fim main()
main()
}}

Algoritmos e Estruturas de Dados, 2007-2008 , Gladys Castillo 47

Descrição da sequencia de passos


efectuados por o ciclo for para n =3
Inicialização: i = 1 ( a variável de controlo i toma o valor de 1)
„ Iteração 1: (i =1)
1. Verificar a condição: i ≤3? ⇒ SIM ⇒ o ciclo prossegue
2. Executar as instruções: Ler o primeiro número e adiciona-lo a soma
3. Executar a acção i++ ⇒ i = 2
„ Iteração 2: (i =2)
1. Verificar a condição: i ≤3? ⇒ SIM ⇒ o ciclo prossegue
2. Executar as instruções: Ler o segundo número e adiciona-lo a soma
3. Executar a acção i++ ⇒ i = 3

„ Iteração 3: (i =3)
1. Verificar a condição: i ≤3? ⇒ SIM ⇒ o ciclo prossegue
2. Executar as instruções: Ler o terceiro nú
número e adiciona-lo a soma
3. Executar a acção i++ ⇒ i = 4

„ Iteração 4: (i =4)
1. Verificar a condição: i ≤4? ⇒ Não ⇒ o ciclo termina

Algoritmos e Estruturas de Dados, 2007-2008 , Gladys Castillo 48

24
Problema 5

Escrever um programa que, recebendo um


qualquer número inteiro positivo,
devolva a soma dos seus dígitos.
Por exemplo, se o inteiro introduzido for 1234 o
programa deverá devolver 10 = 1+2+3+4

Algoritmos e Estruturas de Dados, 2007-2008 , Gladys Castillo 49

Problema 5: Especificação
Entrada: num - número inteiro positivo com um número
indeterminado de dígitos
(valor numérico inteiro positivo: num > 0 )
Saída: soma - a soma dos dígitos do número
(valor numérico inteiro)

Algoritmo:
Ler o número para a variável num
Inicializar soma com 0
Repetir enquanto houver dígitos para somar
1º. Separar um dos dígitos de num e guardar em dígito.
gito
2º. Somar dígito a soma.
soma
Imprimir soma

Algoritmos e Estruturas de Dados, 2007-2008 , Gladys Castillo 50

25
Problema 5. Pseudo-Código
Inicializar
Inicializar soma
soma com
com 0; 0;
Ler
Ler oo número
número (num
num )) ;;
(num
Enquanto
Enquanto num num >> 00
digito
digito == num
num % % 10;
10;
num = num /
num = num / 10; 10;
soma
soma == soma
soma ++ digito;
digito
digito;
Fim
Fim Enquanto
Enquanto ;;
Escrever
Escrever nono ecrã
ecrã aa soma
soma dosdos dígitos
dígitos (soma
soma);
(soma);

Iteração num inicial digito soma num final


1234 / 10 = 123.4 ⇒ 1 1234 4 4 123
123 – parte inteira → num
4 – o resto da divisão → digito 2 123 3 7 12
3 12 2 9 1
4 1 1 10 0

Algoritmos e Estruturas de Dados, 2007-2008 , Gladys Castillo 51

Problema 5. Programa
(versão 1: usando o ciclo while)
import
import java.io.*;
java.io.*;
class
class Cap1Top4Pr5v1SomaDigitos
Cap1Top4Pr5v1SomaDigitos {{
public
public static
static void
void main(String
main(String [[ ]] args)
args) throws
throws IOException{
IOException{
int
int num,
num, digito,
digito, soma
soma == 0;
0;
BufferedReader
BufferedReader inputinput == new
new BufferedReader
BufferedReader (new(new InputStreamReader
InputStreamReader (System.in));
(System.in));
//// entrada
entrada ee validação
validação do
do número
número
do
do {{
System.out.print("Introduza
System.out.print("Introduza umum número
número inteiro
inteiro positivo:
positivo: ");
");
num
num == Integer.parseInt
Integer.parseInt (input.readLine());
(input.readLine());
}} while
while (num
(num <=0);
<=0);
//// processamento
processamento
while
while (num
(num >> 0)0) {{
digito
digito == num
num % % 10;
10;
Equivalente a: num
num /=/= 10;
10;
num = num /10
soma
soma += += digito;
digito;
}}
//// saída
saída
System.out.println
System.out.println (“
(“ A
A soma
soma dos
dos dígitos
dígitos é:
é: "" ++ soma);
soma);
}}
}}
Algoritmos e Estruturas de Dados, 2007-2008 , Gladys Castillo 52

26
Problema 5. Programa
(versão 2: usando o ciclo for)
processamento
while
while (num
(num >0){
>0){
digito
digito == num
num % % 10;
10;
num
num /=/= 10;
10;
soma
soma += += digito;
digito;
}}

num é a variável de controlo.


num é inicializada antes do ciclo (o
for
for (( ;; num
num >0;
>0; num
num /=/= 10){
10){ valor introduzido pelo utilizador)
digito
digito == num
num % % 10;
10; Repetir:
soma
soma += += digito;
digito; Verificar a condição: num > 0?
}} Se num > 0, o processo prossegue:
1º. Executar as instruções
Podemos ainda 2º. Executar acção: num /= 10
escrever as for
for (( ;; num
num >0;
>0; num
num /=
/= 10){
10){ caso contrário (num =0):
instruções nesta soma
soma += += num
num %% 10;
10; ⇒ o ciclo termina
forma mais }}
compacta
Algoritmos e Estruturas de Dados, 2007-2008 , Gladys Castillo 53

Problema 5. Programa
(versão 2: usando o ciclo for)
import
import java.io.*;
java.io.*;
class
class Cap1Top4Pr5v2SomaDigitos
Cap1Top4Pr5v2SomaDigitos {{
public
public static
static void
void main(String
main(String [[ ]] args)
args) throws
throws IOException{
IOException{
int num, digito, soma = 0;
int num, digito, soma = 0;
BufferedReader
BufferedReader input
input == new
new BufferedReader
BufferedReader (new
(new InputStreamReader
InputStreamReader (System.in));
(System.in));
leitura do
do {{
System.out.print("Introduza
System.out.print("Introduza um
um número
número inteiro
inteiro positivo:
positivo: ");
");
num
num == Integer.parseInt
Integer.parseInt (input.readLine());
(input.readLine());
}} while
while (num
(num <=0);
<=0);

for
for (( ;num
;num >0;
>0; num/=10
num/=10 ){
){
processamento soma
soma +=+= num
num %% 10;
10;
}}

System.out.println
System.out.println (“
(“ A
A soma
soma dos
dos dígitos
dígitos é:
é: "" ++ soma);
soma);
escrita }}
}}

Algoritmos e Estruturas de Dados, 2007-2008 , Gladys Castillo 54

27
Problema 6

Escrever um programa que escreva no ecrã uma pirâmide de


números com um número de linhas entre 1 e 9,
fornecido pelo utilizador.
Por exemplo, se o número de linhas for 4, deve obter-se:
1
121
12321
1234321

Algoritmos e Estruturas de Dados, 2007-2008 , Gladys Castillo 55

Problema 6: Especificação
Entrada: numLinhas - número de linhas da pirâmide
(valor numérico inteiro positivo)
Saída: pirâmide com o número de linhas igual a numLinhas

Algoritmo:
Ler o número de linhas para a variável numLinhas
Para uma variável nLinha = 1 até
até numLinhas fazer:
1º. Escrever os espaços
2º. Escrever números por ordem crescente
3º. Escrever números por ordem decrescente
4º. Mudar de linha
Fim para

Algoritmos e Estruturas de Dados, 2007-2008 , Gladys Castillo 56

28
Problema 6: Algoritmo
for
for (nLinha
(nLinha =1; =1; nLinha
nLinha <=
<= numLinhas;
numLinhas;
nLinha++)
nLinha++) {{
Se numLinhas = 4 //// 1º.
1º. Escrever
Escrever os os espaços
espaços
for
for (i(i =1;
=1; ii <=
<= numLinhas
numLinhas –– nLinha;
nLinha; ii ++)
++)
Para nLinha =1,
print(“
print(“ "); ");
3 espaços 1
//// 2º.
2º. Escrever
Escrever númerosnúmeros (ordem
(ordem crescente)
crescente)
Para nLinha =2,
2 espaços 121 for
for (i =1 ; i <= nLinha; ii ++)
(i =1 ; i <= nLinha; ++)
print(i
print(i ););
Para nLinha =3, //// 3º.
3º. Escrever
Escrever númerosnúmeros (ordem
(ordem decrescente)
decrescente)
1 espaço 12321
for
for (i(i =nLinha-1
=nLinha-1 ;; ii >=1;
>=1; ii --)
--)
print(i
print(i ););
Para nLinha =4,
1234321 //// 4º.
0 espaço 4º. Mudar
Mudar de de linha
linha
println();
println();
# espaços = numLinhas - nLinha }}

Algoritmos e Estruturas de Dados, 2007-2008 , Gladys Castillo 57

Problema 6: Programa

?
Algoritmos e Estruturas de Dados, 2007-2008 , Gladys Castillo 58

29

You might also like