PROGRAMAÇÃO

ORIENTADA A
OBJETOS
Comandos de
seleção
Carlos Wagner de Queiroz

OBJETIVOS DE APRENDIZAGEM

> Conceituar estrutura de seleção no contexto da programação.

> Descrever as estruturas de seleção simples, composta e aninhada.
> Definir as estruturas de seleção de múltipla escolha.

Introdução
Os comandos de seleção têm o poder de modificar a estruturação sequen-
cial de uma programação por meio de tomadas de decisões estabelecidas
por condições. Essas condições, sustentadas pelos operadores relacionais e
operadores lógicos, determinam o fluxo e o comportamento de um algoritmo.
Todas as linguagens de programação usam estruturas condicionais; no Java
são usados os comandos if-else e switch-case para executar diferentes
blocos de programação, pré-selecionados com base em certas condições.
Neste capítulo, você vai conhecer as estruturas de seleção condicionais, ver
como diferenciar as estruturas de deleção simples das compostas, reconhecer
como uma estrutura composta pode ser organizada de forma aninhada para
aumentar o leque de opções condicionais e conhecer as estruturas de seleção
de múltipla escolha.
2 Comandos de seleção

Comandos de seleção
Um algoritmo nada mais é do que a reprodução de situações que acontecem
no mundo real. Todos os dias quando acordamos, nos deparamos com várias
situações em que precisamos tomar decisões. Se escovamos os dentes antes
de tomar o café ou se tomamos o café e só depois escovamos os dentes, qual
roupa escolher para sair, quais músicas ouvir no caminho ao trabalho, se vamos
pegar uma rota ou outra para chegar ao nosso destino, ou seja, o tempo todo
estamos selecionando as ações que faremos. E, ao escolhermos uma ação,
muitas vezes outra ação corriqueira é interrompida e as consequências de
nossa seleção levam a um desvio do fluxo normal.
Um algoritmo de programação segue um fluxo lógico que pode se modificar
de acordo com as tomadas de decisões, ou seja, as seleções que são feitas
no meio do percurso até que o resultado desse algoritmo seja alcançado.
Autores diversos usam nomenclaturas diversas para descrever os coman-
dos de seleção; alguns chamam de desvio condicional, outros de controle
de programa, estruturas condicionais, comandos de decisões, enfim, aqui
chamaremos de comandos de seleção.
Os comandos de seleção são, portanto, aqueles que permitem que o
algoritmo mude o seu fluxo normal de acordo com as decisões tomadas no
caminho. Para um programa de computador tomar uma decisão é necessário
que seja estabelecida uma condição.
Uma condição pode produzir respostas verdadeiras (true) ou falsas
(false), de acordo com as situações apresentadas. A relação lógica exis-
tente entre os elementos de uma condição é conseguida com a utilização dos
operadores relacionais (MANZANO; COSTA JÚNIOR, 2014).
A Figura 1 apresenta a tabela de operadores relacionais.

Figura 1. Operadores relacionais.

Fonte: Horstmann (2009, p. 191).
 Comandos de seleção 3

São condições válidas as seguintes estruturas relacionais: A == B, A != B,

A > B, A < B, A >= B, A <= B ou A == 5, A != 5, A > 5, A < 5, A >= 5,
A <= 5.
Note que somente os operadores (> e <) são iguais aos da notação ma-
temática. Isso acontece porque não existem no teclado teclas para ≥, ≤
ou ≠. O operador == pode ser confuso, já que existe o símbolo =, porém,
em Java ele é usado para atribuir valor à uma variável, por exemplo: a = 2
(atribui 2 à variável a). Já no exemplo if (a == 2), está sendo feito um
teste: se a é igual a 2. Resumindo, = é usado para atribuição e == para teste
de igualdade.
O comando if é utilizado para implementar uma decisão e tem duas
partes: uma condição e um corpo. Se a condição for verdadeira, o corpo do
comando será executado. Vamos pensar em um exemplo real. Suponha que
precisamos implementar um algoritmo para identificar crianças conforme sua
faixa etária. Para esse primeiro exemplo, caso a idade da pessoa seja menor
que 14 anos, ela será classificada como criança. Vejamos um fluxograma com
esse modelo, como mostra a Figura 2.

Figura 2. Fluxograma para o comando if — condição simples.

Perceba que, quando a condição foi verdadeira, ela executou um corpo;

já a condição falsa não gerou nenhum processo, finalizando o algoritmo.
Ou seja, uma decisão quando verdadeira ou falsa ocasiona, ou não, a execução
do evento posterior.
4 Comandos de seleção

Mesmo quando só existe uma condição verdadeira e outra falsa é acon-

selhável, segundo as regras de usabilidade, que seja dado um feedback ao
cliente em cada ação que ele efetuar, ou seja, uma condição pode gerar a
execução de um novo processo ou ao menos um aviso sobre o comportamento
do algoritmo.
Usando, ainda, como exemplo o nosso problema, classificar pessoas
conforme a faixa etária, analise a Figura 2. Se a condição for falsa, em vez de
simplesmente não acontecer nada, direcionaremos a um corpo que emitirá
uma mensagem antes de o algoritmo ser finalizado. A simulação dessa nova
hipótese pode ser vista no fluxograma da Figura 3.

Figura 3. Fluxograma para o comando if-else — condição composta.

E se quiséssemos fazer as classificações de todas as pessoas, sendo

menores de 14 anos agrupados como crianças, entre 15 e 17 anos como ado-
lescentes, de 18 a 60 anos como adultos e acima de 60 anos como idosos?
Seria possível fazer usando apenas seleção condicional? Vejamos como ficaria
um fluxograma para esse problema na Figura 4.
 Comandos de seleção 5

Figura 4. Fluxograma para o comando if-else — condição aninhada.

Observe que na Figura 4 existem várias condições que reportarão um

valor verdadeiro e somente uma para o valor falso. Essa é uma caracterís-
tica usada pelo comando if que permite considerar várias seleções em um
mesmo algoritmo.
Vimos, portanto, que algumas condicionais podem desviar o fluxo de
um algoritmo e/ou alterar suas variáveis. Esses exemplos de estrutura de
seleção são determinados com o auxílio de operadores relacionais e os
conceitos de condicionais implementados para cada situação. Deve ficar
claro, portanto, que é possível que se estabeleçam controles de decisão a
partir de uma seleção. Nos exemplos citados, percebemos que as respostas
falsas às condições podem tanto determinar a inércia do algoritmo como
provocar uma mudança, assim como a resposta verdadeira. Quanto a esses
tipos de resposta, podemos classificar as estruturas condicionais em simples,
compostas e aninhadas, conforme reforçaremos na próxima seção.

Condições simples, compostas e aninhadas

As estruturas de controle são utilizadas para especificar a ordem em que as
instruções devem ser executadas. Os controles de seleção ou condicional
são um dos tipos de estruturas de controle.
Por padrão, a estrutura é de sequência, ou seja, a menos que seja especi-
ficado de outra forma, o computador executa automaticamente as instruções
seguindo a estrutura de sequência, isto é, uma após outra, linha após linha,
de cima para baixo.
6 Comandos de seleção

Para mostrarmos na prática como funcionam os controles de seleção,

vamos usar os fluxogramas da seção anterior para implementarmos algoritmos
que respondam à situação-problema apresentada por eles.

O comando if tem como função executar uma instrução quando

uma condição for verdadeira ou falsa. Sua sintaxe é:

if (condição)

   instrução 1 executada quando for verdadeira;

   instrução 2 executada quando for verdadeira;

   instrução N executada quando for verdadeira;

else

   instrução executada quando condição for falsa;

Estrutura de seleção simples

Um desvio condicional será simples quando temos uma condição que desvia
a execução do programa caso o resultado lógico avaliado de certa condição
seja verdadeiro. Se o resultado logico avaliado for falso, nada acontecerá,
e o programa simplesmente segue o seu fluxo de execução (MANZANO; COSTA
JÚNIOR, 2014).
O fluxograma ilustrado na Figura 2 simula o comportamento de uma
condição simples; na prática uma solução seria:

package estruturasdeselecao;
import java.util.Scanner;
public class SelecaoSimples
{
   public static void main(String[] args)
 Comandos de seleção 7

  {
    Scanner scan = new Scanner(System.in);

     System.out.println("Entre com o Valor a sua idade");

    int idade = scan.nextInt();

    if (idade <=14) {

      System.out.println("Você foi classificada como
criança!");
    }
  }
}

A Figura 5 ilustra as saídas simulando um valor de entrada 8, ao qual

retornará a mensagem programada, caso o valor seja menor que 14; um valor
acima de 14 não retorna nenhuma mensagem.

Figura 5. Saídas com valores abaixo de 14 e acima de 14, respectivamente.

Para atribuir valores a uma variável usando o teclado, no Java,

a partir do Java 1.5 podemos usar a classe Scanner. Usaremos essa
classe para implementar as operações de entrada pelo teclado em alguns dos
exemplos mostrados neste capítulo. Para utilizar a classe Scanner em uma
aplicação Java, é preciso importar o pacote java.util, instanciar e criar um
objeto Scanner. O System.in complementa System.out. e int lê os valores
através do teclado. nextInt requer o valor. Para os exemplos mostrados aqui,
trabalharemos com o pacote Java JDK instalado e a IDE Eclipse.
8 Comandos de seleção

Estrutura de seleção composta

Em uma condição composta usa-se o if ... else; nesse tipo de estrutura,
quando a condição é verdadeira são executadas as instruções que ficam no
bloco entre o if e o else; quando é falsa, são executadas as instruções
posicionadas após o else, conforme a sintaxe apresentada no box Saiba mais.
O fluxograma ilustrado na Figura 3 simula o comportamento de uma
condição composta; na prática, uma solução seria:

package estruturasdeselecao;
import java.util.Scanner;
public class SelecaoComposta
{
     public static void main(String[] args)
    {
      Scanner scan = new Scanner(System.in);

       System.out.println("Entre com o Valor a sua idade");

      int idade = scan.nextInt();

      if (idade <=14) {

        System.out.println("Você foi classificada como
criança!");
      }
      else {
        System.out.println("Você não é uma criança!");
        }
    }
}

A Figura 6 ilustra as saídas simulando um valor de entrada 8, ao qual retor-

nará a mensagem programada caso o valor seja menor que 14; um valor acima
de 14 retorna o bloco de instruções após o else, quando a condição for falsa.
 Comandos de seleção 9

Figura 6. Saídas com valores abaixo de 14 e acima de 14, respectivamente.

Estrutura de seleção aninhada

Segundo Schildt (2015), um if aninhado é uma instrução if que é alvo de
outro if ou else. Os ifs aninhados são muito comuns em programação.
O importante a lembrar sobre ifs aninhados em Java é o fato de que uma
instrução else será sempre referente à instrução if mais próxima que estiver
dentro do mesmo bloco e ainda não estiver associada a um else.
O fluxograma ilustrado na Figura 4 simula o comportamento de uma
estrutura de seleção aninhada; na prática, uma solução seria:

package estruturasdeselecao;
import java.util.Scanner;
public class SelecaoAninhada
{
     public static void main(String[] args)
    {
      Scanner scan = new Scanner(System.in);

       System.out.println("Entre com o Valor a sua idade");

      int idade = scan.nextInt();

      if (idade <=12) {

        System.out.println("Você foi classificada como
criança!");
      }
      else if (idade <=17){
        System.out.println("Você foi classificado como
adolescente!");
      }
10 Comandos de seleção

      else if (idade <=60) {

        System.out.println("Você foi classificado como
adulto(a)!");
      }
      else {
        System.out.println("Você foi classificado como
idoso(a)!");
      }
    }
}

A Figura 7 ilustra as saídas simulando um valor de entrada 8, 15, 58 e 60 e

seus respectivos resultados em uma estrutura de seleção aninhada.

Figura 7. Saídas com valores diversos.

Apresentamos com exemplos práticos os comandos (sintaxe) das estru-

turas de seleção simples e composta (if, if-else) e a estrutura aninhada.
Simulamos algumas situações em que podem ser usados os comandos de
seleção, mas você deve ter notado que o if é um ótimo comando para situa-
ções distintas. Percebam, no entanto, que a estrutura aninhada, embora seja
uma boa solução para várias situações, detém de muitas linhas de comando
e, em alguns casos, pode não suprir com a necessidade de múltiplas escolhas.
Na próxima seção, mostraremos uma solução de múltipla escolha que facilitará
a tomada de decisões problemáticas que envolvam esse tipo de seleção.
 Comandos de seleção 11

Estrutura de seleção de múltipla escolha

Na seleção múltipla, como o próprio nome já diz, entre vários blocos,
se escolhe um. Diferente da simples, em que é executado apenas um bloco
de comandos, ou da composta, em que se executa um ou outro, na múltipla,
entre várias opções, você escolhe uma para executar.
No comando switch a seleção é feita, entre diferentes blocos de instru-
ções, usando uma comparação de igualdade. Do ponto de vista operacional
de funcionalidade de um computador, o uso da instrução switch prevê
apenas condições com operador relacional do tipo “igual a”. Em situações
operacionais que envolvam outras formas de relações lógicas, deve-se fazer
uso da instrução if na forma sequencial ou encadeada.
Vejamos a sintaxe do comando switch case:

switch (expressão)
{
case constante1:
instruções;
break;
case constante2:
instruções;
break;
...
default:
instruções;
}

O valor da expressão (ou variável) é testado na ordem, em relação aos

valores das constantes especificadas nos comandos case. Essa comparação
é somente de igual, ou seja, o resultado da expressão é igual a constante1,
constante2, etc. Nos cases, teremos as constantes, e, quando uma coinci-
dência for encontrada, a sequência de comandos associada aquele case
será executada até que o comando break ou o fim do comando switch
seja alcançado. O comando default é executado se nenhuma coincidência
for detectada. Embora seja recomendado o seu uso, o default é opcional.
Vamos à prática. Para o nosso exemplo, vamos criar um algoritmo simples
para entender como o switch case funciona. A ideia aqui é que, quando o
usuário colocar um número de 1 a 12, seja impresso o nome do mês, ou seja,
se ele digitar 1, imprime janeiro, 2 imprime fevereiro e assim sucessivamente.
12 Comandos de seleção

import java.util.Scanner;
public class MultiplaEscolha {
    
        public static void main(String[] args)
        {
            Scanner scan = new Scanner(System.in);
            
            System.out.println("Entre com a mês");
            int mes = scan.nextInt();
                        
            switch(mes) {
            case 1:
            System.out.println("Janeiro");
            break;
            case 2:
            System.out.println("Fevereiro");
            break;
            case 3:
            System.out.println("Março");
            break;
            case 4:
            System.out.println("Abril");
            break;
            case 5:
            System.out.println("Maio");
            break;
            case 6:
            System.out.println("Junho");
            break;
            case 7:
            System.out.println("Julho");
            break;
            case 8:
            System.out.println("Agosto");
            break;
            case 9:
 Comandos de seleção 13

            System.out.println("Setembro");
            break;
            case 10:
            System.out.println("Outrubro");
            break;
            case 11:
            System.out.println("Novembro");
            break;
            case 12:
            System.out.println("Dezembro");
            break;
            default: System.out.println("Mês
inválido");
            }
        }
}

Veja, na Figura 8, as saídas com o uso do break ao final de cada expres-

são e sem o uso do break. Perceba que, se não usarmos o break, todos os
comandos após o case selecionado serão implementados.

Figura 8. Saídas com valor 6, com e sem break.

Em outro exemplo, precisamos criar um algoritmo que imprima o semestre

conforme o mês, por exemplo, se o mês for 3, imprimirá “Primeiro Semestre!”,
se o mês for 10, imprimirá “Segundo semestre”; neste caso, poderíamos usar
o switch da seguinte forma:
14 Comandos de seleção

import java.util.Scanner;
public class MultiplaEscolha {
    
        public static void main(String[] args)
        {
          Scanner scan = new Scanner(System.in);

          System.out.println("Entre com a mês");

          int mes = scan.nextInt();

          switch(mes) {
            case 1:
            case 2:
            case 3:
            case 4:
            case 5:
            case 6:
             System.out.println("Primeiro Semestre!");
            break;
            case 7:
            case 8:
            case 9:
            case 10:
            case 11:
            case 12:
            System.out.println("Segundo Semestre!");
            break;
            default: System.out.println("Mês
inválido");
          }
        }
}
 Comandos de seleção 15

A situação-problema apresentada no fluxograma da Figura 4 e resol-

vida por meio do if-else aninhado não poderia ser respondida com
o comando switch usando os operadores relacionais <,>. O switch trabalha
apenas com o “igual a” e com constantes nos cases, portanto, não seria possível
uma solução em que as opções necessitassem analisar a instrução: idade>=12,
por exemplo, pois essa expressão resulta em valores entre 0 e 12, o que, na
matemática, chamamos de valores contínuos. O switch só é recomendado
para valores discretos, ou seja, 0, 1, 2, 3, 4, etc. Nesse caso, uma solução seria
apontar todas as idades possíveis, o que geraria um código muito grande, sendo
mais simples o uso do código sugerido na subseção anterior.

Neste capítulo, vimos as várias formas de trabalhar os controles de se-

leção, desde os controles condicionais (if e if-else) até o uso da seleção
de múltipla escolha Switch. Você pôde perceber que, para cada situação-
-problema, um comando é indicado. O ideal é que analise inicialmente a
possibilidade do uso do switch e só depois, caso não for possível trabalhar
com ele, passe a usar outra opção, como o if-else. Usando os comandos
de seleção da forma correta, você conseguirá dinamizar os seus algoritmos
e dar ao usuário poder de decisão.

Referências
HORSTMANN, C. Conceitos de computação com Java. 5. ed. Porto Alegre: Bookman,
2009. 720 p.
MANZANO, J. A. N. G.; COSTA JÚNIOR, R. A. Programação de computadores com Java.
São Paulo: Érica, 2014. 160 p.
SCHILDT, H. Java para iniciantes: crie, compile e execute programas Java rapidamente.
6. ed. Porto Alegre: Bookman, 2015. 704 p.

Leituras recomendadas
FURGERI, S. Java 8: ensino didático, desenvolvimento e implementação de aplicações.
São Paulo: Érica, 2015. 320 p.
RUBIRA, C. M. F.; GUERRA, P. A. C.; GOMES, L. A. F. Programação orientada a objetos
usando Java. Rio de Janeiro: Ciência Moderna, 2020. 256 p.