Estrutura Condicional em Java

Linguagem de Programação – 1
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();
http://erinaldosn.wordpress.com
2 – Estrutura Condicional
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);
http://erinaldosn.wordpress.com
Linguagem de Programação – 3
//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
http://erinaldosn.wordpress.com
4 – Estrutura Condicional
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ário1 do Java. Juntos, os
operandos e o símbolo ?: formam uma expressão condicional.
O primeiro operando (à esquerda do ?) é uma expressão booleana2, 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
2
Significa que ele recebe três operandos.
Uma condição que avalia um valor boolean – true ou false.
http://erinaldosn.wordpress.com
Linguagem de Programação – 5
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");
}
}
}
http://erinaldosn.wordpress.com
6 – Estrutura Condicional
Exemplo 2: determine as raízes de uma equação do segundo grau. Sabendo que uma
quação ax2 + bx + c = 0 só tem raízes se b2–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.
http://erinaldosn.wordpress.com
Linguagem de Programação – 7
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
http://erinaldosn.wordpress.com
8 – Estrutura Condicional
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.
http://erinaldosn.wordpress.com
Linguagem de Programação – 9
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
http://erinaldosn.wordpress.com
10 – Estrutura Condicional
São Paulo: Pearson Prentice Hall, 2009
http://erinaldosn.wordpress.com