java, u, h

Prévia do material em texto

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 
 //armazenaem 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