Você está na página 1de 5

Estruturas de Decisão em Java

a) Comando Condicional (if)

O comando condicional ajuda a ilustrar um importante conceito de Java: os


blocos de códigos. O comando if funciona em Java de forma muito parecida com
os de outras linguagens. Na verdade, ele é sintaticamente idêntico ao if de C e
C++.

Sua forma mais simples é a seguinte:

if (condição)
Comando;

Neste exemplo, condição é uma expressão booleana. Se for verdadeira a


(true), então o comando será executado. Se a condição for falsa (false), o
comando será ignorado. Eis um exemplo:

if (var<10)
JOptionPane.showMessageDialog(null,“Var é menor que 10.”);

Neste caso, se var contiver um valor inferior a 10, a expressão condicional


será verdadeira, e a linha contendo showMessageDialog() será executada. Se var
contiver um valor maior ou igual a 10, a linha contendo showMessageDialog() será
ignorada. Eis um programa que ilustra o comando if:

1. import javax.swing.JOptionPane;
2. public class Mostraif
3. {
4. public static void main(String[] args)
5. {
6. int i = 50;
7. int j = 100;
8. if (i<j)
9. JOptionPane.showMessageDialog(null, "i e menor que j.");
10. i *= 2;
11. if (i == j)
12. JOptionPane.showMessageDialog(null,"Agora i e igual a j.");
13. i *= 2;
14. if (i>j)
15. JOptionPane.showMessageDialog(null, "Agora i e maior que j.");
16. if (i == j)
17. JOptionPane.showMessageDialog(null,"Isso não será exibido.");
/* Esta linha não será exibida. */
18. }
19. }
A saída exibida por esse programa é a seguinte:

I e menor que j.
Agora i é igual a j.
Agora i é maior que j.

1. O comando Condicional Composto (if/else)

Quando usamos a estrutura if ela só funcionará se a condição for true. A


estrutura if/else avalia se a expressão é true retornando um valor e se for false
retorna outro – exemplo:

1. import javax.swing.JOptionPane;
2. public class MostraStatus
3. {
4. public static void main (String args [])
5. {
6. double num;
7. num = Double.parseDouble(JOptionPane.showInputDialog("Entre com
um valor real"));
8. if (num == 0) /* se for fornecido um valor nulo, a seguinte mensagem
exibida */
9. {
10. JOptionPane.showMessageDialog(null,"Você deve fornecer um valor
não nulo");
11. }
12. if (num>=6.0)
13. JOptionPane.showMessageDialog(null,"Aprovado");
14. else
15. JOptionPane.showMessageDialog(null,"Reprovado");
16. }
17. }

Entrando com o valor de 5.5 para a média, a saída exibida será:


Reprovado

Perceba que o resultado mudará de acordo com o número digitado, como


está definido na linha 7:

num = Double.parseDouble(JOptionPane.showInputDialog("Entre com um valor


real"));

2. Operador Condicional Ternário ?:

O operador ternário nos dá uma maneira compacta de expressar uma


simples instrução if-else.
Este operador consiste em dois operadores separando a expressão em três
diferentes expressões.

Forma geral:

condição ? expressão_1 : expressão2

A condição consiste em uma expressão lógica avaliada como verdadeira ou


falsa. A condição é avaliada e se verdadeira a expressão condicional toda assume
o valor da expressão_1, se falsa a expressão assume o valor da expressão_2.

Eis um exemplo:

max= (num1>num2)?num1:num2

Esta operação é equivalente à construção if-else seguinte, mas bem mais


compacta.

if (num1>num2)
Max=num1;
else
Max=num2;

Pegamos o exemplo de item 9.2.1, usando o operador ternário ele ficaria da


seguinte maneira:

1. import javax.swing.JOptionPane;
2. public class MostraStatus2
3. {
4. public static void main (String args [ ] )
5. {
6. double num;
7. num = Double.parseDouble(JOptionPane.showInputDialog("Entre com um
valor real"));
8. JOptionPane.showMessageDialog(null,num>=6 ? "Aprovado" :
"Reprovado");
9. }
10. }

Como vemos, o uso do operador ternário nos poupa tempo na execução de


condições simples.

3. Comando switch
O comando switch de Java permite que a execução de um programa
escolha uma entre múltiplas ramificações. Ele representa uma forma fácil de dirigir
a execução para diferentes partes do código com base no valor de uma
expressão. Por isso, muitas vezes é melhor utilizar um switch do que uma longa
série de comandos if-else-if. Eis a forma geral de um comando switch:

switch (expressão)
{
case valor 1:
/ / Seqüência de comandos 1.
break;
case valor2:
/ / Seqüência de comandos 2.
break;
.
.
.
case valorN:
/ / Seqüência de comandos N.
break;
default:
/ / Seqüência de comandos default.
} / / Fim do switch

A expressão pode retornar qualquer tipo simples; cada um dos valores


especificados nos comandos case deve ser compatível com o tipo de expressão.
O valor de cada case deve ser um valor literal único (isto é, deve ser uma
constante e não uma variável). Valores case duplicados não são permitidos.
O comando switch funciona da seguinte maneira: o valor da expressão é
comparado com os valores literais de cada um dos comandos case. Se os valores
forem iguais, a seqüência de código que se segue ao comando case
correspondente é executada. Se nenhuma das constantes for igual ao valor da
expressão, o comando default será executado. Contudo, o comando default é
opcional. Se nenhum case for igual ao valor da expressão e não houver um
comando default, nenhuma ação será executada.
O comando break é usado dentro de um switch para terminar uma
seqüência de comandos. Quando um comando break for encontrado, a execução
saltará para a primeira linha de código que vem depois do comando switch. Ou
seja, break tem o efeito de provocar um salto para fora do comando switch.

Eis um exemplo de uso do comando switch:

1. import javax.swing.JOptionPane;
2. public class SwitchDemo
3. {
4. public static void main (String[] args)
5. {
6. for (int i=0; i<6; i++)
7. switch (i)
8. {
9. case 0:
10. JOptionPane.showMessageDialog(null, "i=0");
11. break;
12. case 1:
13. JOptionPane.showMessageDialog(null, "i=1");
14. break;
15. case 2:
16. JOptionPane.showMessageDialog(null, "i=2");
17. break;
18. case 3:
19. JOptionPane.showMessageDialog(null, "i=3");
20. break;
21. default:
22. JOptionPane.showMessageDialog(null, "i=4");
23. }
24. }
25. }

A saída produzida por este programa é:

i=0
i=1
i=2
i=3
i=4
i=4

Cada vez que atravessamos o loop for (linha 6), os comandos associados
com o case, cuja constante é igual ao valor de i, são executados (linhas 9 a 20).
Todos os outros cases são ignorados. Depois que i assume um valor maior que 3,
nenhum case corresponde ao valor de i, de modo que os comandos executados
são os que correspondem a default (linha 21).