Estrutura Condicional em Java

Estrutura Condicional em Java

O Java contém três tipos de instruções de seleção. A instrução if realiza uma ação se uma condição for verdadeira ou pula a ação se a condição for falsa. A instrução if... else realiza uma ação se uma condição for verdadeira e realiza uma ação diferente se a condição for falsa. A instrução de seleção switch realiza uma de muitas ações diferentes, dependendo do valor de uma expressão.

A instrução if é uma instrução de uma única seleção porque seleciona ou ignora uma única ação (ou um único grupo de ações). A instrução if... else é chamada instrução de seleção dupla porque seleciona entre duas ações diferentes (ou grupos de ações). A instrução switch é chamada de instrução de seleção múltipla uma vez que seleciona entre muitas ações diferentes (ou grupos de ações).

Instrução de uma única seleção

A instrução IF é uma instrução de controle de uma única entrada e uma única saída.

Exemplo 1: verificar se um número fornecido pelo usuário é impar. Se for, exibir a mensagem “O número _____ informado é ímpar”.

import javax.swing.JOptionPane;

public class impar {

public static void main(String args[]){

int numero;

numero = Integer.parseInt(JOptionPane.showInputDialog ("Digite um número"));

/*avalia se o número é impar

* ao verificar se o resto da divsão por 2 * é igual a 1

*/

if (numero % 2 == 1){

JOptionPane.showMessageDialog(null,

"O número "+numero+" é ímpar");

} }

}

Exemplo 2: determinar o maior de dois números dados. Suponha que o primeiro deles é o maior, armazenando-o em uma variável MAIOR e depois, compare se os maior procurado é o segundo dos números dados, neste caso o conteúdo da variável MAIOR deve ser alterado.

//importa para utilizar a classe Scanner import java.util.*;

//o nome da nova classe public class maior_de_dois {

//a função principal

public static void main(String args[]){

//declara entrada como Scanner, para ler do teclado Scanner entrada = new Scanner(System.in);

//declara as três variáveis int a, b, maior;

//exibe uma mensagem solicitando a digitação dos números System.out.println("Digite dois números inteiros: ");

//armazena os números em a e b

a = entrada.nextInt();

b = entrada.nextInt();

//atribui a para maior maior = a;

//verifica se b é maior que a if (b > a){

//se for, atribui b para maior maior = b;

}

//exibe a mensagem com os dois valores digitados e o valor de maior

System.out.printf("O maior dos números %d e %d é %d", a,b,maior);

} }

Exemplo 3: ordenar os conteúdos das variáveis X e Y. Só há necessidade de se realizar alguma ação se o conteúdo de Y for maior que o conteúdo de X. Neste caso, deve-se fazer a permuta dos conteúdos de X e de Y.

//para usar a classe Graphics import java.awt.*;

//para usar a classe JApplet e JOptionPane import javax.swing.*;

//classe principal

public class ordena extends JApplet{

//declaração de variáveis de instância int X, Y;

//método para receber informações public void init(){

//variáveis que receberão dados digitados pelo usuário String num1, num2;

//variável auxiliar para ordenação int AUX;

//atribui o valor digitado para num1 e num2 num1 = JOptionPane.showInputDialog(

"Digite o valor de X");

num2 = JOptionPane.showInputDialog(

"Digite o valor de Y");

//atribui num1 e num2 para X e Y X = Integer.parseInt(num1);

Y = Integer.parseInt(num2);

//mostra os valores de X e Y na ordem que foram digitados JOptionPane.showMessageDialog(null,

"Números digitados: X "+X +" Y "+Y);

//verifica se X é maior que Y if (X > Y){//se for

//atribui X para a variável auxiliar AUX = X;

//atribui Y para X X = Y;

/*Y receberá o valor de X * que ficou armazenado * na variável auxiliar */

Y = AUX;

} }

public void paint(Graphics g){

super.paint(g);

//desenha um retângulo

g.drawRect(10, 10, 200, 30);

//escreve os valores ordenados de X e Y g.drawString("Números ordenados: X "+X

+" Y "+Y, 20, 30);

} }

A instrução if de uma única seleção realiza uma ação indicada somente quando a condição é true; caso contrário, a ação é pulada.

Instrução de seleção dupla

A instrução de seleção dupla if... else permite que o programação especifique uma ação a realizar quando a condição é verdadeira e uma ação diferente quando a condição é falsa.

Exemplo 1: a empresa XSoftwares Ltda. concedeu um bônus de 20% do valor do salário a todos os funcionários com tempo de trabalho na empresa igual ou superior a cinco anos, e 10% aos demais. Calcular e exibir o valor do bônus.

import javax.swing.JOptionPane;

public class bonus {

public static void main(String args[]){

//declaração das variáveis necessárias para a resolução do problema

float salario, premio;

int tempo;

//leitura (entrada) dos valores com as conversões adequadas salario = Float.parseFloat(JOptionPane.showInputDialog(

"Salário"));

tempo = Integer.parseInt(JOptionPane.showInputDialog(

"Tempo de empresa"));

//avalia a condição:

if (tempo >= 5){

//se o resultado for verdadeiro premio = salario * 0.20f;

} else{

//se o resultado for falso premio = salario * 0.10f;

}

JOptionPane.showMessageDialog(null, "O valor do bônus é:

"+premio);

} }

Exemplo 2: calcule a área de um triângulo, dados os comprimentos dos seus lados. Para os números serem comprimentos dos lados de um triângulo, cada um deles precisa ser menor que a soma dos outros dois.

//para usar a classe JOptionPane import javax.swing.*;

//para formatar números reais import java.text.DecimalFormat;

//classe principal

public class area_triangulo { //função principal

public static void main(String args[]){

//num_real recebe o formato de número decimal

DecimalFormat num_real = new DecimalFormat ("0.000");

//declaração das variáveis float x, y, z, area, semiper;

//atribuição dos valores para x, y e z

x = Float.parseFloat(JOptionPane.showInputDialog(

"Digite o primeiro lado: "));

y = Float.parseFloat(JOptionPane.showInputDialog(

"Digite o segundo lado: "));

z = Float.parseFloat(JOptionPane.showInputDialog(

"Digite o terceiro lado: "));

//verifica se cada lado é menor que a soma dos outros dois if ((x < y+z) && (y < x+z) && (z < x+y)){//se for

//acha o semiperímetro semiper = (x + y + z)/2;

//calcula a área

area = (float)Math.sqrt(semiper*

(semiper-x)*(semiper-y)*(semiper-z));

//exibe a área no formato de num_real JOptionPane.showMessageDialog(null,

"A área do triângulo é:

"+num_real.format(area));

}

else{//caso a verificação seja falsa

//exibe a mensagem informando que não é um triângulo JOptionPane.showMessageDialog(null,

"Os valores não podem ser comprimentos dos lados de um triângulo");

} }

}

Operador condicional

O Java fornece o operador condicional ?:, que pode ser utilizado no lugar de uma instrução if... else. Esse é o único operador ternário

do Java. Juntos, os operandos e o símbolo ?: formam uma expressão condicional.

O primeiro operando (à esquerda do ?) é uma expressão booleana

, o segundo operando (entre o ? e :) é o valor da expressão condicional se a expressão booleana for true, e o terceiro operando (à direita do :) é o valor da expressão condicional se a expressão booleana for avaliada como false.

Exemplo: imprimir ‘Aprovado’ se a média do aluno for maior ou igual a 60, mas imprimir ‘Reprovado’ se for menor que 60.

import java.util.Scanner;

public class mediaaluno {

public static void main(String args[]){

Scanner entrada = new Scanner(System.in);

float media;

System.out.print("Digite a média do aluno: ");

media = entrada.nextFloat();

System.out.println(media>=60 ? "Aprovado" : "Reprovado");

} }

Instruções if... else aninhadas

Um programa pode testar múltiplos casos colocando instruções if... else dentro de outras instruções if... else para criar instruções if... else aninhadas.

1 Significa que ele recebe três operandos.

2 Uma condição que avalia um valor boolean – true ou false.

Exemplo 1: receba três valores fornecidos pelo usuário que representarão os lados de um triângulo. Verifique se os valores formam um triângulo e classifique esse triângulo como:

a) Equilátero: três lados iguais.

b) Isósceles: dois lados iguais.

c) Escaleno: três lados diferentes.

Lembre-se de que, para formar um triângulo, nenhum dos lados pode ser igual a zero, um lado não pode ser maior do que a soma dos outros dois.

import javax.swing.*;

public class triangulo {

public static void main (String args[]){

//declara as variáveis A, B e C int A, B, C;

//inicializa as variáveis

A = Integer.parseInt(JOptionPane.showInputDialog("Lado A"));

B = Integer.parseInt(JOptionPane.showInputDialog("Lado B"));

C = Integer.parseInt(JOptionPane.showInputDialog("Lado C"));

//verifica se os lados não são iguais a zero if (A != 0 && B != 0 && C != 0){

//verifica se um lado não é maior que a soma dos outros dois

if (A+B > C && A+C>B && B+C > A){

//verifica se todos os lados são diferentes if (A != B && A != C && B != C){

JOptionPane.showMessageDialog(null,

"Escaleno");

}

//caso não sejam todos diferentes else{

//verifica se todos os lados são iguais if (A == B && B == C){

JOptionPane.showMessageDialog(null,

"Equilátero");

}

//caso não sejam todos iguais else{

JOptionPane.showMessageDialog(null,

"Isósceles");

} }

}

//caso a soma de dois lados não seja maior que um dos lados

else{

JOptionPane.showMessageDialog(null, "Não forma um triângulo");

} }

//caso algum dos lados seja igual a zero else{

JOptionPane.showMessageDialog(null, "Não forma um triângulo");

} }

}

Exemplo 2: determine as raízes de uma equação do segundo grau. Sabendo que uma quação ax

+ bx + c = 0 só tem raízes se b

–4ac 0. Além disso, para que ela seja do segundo grau, deve-se ter a 0.

//para ler do teclado import java.util.Scanner;

//para formatar número decimal import java.text.DecimalFormat;

//programa

public class eqgrau2 { //principal

public static void main(String args[]){

//declara entrada para ler do teclado Scanner entrada = new Scanner(System.in);

//declara num_real para números decimais

DecimalFormat num_real = new DecimalFormat("0.0");

//declaração de variáveis float a, b, c, x1, x2, delta;

//recebe os valores da equação

System.out.println("Digite os valores de a, b e c: ");

//atribui os valores às variáveis a = entrada.nextFloat();

b = entrada.nextFloat();

c = entrada.nextFloat();

//verifica se o valor de a é diferende de 0 if (a != 0){//se for diferente de 0

//calcula o valor de delta

delta = (float)Math.pow(b, 2)-4*a*c;

//verifica se delta é maior ou igual a 0 if (delta >= 0){//se for

//calcula as raízes

x1 = (-b+(float)Math.sqrt(delta))/2*a;

x2 = (-b-(float)Math.sqrt(delta))/2*a;

//exibe o valor das raízes

System.out.println("Raízes da equação: "+

num_real.format(x1)+" e "+

num_real.format(x2));

}

//se delta não for maior ou igual a 0 else{

//exibe a mensagem

System.out.println("A equação dada não tem raízes reais");

} }

//se a for igual a 0 else{

//exibe a mensagem

System.out.println("A equação não é do segundo grau");

} }

}

Operadores lógicos

As instruções IF, IF... else, e outras, requerem uma condição para determinar

como continuar o fluxo de um programa de controle. O Java fornece operadores lógicos

para permitir que os programadores formem condições mais complexas combinando

condições simples.

Operador E condicional (&&)

Se em algum ponto em um programa ambas condições precisam ser verdadeiras antes de escolher certo caminho de execução, utilizamos o operador && (E condicional).

Expressão 1 Expressão 2 Expressão 1 && expressão 2

false false false

false true false

true false false

true true true

Operador OU condicional (||)

Se um programa quiser assegurar que qualquer uma ou ambas as condições sejam verdadeiras antes de escolher certo caminho de execução, deve utilizar o operador

|| (OU condicional).

Expressão 1 Expressão 2 Expressão 1 || expressão 2

false false false

false true true

true false true

true true true

Operador E lógico booleano (&) e OU lógico booleano(|)

Esses operadores funcionam de modo idêntico aos operadores && e ||, com uma exceção: os operadores lógicos booleanos sempre avaliam seus dois operandos.

OU exclusivo lógico booleano (^)

Uma condição simples que contém o operador OU exclusivo lógico booleano é true se e somente se um de seus operandos for true e o outro for false. Se os dois operandos forem true ou somente forem false, a condição inteira é false.

Expressão 1 Expressão 2 Expressão 1 ^ expressão 2

false false false

false true true

true false true

true true false

Operador de negação lógica (!)

O operador ! permite ao programador inverter o significado de uma condição. O operador de negação lógica é um operador unário que tem apenas uma única condição como um operando. O operador lógico de negação é colocado antes de uma condição para escolher um caminho de execução se a condição original for false.

expressão !expressão false true

true false

Estrutura de seleção múltipla

Uma estrutura de seleção múltipla escolha é uma estrutura de seleção que funciona como um conjunto de opções para escolha. É também denominada estrutura de seleção homogênea.

O Java oferece a instrução de múltipla seleção switch para realizar diferentes

ações baseadas nos possíveis valores de uma variável de inteiro ou expressão. Cada

ação está associada com o valor de uma expressão integral constante (byte, short, int ou char) que a variável ou expressão em que a switch é baseada pode assumir.

Exemplo: ler o código de um produto e exibir seu nome de acordo com a tabela a seguir:

Código do produto Nome do produto

1 Caderno

2 Lápis

3 Borracha

Qualquer outro Diversos

//para mostrar caixas de diálogo import javax.swing.JOptionPane;

//programa

public class exibeproduto { //principal

public static void main(String args[]){

//declaração de variáveis int codigo;

String texto;

//atribuição do valor do código do produto

codigo = Integer.parseInt(JOptionPane.showInputDialog ("Digite o código do produto"));

//verifica o valor do código switch (codigo){

//caso seja 1 case 1 :

//atribui a string à variável texto texto = "O produto é caderno";

//interrompe o fluxo break;

//caso seja 2 case 2:

//atribui a string à variável texto texto = "O produto é lápis";

//interrompe o fluxo break;

//caso seja 3 case 3:

//atribui a string à variável texto texto = "O produto é borracha";

//interrompe o fluxo break;

//caso o código não seja 1, 2 ou 3 default :

//atribui a string à variável texto texto = "Diversos";

}

//exibe o conteúdo da variável texto

JOptionPane.showMessageDialog(null, texto);

} }

Instrução break

O Java fornece a instrução break para alterar o fluxo de controle. A instrução

break ocasiona sua saída imediata da instrução. A execução continua com a primeira

instrução depois da instrução de controle.

Exercícios

1. Preencha as lacunas:

a) A instrução __________ é utilizada para executar uma ação quando uma condição for verdadeira e outra quando essa condição for falsa.

b) O Java requer que todas as variáveis tenham um __________.

c) A instrução __________ seleciona entre múltiplas ações com base nos possíveis valores de uma variável ou expressão integrais.

d) O operador __________ pode ser utilizado para assegurar que duas condições são verdadeiras antes de escolher certo caminho de execução.

2. Determine se cada uma das seguintes afirmações é verdadeira ou falsa. Se falso, explique por que.

a) Um algoritmo é um procedimento para resolver um problema em termos das ações a serem executadas e a ordem em que essas ações são executas.

b) Um conjunto de instruções dentro de um par de parênteses é chamado bloco.

c) Uma instrução de seleção especifica que uma ação deve ser repetida enquanto algumas condições permanecem verdadeiras.

d) O pseudocódigo ajuda um programador a pensar sobre um programa antes de tentar escrevê-lo em uma linguagem de programação.

e) O caso default é requerido na instrução de seleção switch.

f) A instrução break é necessária no último caso de uma instrução de seleção switch.

g) A expressão ((x>y)&&(a<b)) é verdadeira se x>y for verdadeira ou a<b for verdadeira.

h) Uma expressão contendo o operador || é verdadeira se um ou ambos de seus operandos forem verdadeiros.

i) Para testar uma série de valores em uma instrução switch, utilize um hífen (–) entre os valores inicial e final da série em um rótulo case.

3. Escreva instruções Java para realizar cada uma das seguintes tarefas:

a) Teste se a variável contador é maior do que 10. Se for, imprima

“Contador é maior que 10”.

b) Calcule o resto após q ser dividido por divisor e atribua o resultado a q.

c) Calcule o valor de 2.5 elevado à potência de 3, utilizando o método pow.

4. Escreva uma instução Java para realizar cada uma das seguintes tarefas:

a) Declare as variáveis soma e x que serão do tipo inteiro.

b) Atribua 1 à variável x.

c) Atribua 0 à variável soma.

d) Adicione a variável x à variável soma e atribua o resultado à variável soma.

e) Imprima “A soma é: ” seguido pelo valor da variável soma.

Bibliografia

Java: como programar

H. M. Deitel, P. J. Deitel

São Paulo: Pearson Prentice Hall, 2005 Estrutura de dados e algoritmos em Java

Michael Goodrich, Roberto Tamassia Porto Alegre: Bookman, 2007

Lógica de programação e estrutua de dados, com aplicações em Java

Sandra Puga, Gerson Rissetti

São Paulo: Pearson Prentice Hall, 2009