PRÁTICA - ESTRUTURAS DE CONTROLE NA LINGUAGEM JAVA
Como se sabe, controlar o fluxo do programa é mais do que uma necessidade para os programadores, mas agora você irá estudar isso na prática. Mas antes veja um detalhe importante.
Em "Java" os comandos são divididos em blocos (métodos) onde se abrem e fecham esses blocos com chaves.
Veja o exemplo a seguir:
/*
SÍNTESE
Objetivo: Apresentar mensagem
Entrada: Nenhuma.
Saída: Mensagem.
*/
public class Main {// Essa chave indica o bloco do programa principal.
public static void main(String[] args) {// Essa chave indica o bloco do método main.
System.out.println("Os programas em Java sao divididos em classes");
}
}
Nesse exemplo em particular foi implementado um bloco que foi o método main, mas nos nossos próximos exemplos você vai começar a observar mais blocos em um único programa.
Agora que você já tem uma noção superficial de blocos vamos iniciar nossos estudos práticos em estruturas de controle, onde voltaremos a tocar no assunto de blocos.
Para refrescar sua memória, estrutura sequencial corresponde a um conjunto de ações que serão executadas sequencialmente linha após linha, ou seja, assim como se escreve, de cima para baixo e da esquerda para direita.
Por exemplo: Um universitário necessita de passar por várias etapas para conseguir entrar na faculdade, ou seja, teve que respeitar uma sequência de estudos para conseguir.
/*
SÍNTESE
Objetivo: Calcular a média ponderada de notas.
Entrada: Duas notas.
Saída: Apresentar média ponderada das notas.
*/
#include <stdio.h>
#include <conio.h>
void main (void)
{
//Declarações
float nota1, nota2, media ;
//Início
printf("\nInforme a primeira nota: ");
scanf("%f",¬a1); //lendo a primeira nota
printf("\nInforme a segunda nota: ");
scanf("%f",¬a2); //lendo a segunda nota
media=(nota1*3 + nota2*7)/10 ; //o cálculo da média ponderada
printf("\nMedia final: %.2f",media); // mostrando a média
getch();
return 0;
} //Fim
A implementação deste algoritmo em linguagem "Java" seria:
import java.util.Scanner; // Importando a classe Scanner.
public class Main {// Início da classe Main.
public static void main(String[] args) { //Início do método main.
//Declarações
double nota1, nota2, media ;
Scanner leitor = new Scanner(System.in);
//Início
System.out.println("Informe a primeira nota: ");
nota1 = leitor.nextDouble(); //lendo a primeira nota
System.out.println("Informe a segunda nota: ");
nota2 = leitor.nextDouble(); //lendo a segunda nota
media=(nota1*3 + nota2*7)/10 ; //o cálculo da média ponderada
System.out.println("Media final: " + media); // mostrando a média
}
}
Como você pôde observar a execução desse programa não teve nenhuma variação do seu fluxo. Porém, há algumas observações a serem detalhadas:
import java.util.Scanner: Para você poder realizar a leitura de dados (int, double, string......) deve-se importar o pacote java.util, instanciar e criar um objeto Scanner
(Scanner leitor = new Scanner(System.in);), sendo que leitor é um objeto da classe Scanner.
System.out.println("Media final: " + media);: Para que se possa apresentar uma mensagem juntamente com um valor numérico, deve-se fazer a 'concatenação' da mensagem ('+') seguida da variável numérica (nesse caso, media).
Vamos ver agora uma nova instrução, que efetua a alteração sequencial de execução de um programa.
As estruturas de seleção permitem a execução de uma instrução ou um bloco de instruções escolhidas após a avaliação do resultado de um teste condicional que pode ser VERDADEIRO ou FALSO.
Este teste condicional pode consistir em uma operação relacional simples ou em uma expressão mais complexa. Existem algumas características importantes relacionadas às estruturas de seleção, permitindo que elas sejam divididas ou classificadas em: simples, composta, aninhada e de múltipla escolha.
Nesse tipo de seleção antes de executar um bloco de instruções, o programa testa a condição. Lembre-se que só executará o bloco se o resultado da condição for VERDADEIRO. Toda instrução de seleção resulta em uma informação lógica (VERDADEIRO ou FALSO) que distinguirá o caminho a ser seguido pelo programa, quebrando a sua ordem sempre sequencial.
Observe o exemplo anterior que apresenta como resultado a média conseguida por um aluno que obteve as notas anteriores de 7.5 e 9.5. Supondo que a média mínima para aprovação seja 7.0 em uma escola, pode-se incluir na apresentação final a mensagem que identifica a situação deste aluno, que será APROVADO ou REPROVADO, de acordo com a média alcançada. Sendo assim, será necessária a inclusão de um teste condicional que possibilite a correta identificação da situação do aluno. Como estudado na parte lógica desta disciplina será necessária a inclusão do comando IF...ELSE, o que resultará no algoritmo:
/*
SÍNTESE
Objetivo: Calcular a media ponderada de duas notas e informar
somente a aprovação para média acima 7.0.
Entrada: Duas notas.
Saída: Média final e a situação.
*/
#include< stdio.h >
#include< conio.h >
void main (void)
{
//Declarações
float nota1, nota2, media;
//Início
printf("\nInforme a primeira nota: ");
scanf("%f",&a1); //lendo a primeira nota
printf("\nInforme a segunda nota: ");
scanf("%f",&a2); //lendo a segunda nota
media=(nota1*3+nota2*7)/10; //o cálculo da média
printf("\nMedia final: %.2f",media); // mostrando a média
//fazendo o teste condicional
if(media >= 7.0)
//apresenta mensagem caso verdadeiro
printf("\nAluno aprovado");
getch();
return 0;
}
Após identificada a lógica que resolve o problema apresentado e o desenvolvimento do seu respectivo algoritmo, será iniciada a elaboração do programa que consiste na tradução do algoritmo em "C" proposto para a linguagem "Java".
/*
SÍNTESE
Objetivo: Calcular a media ponderada de duas notas e informar
somente a aprovação para média acima 7.0.
Entrada: Duas notas.
Saída: Média final e a situação.
*/
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
//Declarações
double nota1, nota2, media;
Scanner leitor = new Scanner(System.in);
//Início
System.out.println("Informe a primeira nota: ");
nota1 = leitor.nextDouble(); //lendo a primeira nota
System.out.println("Informe a segunda nota: ");
nota2 = leitor.nextDouble(); //lendo a segunda nota
media=(nota1*3+nota2*7)/10; //o cálculo da média
System.out.println("Média final = " + media); // mostrando a média
//fazendo o teste condicional
if(media >= 7.0){
//apresenta mensagem caso verdadeiro
System.out.println("Aluno aprovado!");
}
}
}
O "if" é um comando que contém uma ou mais instruções, e como você já viu, para mais que uma instrução é necessária a criação de bloco que será aberto e fechado por meio de chaves, mas isso só será necessário se dentro do "if" tiver mais de uma linha de comando, como no exemplo anterior tinha apenas um comando "System.out.println", então não foi necessário abrir e fechar chaves. Veja o exemplo da condição a seguir:
if(MEDIA>=7.0)
{ //abrindo um bloco de instrução do comando if
System.out.println("Aluno aprovado");
System.out.println("Bom Aluno!");
} // fechando o bloco de instrução do comando if
Se não tivesse as chaves o compilador não executaria as instruções como desejado, apesar de não apresentar um erro, a sua execução estaria com problemas, pois o resultado de sua execução nem sempre seria correto.
Atenção: A indentação é de suma importância para a interpretação do programa, por exemplo:
if(MEDIA >= 7.0)
System.out.println("Aluno aprovado");
System.out.println("Bom Aluno!");
Neste caso observe que foram retiradas as chaves e feita a indentação e o programa irá escrever "Bom aluno" para qualquer condição, ou seja, mesmo que a média seja menor que 7.0, porque ele está interpretando que o System.out.println("Bom aluno") está fora do "if" e realmente está, então a conclusão é a seguinte: "indentação e interpretadores de blocos(chaves) precisam de cuidados ao serem usados".
Essa estrutura vai ocorrer quando duas alternativas dependerem da mesma condição, ou seja, uma da condição ser verdadeira e a outra da condição ser falsa. Em "C" conhecemos o "if" e o "else", em Java isso não se altera, vamos a um exemplo...
Se o sexo de uma pessoa não for masculino, então a conclusão óbvia é que ela seja do sexo feminino e assim vice-versa... como você pôde observar, dizer o sexo de uma pessoa também depende de uma certa lógica, observe que só será possível dizer se uma pessoa é de um determinado sexo se ela não pertencer ao oposto ("se" não for masculino "então" é feminino).
O comando "else"(senão) será executado somente se o teste condicional do comando "if" for falso, ou seja, se a condição do "if" for falsa ele automaticamente entra no "else", em caso de seleção composta.
No nosso próximo exemplo, ao invés de apenas escrever se o aluno está "Aprovado" (média acima de 7.0), ou escrever se ele está "Reprovado"(média abaixo de 7.0), observe que se o aluno não estiver aprovado automaticamente ele estará reprovado.
Veja o exemplo:
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
//Declarações
double nota1, nota2, media ;
Scanner scanf = new Scanner(System.in);
//Início
System.out.println("Informe a primeira nota: ");
nota1 = scanf.nextDouble(); //lendo a primeira nota
System.out.println("Informe a segunda nota: ");
nota2 = scanf.nextDouble(); //lendo a segunda nota
media=(nota1*3 + nota2*7)/10 ; //o cálculo da média ponderada
System.out.println("Media final: " + media); // mostrando a média
if(media < 7.0) //fazendo o teste condicional
{
System.out.println("REPROVADO"); //escrevendo reprovado
System.out.println("Estude mais!");
}
else{ // abrindo bloco de instrução
System.out.println("APROVADO"); // escrevendo aprovado
System.out.println("Parabens!");
}
}
}
Lembre-se: a condição obedece o princípio da não-contradição, ou seja, a condição nunca poderá ser verdadeira e falsa ao mesmo tempo, isso quer dizer que o programa só executa o que tem dentro do "if" ou só o que tem dentro do "else".
No nosso exemplo como o teste da condição foi "falso" então o programa deixa de executar o bloco de instruções que estava dentro do "if" (mudou o fluxo) e executou o bloco de instruções que estava dentro do "else".
Como você observou, o else também pode possuir a abertura e fechamento de blocos (chaves), se for necessária a execução de várias instruções. No entanto, se somente uma instrução tiver que ser executada não será necessária a abertura e o fechamento do bloco.
Para você se tornar um professor de faculdade no mínimo você tem que ser formado, ter uma pós-graduação, um mestrado e falar no mínimo duas línguas. Você percebeu que para você chegar a ser um professor universitário existem condições e que as mesmas têm que ser verdadeiras. Com a seleção aninhada é a mesma coisa, é o agrupamento de várias seleções, tal agrupamento ocorre quando um determinado bloco de instruções deve ser executado "se" um grupo de possibilidades ou combinações for satisfeito.
Observe a prática: O próximo programa irá receber três valores inteiros e irá informar o menor deles.
/*
SÍNTESE
Objetivo: Receber três valores e escrever o menor deles.
Entrada: Três valores.
Saída: O menor valor
*/
#include <stdio.h>
#include <conio.h>
int main (void)
{
//Declarações
int A,B,C,MENOR;
//Início
printf("Informe tres valores:\n");
scanf("%d%d%d",&A,&B,&C); //lendo os três valores
if(A <= B)
{
if(A <= C) //só será testado se o "if" de fora for verdadeiro
MENOR = A;
else
MENOR = C;
}
else
{
if(B <= C)
MENOR=B;
else
MENOR=C;
}
printf("\nMenor = %2d",MENOR);
getch();
return 0;
}
Em Java:
/*
SÍNTESE
Objetivo: Receber três valores e escrever o menor deles.
Entrada: Três valores.
Saída: O menor valor
*/
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
//Declarações
Scanner leitor = new Scanner(System.in);
int a,b,c,menor;
//Início
//lendo os três valores
System.out.println("Informe o primeiro valor:\n");
a = leitor.nextInt();
System.out.println("Informe o segundo valor:\n");
b = leitor.nextInt();
System.out.println("Informe o terceiro valor:\n");
c = leitor.nextInt();
if(a <= b)
{
if(a <= c) //só será testado se o "if" de fora for verdadeiro
menor = a;
else
menor = c;
}
else{
if(b <= c)
menor=b;
else
menor=c;
}
System.out.println("Menor = " + menor);
}
}
No exemplo acima, o terceiro valor informado (10) é o menor.
Acompanhe como isso aconteceu. Como o primeiro valor é maior que o segundo, o teste do primeiro "if" deu "falso", automaticamente o programa executa o bloco de instruções que existe dentro do "else", mas dentro do "else" temos mais duas possibilidades, do segundo ser menor que o terceiro ou o terceiro ser menor que o segundo, é onde ocorre o teste do "if" que está dentro do "else", que também é "falso" e automaticamente o programa executa o que tem dentro do outro "else".
Um de seus questionamentos neste momento deve ser o seguinte: Por que não teve nenhum bloco iniciado e fechado com chaves, sendo que tem blocos que tem um "if" e um "else"? Lembre-se que o programa só executa ou um ou outro, nunca os dois. Portanto se ele executar o "if" ele não vai executar o "else", ou seja, o programa interpretará apenas uma instrução ou o "if" ou o "else".
Em "C" foi estudado a instrução switch que será abordada agora como mais uma instrução de seleção possível na linguagem Java.
No tópico anterior foi falado sobre a seleção aninhada, mas será que ela é sempre a melhor opção para selecionar instruções que dependem da mesma condição? E se existirem inúmeras condições para selecionar as instruções? Lembre-se, para selecionar uma instrução usando "switch" a condição analisada deverá ser um caracter ou um inteiro.
No exemplo a seguir nós vamos apresentar uma cidade a partir do seu DDD usando a "seleção aninhada" e logo em seguida usando o "switch", para você poder refletir qual seria a melhor opção.
//Síntese
//Objetivo: Apresentar capital do centro-oste cidade correspondente ao DDD.
//Entrada: DDD.
//Saída: Nome da capital.
int main(void)
{
//Declarações
int ddd;
// inicio
printf("Digite o DDD: ");
scanf ("%d",&ddd);
if(ddd==61)
printf("Brasilia");
else
{
if(ddd==62)
printf("Goiania");
else
{
if(ddd==65)
printf("Cuiaba");
else
{
if(ddd==67)
printf("Campo Grande");
else
printf("DDD nao encontrado");
}
}
}
getch();
return 0;
}
Utilizando a instrução "switch":
/*
SÍNTESE
Objetivo:Apresentar capital do centro-oeste correspondente ao DDD
Entrada:DDD.
Saída: O nome da capital.
*/
#include <stdio.h>
#include <conio.h>
int main (void)
{
//Declarações
int ddd;
//Início
printf("Digite o DDD:\n");
scanf("%d",&ddd);
switch (ddd)
{ //selecionando o dia
case 61 : printf("\nBrasilia");
break;
case 62 : printf("\nGoiana");
break;
case 65 : printf("\nCuiaba");
break;
case 67 : printf("\nCampo Grande");
break;
default :
printf("\nDDD nao encontrado");
}
getch();
return 0;
}
Elaborando a implementação na linguagem Java tem-se:
/*
SÍNTESE
Objetivo:Apresentar capital do centro-oeste correspondente ao DDD
Entrada:DDD.
Saída: O nome da capital
*/
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
//Declarações
Scanner leitor = new Scanner(System.in);
int ddd;
//Início
System.out.println("Digite o DDD:");
ddd = leitor.nextInt();
switch (ddd)
{ //selecionando o ddd
case 61 : System.out.println("Brasilia");
break;
case 62 : System.out.println("Goiana");
break;
case 65 : System.out.println("Cuiaba");
break;
case 67 : System.out.println("Campo Grande");
break;
default :
System.out.println("DDD nao encontrado");
}
}
}
O comando "break" que você viu logo após a linha de comando do "case", é chamado de comando de desvio, onde ele realiza um desvio incondicional. O "case" será executado até que o comando "break" ou o fim do "switch" seja alcançado.
Quando o comando "break" é alcançado, salta para linha de código seguinte ao final do "switch". Caso não tivéssemos inserido o "break" o programa continuaria testando os outros "cases" e poderia causar um erro em seu programa.
Se você tem alguma dúvida sobre o "switch" vamos tentar tirá-las agora. Há três coisas importantes que você tem que saber sobre o comando "switch":
- O comando "switch" difere do comando "if" porque "switch" só pode testar igualdade, enquanto "if" pode avaliar uma expressão lógica ou relacional;
- Duas constantes "case" no mesmo "switch" não podem ter valores idênticos. Obviamente, um comando "switch" incluído em outro "switch" mais externo pode ter as mesmas constantes "case";
- Se constantes de caractere são usadas em um comando "swicth", elas são automaticamente convertidas para seus valores inteiros.
 |
Com intuito de apoiar o aprendizado sobre Orientação a Objeto, sugere-se assistir a videoaula para o aperfeiçoamento no conhecimento deste conteúdo. |
Você já deve ter alguma intimidade com as estruturas de repetição, mas antes de começarmos logo na prática vamos relembrar alguns conceitos básicos.
Fazer um programa para calcular a média de duas notas de um aluno você já sabe fazer. Simples, não é? Agora imagine calcular a média de notas de 50 alunos. Será que é só escrever o algoritmo 50 vezes? É, pode até dar certo, porém nada viável.
Outro modo de resolver essa questão seria utilizar a mesma sequência de comandos novamente, ou seja, fazer um retrocesso ao início dos comandos para cada aluno, fazendo, portanto com que o fluxo de execução repetisse certo trecho do programa, o que nesta aplicação corresponderia a escrever o mesmo trecho 50 vezes.
Existem três tipos de estruturas de repetição em "C", são elas: for, while e o do...while. Em "Java" temos respectivamente as mesmas estruturas de repetição.
Vamos começar pelo o "for" que é uma estrutura de repetição finita, ou seja, possui limites fixos e uma variável de controle dentro desse limite.
A forma geral da repetição, também chamada de laço ou looping "for" em Java é:
for (<inicialização> ; <teste condicional> ; <incremento ou decremento>) {
<instruções>;
}
- inicialização: É um comando de atribuição que é usado para colocar um valor na variável de controle (que deve ser declarada normalmente como outra variável qualquer) do laço;
- teste condicional: É uma expressão relacional que determina quando o laço acaba, ou seja, enquanto condição verdadeira a repetição acontece;
- incremento ou decremento: Define como a variável de controle deve variar a cada vez que o laço se repete.
Importante: observe que estas três seções são separadas por meio de ponto-e-vírgula (;).
Visando uma melhor fixação do conteúdo, vamos primeiro fazer um algoritmo para calcular a média de pesos de 50 pessoas, usando a linguagem "C":.
/*
SÍNTESE
Objetivo: Calcular a média de pesos de 50 pessoas usando "FOR"
Entrada: 50 pesos.
Saída: Média de pesos.
*/
int main (void)
{
//Declarações
float pesos, acumulador=0 ,media;
int cont;
//Início
for(cont=1;cont<=50;cont++)
{
printf("Informe , %d, peso:",cont);
scanf("%f",&pesos); //lendo a nota
acumulador=acumulador+pesos; //acumulando as 50
}
media=acumulador/50; //calculando a média
printf("\nMedia Geral =%2.1f",media); //mostrando a média
getch();
return 0;
}
A implementação na linguagem JAVA seria:
/*
SÍNTESE
Objetivo: Calcular a média de pesos de 50 pessoas usando "for"
Entrada: 50 pesos.
Saída: Média de pesos.
*/
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
//Declarações
Scanner leitor = new Scanner(System.in);
double pesos, acumulador=0 ,media=0;
int cont;
//Início
for(cont=1;cont<=50;cont++)
{
System.out.println("Informe o "+(cont)+ " peso:");
pesos = leitor.nextDouble(); //lendo o peso
acumulador=acumulador+pesos; //acumulando as 50
}
media=acumulador/50; //calculando a média
System.out.println("Media Geral = " + media); //mostrando a média
}
}
Em nosso exemplo a variável de controle "cont" varia de 1 até 50, fazendo a leitura dos pesos e o acumulador repetir 50 vezes.
A média como só necessita ser calculada uma vez, ela tem que esta fora do bloco de comandos do "for".
ATENÇÃO: Como você observou foi necessário acumular os 50 pesos, então nunca se esqueça de inicializar a variável (zero).
Observação: Como o laço "for" é um bloco de comando e como dentro do laço tem mais de uma linha de comando, ele também necessita de chaves.
Continuando com o laço "for"... Vamos imprimir na tela os número ímpares de 1 até 100. Para resolvermos esse problema existem várias formas, vamos resolver de algumas maneiras diferentes para treinarmos as versatilidades do laço "for".
/*
SÍNTESE
Objetivo: Imprimir na tela os números ímpares entre 1 a 70.
Entrada: Nenhuma.
Saída: Os números ímpares entre 1 a 70.
*/
public class Main {
public static void main(String[] args){
//Declarações
int cont;
//Início
for(cont=1;cont<=70;cont++)
if(cont%2!=0) //testando para ver se é ímpar
System.out.println(cont);
}
}
Como você pôde observar foi usada a variável de controle para obtermos os números pares, ou seja, podemos usar a variável de controle para fazermos o que quisermos, mas temos que tomar cuidado para não mudar a ordem do laço (incrementando ou decrementando a variável dentro do bloco também) a não ser que você use uma lógica para isso.
Vamos ver outra forma de mostrar os números pares mas só que agora em ordem decrescente de 100 até 2...
/*
SÍNTESE
Objetivo: Imprimir na tela os números pares entre 100 a 2
em ordem decrescente.
Entrada: Nenhuma.
Saída: Os números pares entre 100 a 2.
*/
public class Main {
public static void main(String[] args) {
//Declarações
int cont;
//Início
for(cont=101;cont<=1;cont-=2)
System.out.println(cont);
}
}
Desta vez mudamos a inicialização e a cada vez que a repetição ocorrer a variável será decrementada com 2. Com isso só basta escrever a variável de controle na tela.
Lembre-se: O "for" acontece de onde a variável de controle é inicializada até a 'condição' se tornar falsa ou se preferir enquanto verdadeira.
Para relembrar, o "enquanto" ("while") é executado enquanto o teste de sua condição for verdadeiro ou até a condição se tornar falsa. A condição pode ser qualquer expressão, e lembre-se verdadeiro em "Java" é qualquer valor não zero. Se já na primeira vez o resultado da condição for falso, os comandos não serão executados nenhuma vez, o que representa a característica principal desse modelo de repetição.
A forma geral do comando while é:
-
while (<condição>)
{
<instruções>;
}
Vamos utilizar o mesmo exemplo anterior, calcular a média de cinquenta alunos na prova de algoritmo, usando o "while". Mas espere aí, qual será a nossa condição de saída? A condição poderia ser quantidade de notas recebidas, ou seja, a quantidade de alunos menor que 50; porém, o que indica quantas vezes a nota foi acumulada? O "while" não oferece esse recurso, então teríamos que implementar um sistema de contagem, feito através de um 'contador' representado por uma variável com um dado valor inicial, que será incrementada a cada repetição.
/*
SÍNTESE
Objetivo: Calcular a média de pesos de 50 pessoas usando a estrutura "while"
Entrada: 50 pesos.
Saída: Média de pesos.
*/
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
//Declarações
Scanner leitor = new Scanner(System.in);
double pesos, acumulador=0, media = 0;
int contador=1;
//Início
while(contador<=50) //teste da condição
{
System.out.println("Informe o "+ (contador)+"° peso: ");
pesos = leitor.nextDouble(); //lendo o peso
acumulador=acumulador+pesos; //acumulando os 50
contador++; //incrementando o contador
}
media=acumulador / 50; //calculando a média
System.out.println("Media = " + media); //mostrando a média
}
}
Observe que o laço irá repetir enquanto o "contador" estiver com um valor menor ou igual a 50.
No exemplo anterior tínhamos definido a quantidade de pesos que iríamos acumular, mas e se nós tivéssemos que acumular pesos e não soubéssemos a quantidade de pessoas, teríamos que admitir um "flag" de saída.
-
' flag ' é conhecido como um finalizador, em nosso próximo exemplo vamos
admitir o valor finalizador como nota negativa;
Observe o exemplo a seguir:
/*
SÍNTESE
Objetivo: Calcular a média de pesos de 50 pessoas usando a estrutura "while"
Entrada: 50 pesos.
Saída: Média de pesos.
*/
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
//Declarações
Scanner leitor = new Scanner(System.in);
float pesos, acumulador=0, media;
int contador=0;
//Início
//flag para sair
System.out.println("Informe um numero igual ou menor que zero para sair");
//não altera o contador
System.out.println("Informe o "+ (contador + 1) + " peso:");
pesos = leitor.nextFloat();
while(pesos>0)
{
acumulador=acumulador+pesos; //acumulando os pesos
contador++; //incrementando o contador
System.out.println("Informe o "+ (contador + 1) + " peso:");
pesos = leitor.nextFloat();
}
media=acumulador/contador; //calculando a média
System.out.println("Media = " +media);
System.out.println("Quantidade = " + contador); //mostrando a quantidade.
}
}
Nesse caso o usuário poderá calcular quantos pesos ele quiser, e para encerrar a repetição basta digitar um peso igual ou menor que zero.
Vamos agora começar nossos estudos com a última estrutura de repetição a ser vista o "do...while" que em partes é a mesma coisa do "while". O "do...while" se diferencia do "while" no que se diz respeito a condição de saída. Por exemplo: o "repita" em algoritmo executa o laço até que a condição se torne verdadeira, ou seja, enquanto falso, já em "C" e em "Java" o "do...while", executa enquanto verdadeiro assim como o "for" e o "while". Lembrando que o "do...while" também pode ser executado com "flag" (finalizador) de saída.
Neste exemplo vamos calcular a média de pesos de 30 pessoas usando o "do...while":
/*
SÍNTESE
Objetivo: Calcular a média de pesos de 30 pessoas usando a estrutura "do..while"
Entrada: 30 pesos.
Saída: Média de pesos.
*/
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
//Declarações
Scanner leitor = new Scanner(System.in);
float pesos, acumulador=0, media;
int contador=1;
//Início
do{
System.out.println("Informe o "+(contador)+" peso:");
pesos = leitor.nextFloat();
acumulador=acumulador+pesos; //acumulando os pesos
contador++; //incrementando o contador
} while(contador <= 30);
media=acumulador/contador;
System.out.println("Media = " +media); //mostrando a média
System.out.println("Quantidade = " +(contador-1)); //mostrando a quantidade.
}
}
No exemplo anterior tivemos que inicializar o contador que controla o laço "do..while" com o valor 1, porque como já havíamos comentado ele executa todos os comandos antes de testar, então quando ele fizer o primeiro teste ele já vai ter executado o bloco uma vez. E na hora de escrever a quantidade de execuções, ou seja, os pesos recebidos, ele iria escrever uma execução a mais se não estivesse sido decrementado, porque o contador é incrementado antes do teste.
Afinal qual a diferença entre o "while" e o "do...while"? O "do...while" faz o seu teste condicional somente no final do bloco, isso quer dizer que ele primeiro executa o que tem no bloco, e só depois testa se a condição tem valor verdadeiro ou falso.
Seguindo o exemplo no qual admitimos como "flag" um peso igual ou menor que zero, vamos fazê-lo novamente mas agora com o "do..while", para você ver a diferença entre o "while" e o "do...while"
/*
SÍNTESE
Objetivo: calcular o peso de X pessoas usando a estrutura "do while"
Entrada: pesos de cada pessoas e o flag como peso igual ou menor de zero.
Saída: a media de pesos.
*/
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
//Declarações
Scanner leitor = new Scanner(System.in);
float peso,acumulador=0,media;
int contador=0;
//Início
do{
System.out.println("Informe o "+(contador + 1)+" peso:");
peso = leitor.nextFloat();
acumulador=acumulador + peso;
contador++;
}while(peso>0);
media=acumulador/contador;
System.out.println("Media = " + media); //mostrando a média
System.out.println("Quantidade = " +contador); //mostrando a quantidade.
}
}
Como você pode observar o resultado não foi o esperado, porque como ele primeiro executou depois testou, quando foi digitado o valor negativo, além de contar o zero como um peso válido e acumular o valor zero, também contou o peso como um cálculo válido.
A forma correta seria:
/*
SÍNTESE
Objetivo: calcular o peso de X pessoas usando a estrutura "do while"
Entrada: pesos de cada pessoas e o flag como peso igual ou menor de zero.
Saída: a media de pesos.
*/
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
//Declarações
Scanner leitor = new Scanner(System.in);
float peso,acumulador=0,media;
int contador=0;
//Início
System.out.println("Informe o "+(contador + 1)+" peso:");
peso = leitor.nextFloat();
do {
acumulador=acumulador+peso;
contador++;
System.out.println("Informe o "+(contador+1)+" peso:");
peso = leitor.nextFloat(); //lendo a nova nota
}while(peso>0);
media=acumulador/contador;
System.out.println("Media = " + media); //mostrando a média
System.out.println("Quantidade = " + contador); //mostrando a quantidade.
}
}
- O comando "do...while" não é indicado para
executar tarefas que necessitam serem testadas antes de executar.
Atividade de Fixação
No intuito de fixar a aprendizagem iniciada por meio deste módulo e verificar como está sua compreensão sobre o mesmo, são sugeridos alguns exercícios de fixação para serem resolvidos. Clique no link de exercício ao lado, pois será por meio dele iniciada a lista de exercícios sobre os conteúdos estudados até este momento. Boa revisão sobre os mesmos!!