View
220
Download
3
Category
Preview:
Citation preview
1 – Linguagem de Programação
http://erinaldosn.wordpress.com
Estruturas de Repetição em Java
A realização da repetição controlada por contador requer:
1. Uma variável de controle (ou contador de loop).
2. O valor inicial da variável de controle.
3. O incremento (ou decremento) pelo qual a variável de controle é modificada a cada
passagem pelo loop (iteração do loop).
4. A condição de continuação do loop que determina se o loop deve continuar.
Instrução de repetição FOR O Java fornece a instrução de repetição for, que especifica os detalhes da
repetição controlada por contador em uma única linha de código.
Exemplo 1: ler 8 números fornecidos pelo usuário, calcular e exibir a média entre eles. /*
* o programa utiliza a classe Scanner
* para ler os números digitados via teclado
* pelo usuário
*/ import java.util.Scanner;
//classe (o nome do programa ex1_for.java) public class ex1_for {
//método principal onde inicia a execução do programa public static void main(String args[]){
//declaração de variáveis float soma, num, media;
int cont;
Scanner leia = new Scanner(System.in);
//incializa a variável soma = 0;
/*
* para cont começando com 1;
* até cont menor ou igual a 8;
* increment cont de 1 em 1
*/ for (cont = 1; cont <= 8; cont++){
/*
* a variável leia armazena o valor digitado pelo usuário
* esse valor é atribuído à num
*/ num = leia.nextFloat();
//soma armazena o valor de soma + o valor de num soma+=num; //soma = soma + num
} //fim do loop
/*
* calcula a média
* o valor de soma dividido pelo número de iterações
*/ media = soma / cont;
//exibe a média dos números digitados System.out.println("Média ="+media);
}
}
Estrutura de Repetição – 2
http://erinaldosn.wordpress.com
Em Java a expressão cont ← cont + 1 é representada por cont++.
As variáveis quando declaradas não possuem valores, seu conteúdo é nulo e
operações aritméticas que envolvem nulos sempre resultam em nulos. Às vezes também
será necessário acumular valores, isto é, calcular o somatório de um conjunto de
valores. Para isso, também será necessário utilizar uma variável de apoio, que pode ser
do tipo inteiro ou real, de acordo com os valores que serão acumulados acumulador = 0;
acumulador = acumulador + valor;
Componentes de cabeçalho
for ( int cont = 1; cont <= 10; cont++ )
Em geral as instruções for são utilizadas para repetição controlada por
contador. Se a expressão inicialização no cabeçalho for declara a variável de controle,
a variável de controle pode ser utilizada somente nessa instrução for – ela não existirá
fora da instrução for.
Essa utilização restrita do nome da variável de controle é conhecida como o
escopo da variável. O escopo de uma variável define onde ela pode ser utilizada em
um programa.
Todas as três expressões em um cabeçalho for são opcionais. Se a condição de
continuação do loop for omitida, o Java assume que a condição de continuação do loop
é sempre verdadeira, criando um loop infinito.
Você poderia omitir a expressão incremento se o programa calcular o
incremento com instruções no corpo do loop ou se nenhum incremento for necessário.
A expressão incremento em uma instrução for atua como se ela fosse uma instrução
independente no fim do corpo do for.
A instrução de repetição WHILE Uma instrução de repetição permite ao programador especificar que um
programa deve repetir uma ação enquanto alguma condição permanecer verdadeira.
Palavra
chave
Variável
de controle
Valor inicial
da variável
de controle
Condição de
continuação do loop
Incremento da
variável de controle
Separador
ponto-e-vírgula
Separador
ponto-e-vírgula
3 – Linguagem de Programação
http://erinaldosn.wordpress.com
A(s) instrução(ões) contida(s) na instrução de repetição while constitui(em) o
corpo da instrução de repetição while, que pode ser uma única instrução ou um bloco.
Por fim, a condição se tornaria falsa. Nesse ponto a repetição termina e a primeira
instrução depois da instrução de repetição é executada.
Exemplo 2: ler 8 números fornecidos pelo usuário, calcular e exibir a média entre eles. import java.util.Scanner;
//classe public class ex2_while {
//método principal public static void main(String args[]){
//declaração de variáveis float soma, num, media;
int cont;
Scanner leia = new Scanner(System.in);
//inicialização de variáveis soma = 0;
cont = 0;
//enquanto a variável cont for menor que 8 while (cont < 8){ //inicia o loop
//armazena na variável num o valor digitado via teclado num = leia.nextFloat();
//a variável soma acula a soma com num soma+=num;
//incrementa o contador cont cont++;
}//fim do loop
//calcula a média dos números somados media = soma / cont;
//exibe (escreve) a média System.out.println("Média = "+media);
} // fim do método principal
} //fim da classe
A estrutura de repetição DO...WHILE A instrução do... while é semelhante à instrução while. Em while o programa
testa a condição de continuação do loop no começo do loop antes de executar o corpo
do loop. Se a condição for falsa, o corpo nunca executa. A instrução do... while testa a
condição de continuação do loop depos de executar o corpo do loop, portanto, o corpo
sempre executa pelo menos uma vez. Quando uma instrução do... while termina a
execução continua cm a próxima instrução na sequência.
Exercício 3: ler 8 números fornecidos pelo usuário, calcular e exibir a média entre eles. import java.util.Scanner;
public class ex3_do_while {
//método principal public static void main(String args[]){
//declaração de variáveis float soma, num, media;
int cont;
Scanner leia = new Scanner(System.in);
//inicialização de variáveis soma = 0;
cont = 0;
//faça (repita) do{
//armazene em num o valor digitado pelo usuário
Estrutura de Repetição – 4
http://erinaldosn.wordpress.com
num = leia.nextFloat();
//acumula a soma dos números digitados soma+=num;
//incrementa o contador cont++;
}while (cont < 8);//enquanto (até) cont ser menor que 8
//calcula a média dos números digitados media = soma / cont;
//exibe a média System.out.println("Média = "+media);
}//fim do método principal
}//fim da classe ex3_do_while
Exemplo 4: a cada iteração pergunta-se ao usuário se deseja continuar. Com base na
resposta, a condição estabelecida é testada. import java.util.Scanner;
public class ex4_while {
public static void main(String args[]){
//declaração e inicialização de variáveis float soma=0, num, media;
int cont = 0;
char resposta='S';
Scanner leia = new Scanner(System.in);
/*
* enquanto a variável respostar
* for igual a 'S' ou 's' faça
*/ while (resposta == 'S' || resposta == 's'){//início do loop
//armazena em num o valor digitado pelo usuário via teclado num = leia.nextFloat();
//acumula a soma dos números digitados soma+=num;
//acumula um contador de quantos números foram digitados cont++;
//exibe a mensagem se o usuário quer continuar System.out.println("Deseja continuar?");
//armazena em resposta o caractere digitado pelo usuário resposta = leia.next().charAt(0);
}//fim do loop
//calcula a média da soma dos números digitados media = soma / cont;
//exibe a média System.out.println("Média = "+media);
}//fim do método principal
}//fim da classe
Operadores de atribuição compostos O Java fornece vários operadores de atribuição compostos para abreviar
expressões de atribuição. A tabela abaixo mostra os operadores de atribuição compostos
aritméticos, expressões de exemplo que utilizam os operadores e explicações do que os
operadores fazem.
Operador de
atribuição
Expressão de exemplo Explicação Atribuições
Suponha: int c = 3, d = 5, e = 4, f = 6, g = 12;
+= c += 7 c = c + 7 10 para c
–= d –= 4 d = d – 4 1 para d
5 – Linguagem de Programação
http://erinaldosn.wordpress.com
Operador de
atribuição
Expressão de exemplo Explicação Atribuições
*= e *= 5 e = e * 5 20 para e
/= f /= 3 f = f / 3 2 para f
%= g %= 9 g = g % 9 3 para g
Operadores de incremento e decremento O Java fornece dois operadores unários para adicionar 1 ou subtrair 1 do valor
de uma variável numérica. Um operador de incremento ou de decremento que é
colocado antes de uma variável é chamado operador de pré-incremento ou operador de
pré-decremento, respectivamente. Um operador de incremento u decremento que é
colocado depois de uma variável é chamado operador de pós-incremento ou operador de
pós-decremento, respectivamente.
Pré-incrementar (ou pré-decrementar) uma variável faz com que a variável seja
incrementada (decrementada) por 1 e então o novo valor da variável é utilizado na
expressão em que aparece. Pós-incrementar (pós-decrementar) a variável faz com que o
valor atual da variável seja utilizado na expressão em que ela aparece e então o valor da
variável é incrementado (decrementado) por 1.
Os operadores de incremento e decremento unários devem ser colocados ao lado
de seus operandos sem espaços no meio.
A tabela abaixo demonstra os operadores de incremento e de decremento.
Operador Chamado Expressão
de exemplo
Explicação
++ pré-incremento ++a Incrementa a por 1 e então utiliza o novo
valor de a na expressão em que a reside.
++ pós-incremento a++
Utiliza o valor atual de a na expressão
em que a reside, então incrementa a por
1.
-- pré-decremento --b
Decrementa b por 1 e então utiliza o
novo valor de b na expressão em que b
reside.
-- pós-decremento b--
Utiliza o valor atual de b na expressão
em que b reside, então decrementa b por
1.
Exercícios 1. Identifique e corrija os erros em cada um dos seguintes conjuntos de código:
a) while (c <= 5 ) {
produto *= c;
++c;
b) if (sexo == 1) System.out.println(“Mulher”);
else;
System.out.println(“Homem”);
c) if (idade >= 65); System.out.println(“idade maior oi igual a”);
else
Estrutura de Repetição – 6
http://erinaldosn.wordpress.com
System.out.println(“a idade é menor que 65)”;
d) int x = 1, total; while (x <= 10)
{
total += x;
++x;
}
e) while (x <= 100) total += x;
++x;
f) while (y > 0)
{
System.out.println(y);
++y;
g) i = 1; while (i <= 10);
i++;
}
h) for (k = 0.1; k != 1.0; k += 0.1) System.out.println(k);
i) switch(n){
case 1:
System.out.println(“O número é 1”);
case 2:
System.out.println(“O número é 2”);
break;
default:
System.out.println(“O número não é 1 nem 2”);
break;
}
j) for (i = 100, i >= 1, i++)
System.out.println(i);
k) switch (valor % 2){ case 0:
System.out.println(“Inteiro par”);
case 1:
System.out.println(“Inteiro ímpar”);
}
2. O que há de errado com a instrução while a seguir? while (z >= 0)
soma += z;
3. O que os seguintes programas imprimem? public class prog4_16 {
public static void main(String args[]){
int y, x = 1, total = 0;
while (x <= 10){
y = x * x;
System.out.println(y);
total += y;
++x;
7 – Linguagem de Programação
http://erinaldosn.wordpress.com
}
System.out.printf("O total é %d\n", total);
}
}
public class prog4_17 {
public static void main(String args[]){
int i = 1;
while (i <= 10){
System.out.println(i % 2 == 1 ? "*****" :
"+++++");
++i;
}
}
}
public class prog4_18 {
public static void main(String args[]){
int linha = 10, coluna;
while (linha >= 1){
coluna = 1;
while (coluna <= 10){
System.out.print(linha % 2 == 1 ? "<" :
">");
++coluna;
}
--linha;
System.out.println();
}
}
}
public class prog4_19 {
public static void main(String args[]){
for (int i = 1; i <= 10; i++){
for (int j = 1; j <= 5; j++)
System.out.print('0');
System.out.println();
}
}
}
4. O que os seguintes segmentos de programas fazem? for (i = 1; i <= 5; i++){
for (j = 1; j <= 3; j++){
for (k = 1; k <= 4; k++)
System.out.print(„*‟);
System.out.println();
}
}
n = 1;
Estrutura de Repetição – 8
http://erinaldosn.wordpress.com
while (n <= 10)
System.out.println(n++);
for (int i = 19; i >= 1; i -= 2)
System.out.println(i);
cont = 2;
do{
System.out.println(cont);
cont += 2;
} while (cont <= 100)
5. Um programa Java está todo misturado. Reorganize os trechos de código para criar
o programa. Adicione as chaves necessárias.
if (x == 1) {
System.out.print(“d”);
x = x – 1;
}
if (x == 2) {
System.out.print(“b c”);
}
class embaralha{
public static void main(String args[]){
if (x > 2) {
System.out.print(“a”);
}
int x = 3;
x = x – 1;
System.out.print(“-“);
while (x > 0){
Esse programa produz a saída listada abaixo:
Bibliografia Lógica de programação e estrutura de dados, com aplicações em Java
Sandra Puga, Gerson Rissetti
São Paulo: Pearson Prentice Hall, 2009
Java: como programar
H. M. Deitel, P. J. Deitel
São Paulo: Pearson Prentice Hall, 2005
Estrutura de dados e algoritmos em Java
9 – Linguagem de Programação
http://erinaldosn.wordpress.com
Michael Goodrich, Roberto Tamassia
Porto Alegre: Bookman, 2007
Use a cabeça Java
Kathy Sierra e Bert Bates
Rio de Janeiro: Alta Books, 2005
Recommended