aula-4-estrutura-condicional

Prévia do material em texto

COLÉGIO ESTADUAL ULYSSES GUIMARÃES 
CURSO TÉCNICO PROFISSIONALIZANTE EM INFORMÁTICA 
 
 
ERINALDO SANCHES NASCIMENTO 
 
 
 
 
 
 
 
 
 
 
ESTRUTURA CONDICIONAL 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
FOZ DO IGUAÇU 
2013 
LISTA DE QUADROS 
 
 
QUADRO 1 – PSEUDOCÓDIGO PARA VERIFICAR SE UM NÚMERO É ÍMPAR ...... 7 
QUADRO 2 – CLASSE JAVA QUE VERIFICA SE UM NÚMERO É ÍMPAR ................. 7 
QUADRO 3 – PSEUDOCÓDIGO PARA DETERMINAR O MAIOR DE DOIS 
NÚMEROS USANDO VARIÁVEL ......................................................................... 8 
QUADRO 4 – CLASSE JAVA QUE DETERMINA O MAIOR DE DOIS NÚMEROS 
USANDO VARIÁVEL ............................................................................................ 9 
QUADRO 5 – PSEUDOCÓDIGO COM ALGORITMO QUE ORDENA OS 
CONTEÚDOS DAS VARIÁVEIS X E Y ................................................................ 10 
QUADRO 6 – CLASSE JAVA QUE ORDENA OS CONTEÚDOS DE DUAS 
VARIÁVEIS, NA ORDEM X E Y .......................................................................... 10 
QUADRO 7 – PSEUDOCÓDIGO COM O ALGORITMO PARA CALCULAR O VALOR 
DO BÔNUS ......................................................................................................... 13 
QUADRO 8 – CLASSE JAVA QUE CALCULA E EXIBE O VALOR DO BÔNUS ........ 13 
QUADRO 9 – PSEUDOCÓDIGO PARA CALCULAR A ÁREA DO TRIÂNGULO ....... 14 
QUADRO 10 – CLASSE JAVA QUE CALCULA A ÁREA DO TRIÂNGULO ............... 15 
QUADRO 11 – CLASSE JAVA USANDO OPERADOR CONDICIONAL TERNÁRIO 17 
QUADRO 12 – PSEUDOCÓDIGO QUE VERIFICA E CLASSIFICA UMA TRIÂNGULO 
VÁLIDO ............................................................................................................... 18 
QUADRO 13 – CLASSE JAVA QUE VERIFICA E CLASSIFICA UM TRIÂNGULO 
VÁLIDO ............................................................................................................... 19 
QUADRO 14 – PSEUDOCÓDIGO QUE ENCONTRA AS RAÍZES DE UMA 
EQUAÇÃO DO SEGUNDO GRAU ...................................................................... 21 
QUADRO 15 – APLICATIVO JAVA QUE CALCULA E EXIBE AS RAÍZES DE UMA 
EQUAÇÃO DO SEGUNDO GRAU ...................................................................... 22 
QUADRO 16 – PSEUDOCÓDIGO PARA RETORNAR DADOS DE UMA TABELA ... 25 
QUADRO 17 – APLICATIVO JAVA QUE RETORNA DADOS DE UMA TABELA COM 
SELEÇÃO MÚLTIPLA ......................................................................................... 26 
 
 
LISTA DE TABELAS 
 
 
TABELA 1 – OPERADORES RELACIONAIS UTILIZADO EM PSEUDOCÓDIGO. ..... 2 
TABELA 2 – OPERADORES RELACIONAIS EM JAVA. ............................................. 2 
TABELA 3 – OPERADORES LÓGICOS UTILIZADOS EM PSEUDOCÓDIGO. ........... 3 
TABELA 4 – TABELA-VERDADE COM OS OPERADORES LÓGICOS E, OU E NÃO.
 .............................................................................................................................. 3 
TABELA 5 – OPERADORES LÓGICOS EM JAVA. ..................................................... 4 
TABELA 6 – EXEMPLOS DE OPERAÇÕES LÓGICAS. .............................................. 4 
TABELA 7 – ORDEM DE PRECEDÊNCIA DOS OPERADORES. ............................... 5 
 
 
LISTA DE FIGURAS 
 
 
FIGURA 1 – FLUXOGRAMA DE UMA ESTRUTURA CONDICIONAL SIMPLES. ....... 6 
FIGURA 2 – FLUXOGRAMA PARA ESTRUTURA DE SELEÇÃO COMPOSTA. ....... 12 
FIGURA 3 – FLUXOGRAMA PARA ESTRUTURA CONDICIONAL ENCADEADA. ... 18 
FIGURA 4 – FLUXOGRAMA DA ESTRUTURA CONDICIONAL DE MÚLTIPLA 
ESCOLHA. .......................................................................................................... 25 
 
 
SUMÁRIO 
 
 
4 ESTRUTURA CONDICIONAL .................................................................................. 1 
4.1 EXPRESSÕES BOOLEANA .................................................................................. 1 
4.1.1 Operadores Relacionais ..................................................................................... 2 
4.1.2 Operadores Lógicos ........................................................................................... 3 
4.1.3 Precedência dos Operadores ............................................................................. 4 
4.2 ESTRUTURAS DE SELEÇÃO ............................................................................... 5 
4.2.1 Estrutura Condicional Simples ........................................................................... 6 
4.2.2 Estrutura Condicional Composta ...................................................................... 12 
4.2.2.1 Operador Condicional.................................................................................... 16 
4.2.3 Estruturas Condicionais Endadeadas .............................................................. 17 
4.2.4 Estruturas Condicionais de Múltipla Escolha .................................................... 23 
4.3 EXERCÍCIOS ...................................................................................................... 27 
4.4 TRABALHOS PRÁTICOS .................................................................................... 35 
4.5 REFERÊNCIA BIBLIOGRÁFICA ......................................................................... 38 
1 
 
4 ESTRUTURA CONDICIONAL 
 
 
Normalmente, as instruções de um programa são executadas uma após a 
outra, na ordem em que são escritas. Esse processo é chamado de execução 
sequencial. Várias declarações Java permitem especificar que a próxima instrução a 
ser executada não seja necessariamente a próxima na sequência. Isto é chamado 
de transferência de controle. 
A ordem em que os comandos são executados em um programa em 
execução é chamada de fluxo de controle. Como na maioria das linguagens de 
programação, Java lida com o fluxo de controle com declarações de ramificação e 
looping. 
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). 
 
 
4.1 EXPRESSÕES BOOLEANA 
 
 
As declarações condicionais em Java permitem ao programador decidir qual 
instrução será executada em seguida. 
Cada decisão é baseada em uma expressão booleana, também chamada de 
condição, no qual uma expressão é avaliada como verdadeira ou falsa. O resultado 
da expressão determina que instrução será executada em seguida. 
Todos os condicionais são baseados em expressões booleanas, que utilizam 
operadores relacionais e lógicos para tomar decisões. 
2 
 
4.1.1 Operadores Relacionais 
 
 
A tabela 1 apresenta os operadores relacionais utilizados em pseudocódigo 
para estabelecer uma relação de comparação entre valores ou expressões. O 
resultado dessa comparação é sempre um valor lógico (booleano) verdadeiro ou 
falso. 
Operador Representação 
Maior > 
Maior ou igual >= 
Menor < 
Menor ou igual <= 
Igual a = 
Diferente de < > 
Tabela 1 – Operadores relacionais utilizado em pseudocódigo. 
 
Java também tem vários operadores relacionais que permitem ao orograma 
decidir a ordenação relativa entre dois valores. A tabela 2 mostra os operadores 
relacionais utilizado em Java. 
Operador Representação 
Maior que > 
Maior ou igual a >= 
Menor que < 
Menor ou igual a <= 
Igual a == 
Não igual a != 
Tabela 2 – Operadores relacionais em Java. 
 
Qualquer tipo em Java podem ser comparados usando o testede igualdade 
(==) e desigualdade (! =). Somente os tipos numéricos (inteiro, ponto flutuante e 
operandos de caracteres) podem ser comparados com os operadores de ordenação. 
Os operadores relacionais têm menor precedência que os operadores 
aritméticos. Portanto, as operações aritméticas são avaliadas em primeiro lugar, 
3 
 
seguidas pelas operações de igualdade e relacionais. Como sempre, os parênteses 
podem ser usados para especificar explicitamente a ordem de avaliação. 
 
 
4.1.2 Operadores Lógicos 
 
 
A tabela 3 apresenta os operadores lógicos utilizados em pseudocódigo para 
concatenar ou associar expressões que estabelecem uma relação de comparação 
entre valores. O resultado dessas expressões é sempre um valor lógico (booleano) 
verdadeiro ou falso. 
Operador Representação 
e .e. 
ou .ou. 
não .não. 
Tabela 3 – Operadores lógicos utilizados em pseudocódigo. 
 
A avaliação das expressões nas quais são utilizados os operadores lógicos 
está resumida na tabela-verdade apresentada na tabela 4. 
Operador 
 .e. .ou. .não 
Expressão A = 5 B < > 9 A = 5 .e. B < > 9 A = 5 .ou. B < > 9 .não. A = 5 
Resultados 
possíveis 
.v. .v. .v. .v. .f. 
.v. .f. .f. .v. .f. 
.f. .v. .f. .v. .v. 
.f. .f. .f. .f. .v. 
Tabela 4 – Tabela-verdade com os operadores lógicos E, OU e NÃO. 
 
Os operadores lógicos booleanos mostrados na tabela 5 operam apenas em 
operandos booleanos. Todos os operadores lógicos binários combinam dois valores 
booleanos para formar um valor booleano resultante. 
Operador Representação 
& E lógico 
| OU lógico 
4 
 
Operador Representação 
^ XOR lógico (OU exclusivo) 
|| OU 
&& E 
! Unário NÃO lógico 
&= Atribuição E 
|= Atribuição OU 
^= Atribuição XOR 
Tabela 5 – Operadores lógicos em Java. 
 
A tabela 6 mostra o efeito de cada operação lógica: 
A B A | B A & B A ^ B 
False False False False False 
True False True False True 
Fase True True False True 
True True True True False 
Tabela 6 – Exemplos de operações lógicas. 
 
 
4.1.3 Precedência dos Operadores 
 
 
Quando, em um algoritmo ou programa, uma expressão envolve mais de um 
operador, a ordem da avaliação das expressões segue a precedência deles. A 
precedência dos operadores define a ordem para execução das operações. 
Para as operações aritméticas temos a seguinte ordem, que deve ser 
avaliada sempre da esquerda para a direita. 
1. São calculados os fatoriais. 
2. São calculadas as funções, potência e raiz quadrada. 
3. São calculadas as multiplicações e divisões. 
4. São calculadas as adições e subtrações. 
Exemplo: 
5 
 
Considerando B ← 5 e A ← 2. Substituindo as variáveis pelos valores 
atribuídos: . 
1. As expressões tem a mesma precedência. Então, calcula-
se , obtém-se o valor 4 e em seguida 10mod3 e obtém-se 1, reconstruindo 
a expressão com os valores obtidos: K ← 2 + 5 * 4 – 1. 
2. Calcula-se 5 * 4 = 20, reconstruindo a expressão, tem-se K ← 2 + 20 – 1. 
3. Todas as operações resultantes têm a mesma precedência. Dessa maneira 
calculando da esquerda para a direta o resultado final é: K ← 21. 
A tabela 7 mostra a ordem de precedência dos operadores, da mais alta 
para a mais baixa. Os parênteses são usados para alterar a precedência de uma 
operação. Em operações lógicas o operador .e. tem prioridade sobre o operador 
.ou.. 
Operador Função realizada 
( ), [ ] Parênteses e colchetes são usados para agrupar expressões, 
determinando precedência. 
^ ou ** Operador aritmético de potenciação. 
*, / Operadores aritméticos de multiplicação e divisão. 
+, – Operadores aritméticos de adição e subtração. 
← Operador de atribuição. 
=, <, >, <=, >=, < > Operadores relacionais. 
.não. Operador lógico de negação. 
.e. Operador lógico e 
.ou. Operador lógico ou 
Tabela 7 – Ordem de precedência dos operadores. 
 
 
4.2 ESTRUTURAS DE SELEÇÃO 
 
 
As estruturas de seleção ou decisão são utilizadas quando existe a 
necessidade de verificar condições para a realização de uma instrução ou de uma 
sequência de instruções. Os testes de seleção também podem ser utilizados para 
verificar opções de escolha. 
6 
 
A verificação de que uma condição é satisfeita e, a partir daí, a decisão em 
relação à execução ou não de uma determinada sequência de comandos é 
chamada de estrutura de seleção, estrutura de decisão ou comando de seleção. 
Exemplo: supondo que uma pessoa esteja jogando um jogo de computador, 
para que o jogador passe de uma fase (etapa) para outra, é necessário verificar se 
ele atingiu a pontuação exigida. Assim, existe uma condição para a realização de 
uma sequência de instruções para liberar o acesso à próxima fase do jogo. 
Ao final do jogo, uma pergunta é feita: “Deseja continuar jogando?”. O 
jogador poderá escolher entre as respostas sim ou não. 
Uma decisão é o resultado da avaliação de uma expressão booleana. Toda 
condição pode ser encarada como uma pergunta que pode ter a resposta verdadeiro 
(.v.) ou falso (.f.). 
As estruturas de seleção podem ser do tipo simples, composto ou 
encadeado. 
 
 
4.2.1 Estrutura Condicional Simples 
 
 
São utilizadas para verificar se dada condição é atendida. Se for, um 
conjunto de instruções deverá ser executado. Se não for, o fluxo de execução do 
algoritmo seguirá após o fim do bloco de decisão. 
A sintaxe básica da decisão unidirecional é: 
 se (condição) então [inicio do bloco de decisão] 
 conjunto de instruções 
 fim-se [fim do bloco de decisão] 
O conjunto de instruções só será executado se a condição for verdadeira. A 
figura 1 apresenta o fluxograma de uma estrutura condicional simples. Uma 
condição é uma comparação que possui dois valores possíveis, verdadeiro ou falso. 
 
Figura 1 – Fluxograma de uma estrutura condicional simples. 
condição Conjunto de 
instruções 
Fim 
.V
. 
.F
. 
7 
 
A instrução if é uma instrução de controle de uma única entrada e uma única 
saída. 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. 
Exemplo 1: Desenvolvimento de um algoritmo e programa Java que verifique 
se um número fornecido pelo usuário é ímpar. Se for, exibir a mensagem “O número 
_____ informado é ímpar”. 
O quadro 1 apresenta o pseudocódigo para a solução do problema descrito 
no exemplo 1. 
 
Quadro 1 – Pseudocódigo para verificar se um número é ímpar 
1 ALGORITMO N_IMPAR 
2 DECLARE 
3 NUMERO : INTEIRO 
4 LEIA (NUMERO) 
5 SE (NUMERO MOD 2 = 1) ENTÃO 
6 ESCREVA (“O número informado é impar”) 
7 FIM-SE 
8 FIM Nº_IMPAR 
 
O quadro 2 apresenta a classe Java que utiliza caixas de diálogo para 
receber o número do usuário e devolver a mensagem informando se o número é 
ímpar. 
 
Quadro 2 – Classe Java que verifica se um número é ímpar 
1 import javax.swing.JOptionPane; 
2 public class impar { 
3 public static void main(String args[]){ 
4 int numero; 
5 numero = Integer.parseInt(JOptionPane.showInputDialog 
6 ("Digite um número")); 
7 /*avalia se o número é impar 
8 * ao verificar se o resto da divsão por 2 
9 * é igual a 1 
8 
 
10 */ 
11 if (numero % 2 == 1){ 
12 JOptionPane.showMessageDialog(null, 
13 "O número "+numero+" é ímpar"); 
14 } 
15 } 
16 } 
 
Exemplo 2: Desenvolvimento de um algoritimo e programa Java que 
determine 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 o maior procurado é 
o segundo dos números dados, neste caso o conteúdo da variável MAIOR deve ser 
alterado. 
O quadro 3 apresenta o pseudocódigo que representa o algoritmo para 
resolver o problema enunciado acima. 
 
Quadro 3 – Pseudocódigo para determinar o maior de dois números usando variável 
1 ALGORITMO MAIOR_DE_DOIS 
2 DECLARE 
3 A, B, MAIOR : INTEIRO 
4 ESCREVA (“Digite dois números: ”) 
5 LEIA (A, B) 
6 MAIOR ← A 
7 SE (B > A) ENTÃO 
8 MAIOR ← B 
9 FIM-SE 
10 ESCREVA (“O maior dosnúmeros”, A, “e”, B, “é”, MAIOR) 
11 FIM MAIOR_DE_DOIS 
 
O quadro 4 apresenta a classe Java que determina o maior de dois números 
recebidos via console. 
 
 
9 
 
Quadro 4 – Classe Java que determina o maior de dois números usando variável 
1 //importa para utilizar a classe Scanner 
2 import java.util.*; 
3 //o nome da nova classe 
4 public class maior_de_dois { 
5 //a função principal 
6 public static void main(String args[]){ 
7 //declara entrada como Scanner, para ler do teclado 
8 Scanner entrada = new Scanner(System.in); 
9 //declara as três variáveis 
10 int a, b, maior; 
11 //exibe uma mensagem solicitando a digitação dos números 
12 System.out.println("Digite dois números inteiros: "); 
13 //armazena os números em a e b 
14 a = entrada.nextInt(); 
15 b = entrada.nextInt(); 
16 //atribui a para maior 
17 maior = a; 
18 //verifica se b é maior que a 
19 if (b > a){ 
20 //se for, atribui b para maior 
21 maior = b; 
22 } 
23 //exibe a mensagem com os dois valores digitados e o valor de 
maior 
24 System.out.printf("O maior dos números %d e %d é %d", 
a,b,maior); 
25 } 
26 } 
 
Exemplo 3: Desenvolvimento de um algoritmo e programa que ordene os 
conteúdos das variáveis X e Y. Só há necessidade de se realizar alguma ação se o 
10 
 
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. 
O quadro 5 apresenta o pseudocódigo para o problema descrito acima. 
 
Quadro 5 – Pseudocódigo com algoritmo que ordena os conteúdos das variáveis X e Y 
1 ALGORITMO ORDENA 
2 DECLARE 
3 X, Y, AUX : INTEIRO 
4 ESCREVA (“Digite dois números: ”) 
5 LEIA (X, Y) 
6 ESCREVA (“Números digitados: X= ”, X, “ Y= ”, Y) 
7 SE (X > Y) ENTÃO 
8 AUX = X 
9 X = Y 
10 Y = AUX 
11 FIM-SE 
12 ESCREVA (“Números ordenados: X= ”, X, “Y= ”, Y); 
13 FIM ORDENA 
 
O quadro 6 apresenta a classe Java que faz a permuta dos conteúdos de X 
e Y caso o conteúdo de Y seja maior que o de X. 
 
Quadro 6 – Classe Java que ordena os conteúdos de duas variáveis, na ordem X e Y 
1 //para usar a classe Graphics 
2 import java.awt.*; 
3 //para usar a classe JApplet e JOptionPane 
4 import javax.swing.*; 
5 //classe principal 
6 public class ordena extends JApplet{ 
7 //declaração de variáveis de instância 
8 int X, Y; 
9 //método para receber informações 
11 
 
10 public void init(){ 
11 //variáveis que receberão dados digitados pelo usuário 
12 String num1, num2; 
13 //variável auxiliar para ordenação 
14 int AUX; 
15 //atribui o valor digitado para num1 e num2 
16 num1 = JOptionPane.showInputDialog( 
17 "Digite o valor de X"); 
18 num2 = JOptionPane.showInputDialog( 
19 "Digite o valor de Y"); 
20 //atribui num1 e num2 para X e Y 
21 X = Integer.parseInt(num1); 
22 Y = Integer.parseInt(num2); 
23 //mostra os valores de X e Y na ordem que foram digitados 
24 JOptionPane.showMessageDialog(null, 
25 "Números digitados: X "+X 
26 +" Y "+Y); 
27 //verifica se X é maior que Y 
28 if (X > Y){//se for 
29 //atribui X para a variável auxiliar 
30 AUX = X; 
31 //atribui Y para X 
32 X = Y; 
33 /*Y receberá o valor de X 
34 * que ficou armazenado 
35 * na variável auxiliar 
36 */ 
37 Y = AUX; 
38 } 
39 } 
40 public void paint(Graphics g){ 
41 super.paint(g); 
42 //desenha um retângulo 
12 
 
43 g.drawRect(10, 10, 200, 30); 
44 //escreve os valores ordenados de X e Y 
45 g.drawString("Números ordenados: X "+X 
46 +" Y "+Y, 20, 30); 
47 } 
48 } 
 
 
4.2.2 Estrutura Condicional Composta 
 
 
A estrutura de seleção composta prevê dois conjuntos de instruções para 
serem realizados de acordo com a avaliação da condição: um conjunto de instruções 
que será realizado quando a condição resultar verdadeiro e um conjunto de 
instruções para resultado falso. 
se (condição) então 
 conjunto de instruções A 
senão 
 conjunto de instruções B 
fim-se 
A figura 2 apresenta o fluxograma para estrutura de seleção composta. Se a 
condição for verdadeira, será executado o conjunto de instruções A; caso contrário, 
se a condição for falsa, será executado o conjunto de instruções B. 
 
 
Figura 2 – Fluxograma para estrutura de seleção composta. 
 
.V. 
.F. Conjunto de 
instruções B 
condição Conjunto de 
instruções A 
Fim 
13 
 
A instrução de seleção dupla if-else permite que o programa especifique 
uma ação a realizar quando a condição é verdadeira e uma ação diferente quando a 
condição é falsa. 
Exemplo 4: A empresa XSoftwares 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. O quadro 7 e o quadro 8 apresentam o 
pseudocódigo e uma classe Java capaz de calcular e exibir o valor do bônus. Para 
resolver o problema é necessário conhecer o valor do salário e o tempo de serviço 
do funcionário. 
 
Quadro 7 – Pseudocódigo com o algoritmo para calcular o valor do bônus 
1 ALGORITMO PREMIO 
2 DECLARE 
3 SALARIO, BONUS : REAL 
4 TEMPO : INTEIRO 
5 LER (SALARIO) 
6 LER (TEMPO) 
7 SE (TEMPO >= 5) ENTÃO 
8 BONUS ← SALARIO * 0.20 
9 SENÃO 
10 BONUS ← SALARIO * 0.10 
11 FIM-SE 
12 ESCREVA (“O valor do bônus é ”, BONUS) 
13 FIM PREMIO 
 
Quadro 8 – Classe Java que calcula e exibe o valor do bônus 
1 import javax.swing.JOptionPane; 
2 public class bonus { 
3 public static void main(String args[]){ 
4 //declaração das variáveis necessárias para a resolução do 
problema 
5 float salario, premio; 
6 int tempo; 
14 
 
7 //leitura (entrada) dos valores com as conversões adequadas 
8 salario = Float.parseFloat(JOptionPane.showInputDialog( 
9 "Salário")); 
10 tempo = Integer.parseInt(JOptionPane.showInputDialog( 
11 "Tempo de empresa")); 
12 //avalia a condição: 
13 
14 if (tempo >= 5){ 
15 //se o resultado for verdadeiro 
16 premio = salario * 0.20f; 
17 } 
18 else{ 
19 //se o resultado for falso 
20 premio = salario * 0.10f; 
21 } 
22 JOptionPane.showMessageDialog(null, "O valor do bônus é: 
"+premio); 
23 } 
24 } 
 
Exemplo 5: Desenvolvimento do algoritmo e programa Java que 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. 
O quadro 9 apresenta o pseudocódigo com o algoritmo que calcula a área 
do triângulo a partir do comprimento dos seus lados. 
 
Quadro 9 – Pseudocódigo para calcular a área do triângulo 
1 ALGORITMO AREA_TRIANGULO 
2 DECLARE 
3 X, Y, Z, AREA, SEMIPER : REAL 
4 ESCREVA (“Digite os comprimentos dos lados do triângulo: ”) 
5 LEIA (X, Y, Z); 
15 
 
6 SE (X < Y + Z) .E. (Y < X + Z) .E. (Z < X + Y) ENTÃO 
7 SEMIPER ← (X + Y + Z) / 2 
8 AREA ← 
9 ESCREVA (“A área do triângulo é:”,AREA:0:2); 
10 SENÃO 
11 ESCREVA (“Os valores não podem ser comprimentos dos lados de um 
triângulo”); 
12 FIM-SE 
13 FIM AREA_TRIANGULO 
 
O quadro 10 mostra a classe Java que calcula a área do triângulo. Essa 
classe usa caixas de diálogos para receber os valores dos lados do triângulo. O 
resultado da área do triângulo é exibido no formato com 3 casas decimais. 
 
Quadro 10 – Classe Java que calcula a área do triângulo 
1 //para usar a classe JOptionPane 
2 import javax.swing.*; 
3 //para formatar números reais 
4 import java.text.DecimalFormat; 
5 //classe principal 
6 public class area_triangulo { 
7 //função principal 
8 public static void main(String args[]){ 
9 //num_real recebe o formato de número decimal 
10 DecimalFormat num_real = new DecimalFormat ("0.000"); 
11 //declaração das variáveis 
12 float x, y, z, area, semiper; 
13 //atribuição dos valores para x, y e z 
14 x = Float.parseFloat(JOptionPane.showInputDialog( 
15"Digite o primeiro lado: ")); 
16 y = Float.parseFloat(JOptionPane.showInputDialog( 
17 "Digite o segundo lado: ")); 
16 
 
18 z = Float.parseFloat(JOptionPane.showInputDialog( 
19 "Digite o terceiro lado: ")); 
20 //verifica se cada lado é menor que a soma dos outros dois 
21 if ((x < y+z) && (y < x+z) && (z < x+y)){//se for 
22 //acha o semiperímetro 
23 semiper = (x + y + z)/2; 
24 //calcula a área 
25 area = (float)Math.sqrt(semiper* 
26 (semiper-x)*(semiper-y)*(semiper-z)); 
27 //exibe a área no formato de num_real 
28 JOptionPane.showMessageDialog(null, 
29 "A área do triângulo é: 
"+num_real.format(area)); 
30 } 
31 else{//caso a verificação seja falsa 
32 //exibe a mensagem informando que não é um triângulo 
33 JOptionPane.showMessageDialog(null, 
34 "Os valores não podem ser comprimentos 
dos lados de um triângulo"); 
35 } 
36 } 
37 } 
 
 
4.2.2.1 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 booleana, o 
segundo operando (entre o ? e :) é o valor da expressão condicional se a expressão 
 
1
 Significa que ele recebe três operandos. 
17 
 
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 6: O quadro 11 apresenta uma classe Java que imprime ‘Aprovado’ 
se a média do aluno for maior ou igual a 60, mas imprime ‘Reprovado’ se for menor 
que 60. 
 
Quadro 11 – Classe Java usando operador condicional ternário 
1 import java.util.Scanner; 
2 public class mediaaluno { 
3 public static void main(String args[]){ 
4 Scanner entrada = new Scanner(System.in); 
5 float media; 
6 System.out.print("Digite a média do aluno: "); 
7 media = entrada.nextFloat(); 
8 System.out.println(media>=60 ? "Aprovado" : "Reprovado"); 
9 } 
10 } 
 
 
4.2.3 Estruturas Condicionais Endadeadas 
 
 
Uma estrutura de seleção encadeada é uma sequência de testes de 
seleção, os quais serão executados ou não de acordo com o resultado das 
condições e com o encadeamento dos testes. 
Um teste de seleção pode ter dois conjuntos de instruções, um para 
resultado verdadeiro e outro para falso, porém esses conjuntos de instruções podem 
conter outros testes de seleção, que, por sua vez, também podem conter outros, e 
assim por diante. 
se (condição_1) então 
 se (condição_2) então 
 conjunto de instruções A 
 senão 
 conjunto de instruções B 
18 
 
 fim-se 
senão 
 conjunto de instruções C 
fim-se 
Se a condição_1 resultar verdadeiro, então será realizado o teste da 
condição_2; se esse teste resultar verdadeiro, será realizado o conjunto de 
instruções A; se resultar falso, será realizado o conjunto de instruções B. Se o teste 
da condição_1 resultar falso, será realizado o conjunto de instruções C. 
A figura 3 apresenta o fluxograma que representa a descrição acima. 
 
 
Figura 3 – Fluxograma para estrutura condicional encadeada. 
 
Um programa Java pode testar múltiplos casos colocando instruções if-else 
dentro de outras instruções if-else criando instruções if-else aninhadas. 
Exemplo 7: Desenvolvimento de um algoritmo e programa que recebe três 
valores fornecidos pelo usuário, que representam os lados de um triângulo. Verifica-
se, então, se os valores formam um triângulo, classificando-o como: 
a) equilátero: três lados iguais; 
b) isósceles: dois lados iguais; 
c) escaleno: três lados diferentes 
Deve-se lembrar que, para formar um triângulo, nenhum dos lados pode ser 
igual a zero, um lado não pode ser maior que a soma dos outros dois. O quadro 12 
representa o pseudocódigo para resolver o exemplo, e o quadro 13 apresenta a 
classe Java que verifica e classifica um triângulo válido. 
 
Quadro 12 – Pseudocódigo que verifica e classifica uma triângulo válido 
.V. 
.F. 
Conjunto de 
instruções B 
Condição
_2 
Conjunto de 
instruções A 
Fim Condição
_1 
.V. 
Conjunto de 
instruções C 
.F. 
19 
 
1 ALGORITMO TRIANGULO 
2 DECLARE 
3 A, B, C : INTEIRO 
4 LER (A, B, C) 
5 SE (A <> 0) .E. (B <> 0) .E. (C <> 0) ENTÃO 
6 SE (A + B > C) .E. (A + C > B) .E. (B + C > A) ENTÃO 
7 SE (A <> B) .E. (A <> C) .E. (B <> C) ENTÃO 
8 ESCREVA (“É um triângulo escaleno”) 
9 SENÃO 
10 SE (A = B) .OU. (B = C) ENTÃO 
11 ESCREVA (“É um triângulo equilátero”) 
12 SENÃO 
13 ESCREVA (“É um triângulo isósceles”) 
14 FIM-SE 
15 FIM-SE 
16 SENÃO 
17 ESCREVA (“Os valores não formam um triângulo”) 
18 FIM-SE 
19 ESCREVA (“Os valores não formam um triângulo”) 
20 FIM-SE 
21 FIM TRIANGULO 
 
Quadro 13 – Classe Java que verifica e classifica um triângulo válido 
1 import javax.swing.*; 
2 public class triangulo { 
3 public static void main (String args[]){ 
4 //declara as variáveis A, B e C 
5 int A, B, C; 
6 //inicializa as variáveis 
7 A = Integer.parseInt(JOptionPane.showInputDialog("Lado A")); 
8 B = Integer.parseInt(JOptionPane.showInputDialog("Lado B")); 
9 C = Integer.parseInt(JOptionPane.showInputDialog("Lado C")); 
20 
 
10 //verifica se os lados não são iguais a zero 
11 if (A != 0 && B != 0 && C != 0){ 
12 //verifica se um lado não é maior que a soma dos outros 
dois 
13 if (A+B > C && A+C>B && B+C > A){ 
14 //verifica se todos os lados são diferentes 
15 if (A != B && A != C && B != C){ 
16 JOptionPane.showMessageDialog(null, 
"Escaleno"); 
17 } 
18 //caso não sejam todos diferentes 
19 else{ 
20 //verifica se todos os lados são iguais 
21 if (A == B && B == C){ 
22 JOptionPane.showMessageDialog(null, 
"Equilátero"); 
23 } 
24 //caso não sejam todos iguais 
25 else{ 
26 JOptionPane.showMessageDialog(null, 
"Isósceles"); 
27 } 
28 } 
29 } 
30 //caso a soma de dois lados não seja maior que um dos 
lados 
31 else{ 
32 JOptionPane.showMessageDialog(null, "Não forma 
um triângulo"); 
33 } 
34 } 
35 //caso algum dos lados seja igual a zero 
36 else{ 
21 
 
37 JOptionPane.showMessageDialog(null, "Não forma um 
triângulo"); 
38 } 
39 } 
40 } 
 
Exemplo 8: Desenvolvimento de um algoritmo e aplicativo Java que 
determina as raízes de uma equação do segundo grau. Sabendo que uma equação 
ax2 + bx + c = 0 só tem raízes reais se b2 – 4ac 0. Além disso, para que ela seja 
do segundo grau, deve-se ter a 0. 
No quadro 14 é apresentado o pseudocódigo que resolve o problema do 
exemplo acima. O quadro 15 cria o aplicativo Java que executa o algoritmo. 
 
Quadro 14 – Pseudocódigo que encontra as raízes de uma equação do segundo grau 
1 ALGORITMO EQ_GRAU2 
2 DECLARE 
3 A, B, C, X1, X2, DELTA : REAL; 
4 LEIA (A, B, C) 
5 SE (A <> 0) ENTÃO 
6 DELTA ← 
7 SE DELTA >= 0 ENTÃO 
8 
 X1 ← 
9 
 X2 ← 
10 ESCREVA (“Raízes da equação: ”, X1, “e ”, X2) 
11 SENÃO 
12 ESCREVA (“A equação dada não tem raízes reais”) 
13 FIM-SE 
14 SENÃO 
15 ESCREVA (“A equação não é do segundo grau”) 
16 FIM-SE 
17 FIM EQ_GRAU2 
 
22 
 
 
 
 
Quadro 15 – Aplicativo Java que calcula e exibe as raízes de uma equação do segundo grau 
1 //para ler do teclado 
2 import java.util.Scanner; 
3 //para formatar número decimal 
4 import java.text.DecimalFormat; 
5 //programa 
6 public class eqgrau2 { 
7 //principal 
8 public static void main(String args[]){ 
9 //declara entrada para ler do teclado 
10 Scanner entrada = new Scanner(System.in); 
11 //declara num_real para números decimais 
12 DecimalFormat num_real = new DecimalFormat("0.0"); 
13 //declaração de variáveis 
14 float a, b, c, x1, x2, delta; 
15 //recebeos valores da equação 
16 System.out.println("Digite os valores de a, b e c: "); 
17 //atribui os valores às variáveis 
18 a = entrada.nextFloat(); 
19 b = entrada.nextFloat(); 
20 c = entrada.nextFloat(); 
21 //verifica se o valor de a é diferende de 0 
22 if (a != 0){//se for diferente de 0 
23 //calcula o valor de delta 
24 delta = (float)Math.pow(b, 2)-4*a*c; 
25 //verifica se delta é maior ou igual a 0 
26 if (delta >= 0){//se for 
27 //calcula as raízes 
28 x1 = (-b+(float)Math.sqrt(delta))/2*a; 
23 
 
29 x2 = (-b-(float)Math.sqrt(delta))/2*a; 
30 //exibe o valor das raízes 
31 System.out.println("Raízes da equação: "+ 
32 num_real.format(x1)+" e "+ 
33 num_real.format(x2)); 
34 } 
35 //se delta não for maior ou igual a 0 
36 else{ 
37 //exibe a mensagem 
38 System.out.println("A equação dada não tem raízes 
reais"); 
39 } 
40 } 
41 //se a for igual a 0 
42 else{ 
43 //exibe a mensagem 
44 System.out.println("A equação não é do segundo grau"); 
45 } 
46 } 
47 } 
 
 
4.2.4 Estruturas Condicionais de Múltipla Escolha 
 
 
Uma estrutura de seleção de múltipla escolha (ou estrutura de seleção 
homogênea) funciona como um conjunto de opções para escolha. Existem duas 
maneiras para representá-la: 
 Utilizando a estrutura condicional encadeada da instrução if; 
se (variável = tal_coisa_1) então 
 faça conjunto de instruções A 
senão 
 se (variável = tal_coisa_2) então 
24 
 
 faça conjunto de instruções B 
 senão 
 se (variável = tal_coisa3) então 
 faça conjunto de instruções C 
 senão 
 faça conjunto de instruções D 
 fim-se 
 fim-se 
fim-se 
 Utilizando a estrutura com seleção de múltipla escolha da instrução 
switch case. 
escolha variável 
 caso tal_coisa_1: 
 faça conjunto de instruções A 
 caso tal_coisa_2 
 faça conjunto de instruções B 
 caso tal_coisa_3 
 faça conjunto de instruções C 
 caso contrário 
 faça conjunto de instruções D 
fim-escolha 
A segunda opção é a mais indicada. Cada rótulo da estrutura possui o 
próprio bloco e é separado dele pela marca : (dois pontos). Todos os rótulos são 
dispostos um nível de indentação2 acima no nível onde está a palavra chave escolha 
(switch). Blocos de instruções dispõem-se um nível de indentação acima daquele 
onde estão os rótulos. 
Após a avaliação da expressão (ou variável) de controle um valor inteiro é 
obtido, o rótulo com este valor selecionado e por fim o bloco executado. Quando a 
execução encerra, ocorre um desvio para fora da estrutura para que outros blocos 
não sejam executados. A figura 4 mostra a representação do fluxograma para a 
estrutura condicional de múltipla escolha. 
 
2
 Espaço entre a margem e o início do texto em um parágrafo. 
25 
 
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. 
 
 
Figura 4 – Fluxograma da estrutura condicional de múltipla escolha. 
 
Exemplo 9: Desenvolvimento de um algoritmo e aplicativo Java que leia o 
código de um produto e exiba seu nome de acordo com a tabela abaixo: 
Código do produto Nome do produto 
1 Caderno 
2 Lápis 
3 Borracha 
Qualquer outro Diversos 
O quadro 16 apresenta o pseudocódigo que cria o algoritmo sugerido 
usando seleção múltipla, e o quadro 17 apresenta o aplicativo Java que executa o 
algoritmo. 
 
Quadro 16 – Pseudocódigo para retornar dados de uma tabela 
1 ALGORITMO PRODUTO 
2 DECLARE 
3 CODIGO : INTEIRO 
4 LEIA (CODIGO) 
5 ESCOLHA CODIGO 
Tal_coisa_
1 
Tal_coisa_
2 
Tal_coisa_
3 
Conjunto 
de instruções A 
Conjunto 
de instruções A 
Conjunto 
de instruções A 
Conjunto 
de instruções D 
... 
... 
... 
26 
 
6 CASO 1 : ESCREVA (“O produto é caderno”) 
7 CASO 2 : ESCREVA (“O produto é lápis”) 
8 CASO 3 : ESCREVA (“O produto é borracha”) 
9 CASO CONTRÁRIO : ESCREVA (“Diversos”) 
10 FIM-ESCOLHA 
11 FIM PRODUTO 
Quadro 17 – Aplicativo Java que retorna dados de uma tabela com seleção múltipla 
1 //para mostrar caixas de diálogo 
2 import javax.swing.JOptionPane; 
3 //programa 
4 public class exibeproduto { 
5 //principal 
6 public static void main(String args[]){ 
7 //declaração de variáveis 
8 int codigo; 
9 String texto; 
10 //atribuição do valor do código do produto 
11 codigo = Integer.parseInt(JOptionPane.showInputDialog 
12 ("Digite o código do produto")); 
13 //verifica o valor do código 
14 switch (codigo){ 
15 //caso seja 1 
16 case 1 : 
17 //atribui a string à variável texto 
18 texto = "O produto é caderno"; 
19 //interrompe o fluxo 
20 break; 
21 //caso seja 2 
22 case 2: 
23 //atribui a string à variável texto 
24 texto = "O produto é lápis"; 
25 //interrompe o fluxo 
27 
 
26 break; 
27 //caso seja 3 
28 case 3: 
29 //atribui a string à variável texto 
30 texto = "O produto é borracha"; 
31 //interrompe o fluxo 
32 break; 
33 //caso o código não seja 1, 2 ou 3 
34 default : 
35 //atribui a string à variável texto 
36 texto = "Diversos"; 
37 } 
38 //exibe o conteúdo da variável texto 
39 JOptionPane.showMessageDialog(null, texto); 
40 } 
41 } 
 
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. 
 
 
4.3 EXERCÍCIOS 
 
 
1. Dadas as expressões a seguir, identifique o resultado verdadeiro ou falso que 
cada uma delas retornaria, em função dos valores dados. 
A ← 2; B ← 7; 
a) A = 3 .e. B = 7 
b) A = 2 .e. B = 5 
c) A < 3 .ou. B < > 7 
d) A <= 2 .e. B = 7 
e) .não. A = 2 .e. B = 7 
f) A < 5 .e. B > 2 .ou. B < > 7 
2. Complete a tabela-verdade a seguir: 
 Operador 
28 
 
 .e. .ou. .não. 
Expressão A = 4 B < > 5 A = 4 .e. B < > 5 A = 4 .ou. B < > 5 .não. A = 4 
Resultados 
possíveis 
 
 
 
 
3. 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. 
4. 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. 
29 
 
5. Suponha que n1 e n2 são duas variáveis int que foram dadas valores. Adicione 
uma expressãobooleana que retorna verdadeiro se o valor de n1 é maior ou 
igual ao valor de n2, caso contrário, ele deve voltar falso. 
6. Suponha que n1 e n2 são duas variáveis int que foram dadas valores. Escreva 
uma declaração if-else que exiba "n1" se n1 é maior ou igual a n2, e escreva "n2" 
de outra forma. 
7. Suponha var1 e var2 duas variáveis que receberam valores. Como teste se eles 
são iguais quando as variáveis são do tipo int? Como testar se são iguais quando 
as variáveis são do tipo String? 
8. Suponha que proximaPalavra é uma variável String que recebeu um valor de 
String que consiste inteiramente em letras. Escreva um código Java que exibe a 
mensagem "Primeira metade do alfabeto", desde que proximaPalavra precede 
"N" em ordem alfabética. Se proximaPalavra não preceder "N" em ordem 
alfabética, o código deve emitir "Segunda metade do alfabeto". (Note-se que "N" 
usa aspas para produzir um valor String, em vez de usar aspas simples para 
produzir um valor de char). 
9. Escreva uma instrução if-else que exiba como saída a palavra "passou" desde 
que o valor da variável exame seja maior do que ou igual a 6,0 e também o valor 
da variável programaConcluido seja maior do que ou igual a 1,0. Caso contrário, 
a declaração if-else deve imprimir a palavra "falhou". 
10. Escreva uma instrução if-else que exiba como saída a palavra "emergência" 
desde que o valor da variável de pressao seja maior do que 160 ou o valor da 
variável de temperatura seja maior do que ou igual a 40. Caso contrário, a 
declaração if-else deve imprimir a palavra "OK". 
11. Determine o valor verdadeiro ou falso, de cada uma das expressões booleanas 
abaixo, assumindo que o valor da variável de contagem é 0 e o valor da variável 
limite é 10. 
a) (contagem == 0) && (limite < 20) 
b) contagem == 0 && limite < 20 
c) (limite > 20) || (contagem < 5) 
d) !(contagem == 12) 
e) (contagem == 1) && (x < y) 
f) (contagem < 10) || (x < y) 
g) !( ((contagem < 10) || (x < y)) && (count >= 0) ) 
30 
 
h) ((limite/contagem) > 7) || (limite < 20) 
i) (limite < 20) || ((limite/contagem) > 7) 
j) ((limite/contagem) > 7) && (limite < 0) 
k) (limite < 0) && ((limite/contagem) > 7) 
12. A seguinte sequência produz uma divisão por zero? 
int j = -1; 
if ((j > 0) && (1/(j+1) > 10)) 
 System.out.println(i); 
13. O que está errado com o seguinte fragmento de código? Reescreva-o para que 
ele produza uma saída correta. 
if (total == MAX) 
 if (total < soma) 
 System.out.println ("total == MAX and < soma"); 
else 
 System.out.println ("total is not equal to MAX"); 
14. O que está errado com o seguinte fragmento de código? Este código compilará 
se for parte de um programa? Explique. 
if (tamanho = MIN_TAMANHO) 
 System.out.println ("O tamanho é mínimo."); 
15. Qual saída é produzida pelos seguintes fragmentos de códigos? 
a) int num = 87, max = 25; 
 if (num >= max*2) 
 System.out.println ("maçã"); 
 System.out.println ("laranja"); 
 System.out.println ("pêra"); 
b) int limit = 100, num1 = 15, num2 = 40; 
if (limit <= limit) 
{ 
 if (num1 == num2) 
 System.out.println ("lemon"); 
 System.out.println ("lime"); 
} 
System.out.println ("grape"); 
16. Considere o seguinte trecho de código: 
31 
 
if(i == 10.0) 
 System.out.println("verdadeiro"); 
Qual das seguintes declarações da variável i irá compilar sem erros e imprimir 
verdadeiro quando o programa é executado? 
a) int i = 012; 
b) int i = 10.0F; 
c) int i = 10L; 
d) int i = 10,0; 
17. Considere o seguinte segmento de código: 
Boolean b = null; 
System.out.println(b ? true : false); 
Qual das seguintes opções descreve corretamente o comportamento deste 
segmento de código? 
a) Este código irá resultar num erro do compilador, uma vez que um tipo de 
referência (de tipo booleano) não pode ser usado como parte de expressão, para 
verificação de estado. 
b) Este código irá resultar em lançar um NullPointerException. 
c) Este código irá imprimir verdade no console. 
d) Este código irá imprimir falso no console. 
18. Considere o seguinte programa: 
class PrintlnTest { 
 public static void main(String[] args) { 
 String dois = "2"; 
 System.out.println("1 + 2 + 3 + 4 = " 
 + 1 + Integer.parseInt(dois) + 3 + 4); // ANALISE 
 } 
} 
Qual das seguintes opções descreve corretamente o comportamento desse 
programa? 
a) Quando compilado, este programa vai dar um erro do compilador em linha 
marcada com comentários ANALISE por falta de um manipulador catch para 
NumberFormatException. 
b) Quando executado, o programa imprime o seguinte: 1 + 2 + 3 + 4 = 1234. 
c) Quando executado, o programa exibe o seguinte: 1 + 2 + 3 + 4 = 10. 
32 
 
d) Quando executado, o programa imprime o seguinte: 1 + 2 + 3 + 4 = 127. 
e) Quando executado, o programa imprime o seguinte: 1 + 2 + 3 + 4 = 19. 
f) Quando executado, o programa lança um NumberFormatException na linha 
marcada com comentário ANALISE. 
19. Considere o seguinte programa e prever o resultado: 
class Test { 
public static void main(String []args) { 
int a = 7, b = 10; 
System.out.printf("no:%2$s and %1$s", a, b); 
System.out.printf("\nno:2$s and 1$s", a, b); 
} 
} 
a) no: 10 e 7 
no: 2$s e 1$s 
b) no: 7 e 10 
no: 2$s e 1$s 
c) no: 10 e 7 
no: 10 e 7 
d) no: 7 e 10 
no: 7 e 10 
e) Este programa irá resultar em erro do compilador (s). 
20. Assinale V para verdadeiro ou F para falso: 
( ) Nas estruturas de controle, tais como as estruturas de seleção simples, 
compostas ou encadeadas, é necessário verificar as condições para a 
realização de uma instrução ou sequência de instruções. 
( ) A instrução de desvio incondicional realiza a transferência do controle da 
execução para um lugar especificado no programa. 
( ) As instruções de seleção bidirecional e as construções de seleção 
múltipla são tipos de instruções iterativas. 
( ) Seleção bidirecional e n-direcional ou múltipla são tipos de instruções de 
seleção. 
21. Verifique se um número fornecido pelo usuário é par ou impar. Apresente uma 
mensagem mostrando o número digitado e o resultado do teste. 
33 
 
22. Um aluno realizou três provas de uma disciplina. Considerando o critério abaixo 
faça um programa que mostre se ele ficou para exame. Em caso positivo, leia a 
nota do exame e verifique se conseguiu a aprovação ou não. 
Media = (prova1 + prova2 + prova3)/3 
A média deve ser maior ou igual a 7,0. Se não conseguir, a nova média deve ser: 
Final = (Media + Exame)/2 
Nesse caso, a média final deve ser maior ou igual a 5,0. 
23. A nota final de um estudante é calculada a partir de três notas atribuídas 
respectivamente a um trabalho de laboratório, a uma avaliação semestral e a um 
exame final. A média das três notas mencionadas anteriormente obedece aos 
pesos a seguir: 
Nota Peso 
Trabalho de laboratório 2 
Avaliação semestral 3 
Exame final 5 
Faça um programa que receba as três notas, calcule e mostre a média 
ponderada e o conceito que segue a tabela abaixo: 
Média ponderada Conceito 
8,0 a 10,0 A 
7,0 a 8,0 B 
6,0 a 7,0 C 
5,0 a 6,0 D 
0,0 a 5,0 E 
24. Faça um programa que recebe três notas de um aluno, calcule e mostre a média 
aritmética e a mensagem que segue a tabela abaixo. Para alunos de exame, 
calcule e mostre a nota que deverá ser tirada no exame para aprovação, 
considerando que a média no exame é 6,0. 
Média aritmética Mensagem 
0,0 a 3,0 Reprovado 
3,0 a 7,0 Exame 
7,0 a 10,0 Aprovado 
25. Usando o operador condicional faça um programa que receba dois números e 
mostre o maior. 
34 
 
26. Faça um programa que receba três números e mostre-os em ordem crescente. 
27. Faça um programa que mostre o menu de opções a seguir, receba a opção do 
usuário e os dados necessários para executar cada operação. 
Menu de opções: 
1. Somar dois números 
2. Raiz quadrada de um número 
Digite a opção desejada: 
28. Faça um programa que receba o código corresponde ao cargo de um funcionário 
e seu salário atuale mostre o cargo, o valor do aumento e seu novo salário. Os 
cargos estão na tabela a seguir. 
Código Cargo Percentual 
1 Escriturário 5% 
2 Secretário 3,5% 
3 Caixa 20% 
4 Gerente 10% 
5 Diretor Não tem aumento 
29. Faça um programa que receba dois números e execute as operações listadas a 
seguir de acordo com a escolha do usuário. 
Escolha do usuário Operação 
1 Média entre os números digitados 
2 Diferença do maior pelo menor 
3 Produto entre os números digitados 
4 Divisão do primeiro pelo segundo 
Se a opção digitada for inválida, mostrar uma mensagem de erro e terminar a 
execução do programa. 
Lembre-se: na operação 4 o segundo número deve ser diferente de zero. 
30. Uma agência bancária possui dois tipos de investimentos, conforme o quadro a 
seguir. Faça um programa que receba o tipo de investimento e o valor do 
investimento e que calcule e mostre o valor corrigido de acordo com o tipo de 
investimento. 
Tipo Descrição Rendimento mensal 
1 Poupança 3% 
2 Fundos de renda fixa 4% 
35 
 
 
 
4.4 TRABALHOS PRÁTICOS 
 
 
1. Elabore um algoritmo para validação do CPF (cadastro de pessoa física). O 
número do CPF é composto de 11 dígitos, sendo que os dois últimos são os 
dígitos verificadores. A validação do CPF é feita por meio de cálculos com base 
nos 9 primeiros dígitos. As etapas desse cálculo são descritas a seguir. Para isso 
utilize o CPF exemplo ABC.DEF.GHI-XY. 
Calculo do X 
 Multiplicar o dígito A por 10, o dígito B por 9, o dígito C por 8 e assim 
sucessivamente. Até o dígito I, que deverá ser multiplicado por 2. 
 Calcular a soma entre todos os valores calculados no passo 1. 
 Dividir o valor obtido no passo 2 por 11. Essa divisão deve ser por inteiro. 
Se o resto da divisão for menor que 2, o primeiro dígito verificador será 0. 
Caso contrário, subtrai-se de 11 o valor obtido. 
Calculo do Y 
 Multiplicar o dígito A por 11, o dígito B por 10, o dígito C por 9, e assim 
sucessivamente até o dígito Y, que deverá ser multiplicado por 2. 
 Calcular a soma entre todos os valores calculados no passo 1. 
 Dividir o valor obtido no passo 2 por 11. Essa divisão deve ser por inteiros. 
Se o resto da divisão for menor que 2, o primeiro dígito verificador será 0. 
Caso contrário, subtrai-se de 11 o valor obtido. 
2. Faça um programa que receba: 
O código de um produto comprado, supondo que a digitação do código do 
produto seja sempre válida (um número inteiro entre 1 e 10); 
O peso do produto em quilos; 
O código do país de origem, supondo que a digitação do código do país seja 
sempre válida (um número inteiro entre 1 e 3). 
Código do país de origem Imposto 
1 0% 
2 15% 
36 
 
3 25% 
 
Código do produto Preço por grama 
1 a 4 10 
5 a 7 25 
8 a 10 35 
Calcule e mostre: 
 O peso do produto convertido em gramas; 
 O preço total do produto comprado; 
 O valor do imposto, sabendo-se que o imposto é cobrado sobre o preço total 
do produto comprado e que depende do país de origem. 
 O valor total, preço total do produto mais imposto. 
3. Faça um programa que receba o valor do salário mínimo, o número de horas 
trabalhadas, o número de dependentes do funcionário e a quantidade de horas 
extras trabalhadas. Calcule e mostre o salário a receber do funcionário de acordo 
com as regras a seguir: 
 O valor da hora trabalhada é igual a 1/5 do salário mínimo; 
 O salário do mês é igual ao número de horas trabalhadas multiplicado pelo 
valor da hora trabalhada; 
 Para cada dependente acrescentar R$ 27,24; 
 Para cada hora extra trabalhada calcular o valor da hora trabalhada acrescida 
de 50%; 
 O salário bruto é igual ao salário do mês mais o valor dos dependentes mais 
o valor das horas extras; 
 Calcular o valor do imposto de renda retido na fonte de acordo com a tabela a 
seguir: 
Salário bruto IRRF 
Isento Até R$ 
1.499,15 
de R$ 1.499,16 até R$ 
2.246,75 
7,5% 
de R$ 2.246,76 até R$ 
2.995,70 
15% 
37 
 
de R$ 2.995,71 até R$ 
3.743,19 
22,5% 
acima de R$ 3.743,19 27,5% 
 O salário líquido é igual ao salário bruto menos IRRF; 
 A gratificação de acordo com a tabela a seguir: 
Salário líquido Gratificação 
até R$ 650,00 R$ 100,00 
acima de R$ 
650,00 
R$ 50,00 
 O salário a receber do funcionário é igual ao salário líquido mais gratificação. 
4. Faça um programa que apresente o menu de opções a seguir: 
Menu de opções: 
1. Imposto 
2. Novo salário 
3. Classificação 
Digite a opção desejada: 
Permita ao usuário escolher a opção desejada, receba os dados necessários 
para executar a operação e mostre o resultado. Verifique a possibilidade de 
opção inválida e não se preocupe com restrições como salário negativo 
Opção 1: receber o salário de um funcionário, calcular e mostrar o valor do 
imposto usando as regras a seguir: 
Salários Percentual de imposto 
até R$ 1.106,90 8% 
de R$ 1.106,91 a R$ 1.844,83 9% 
de R$ 1.844,84 a R$ 3.689,66 11% 
Opção 2: receber o salário de um funcionário, calcular e mostrar o valor do novo 
salário, usando as regras a seguir: 
Salário Aumento 
Maiores que R$ 1.500,00 R$ 25,00 
De R$ 750,00 (inclusive) até R$ 1.500 (inclusive) R$ 50,00 
De R$ 450,00 (inclusive) a R$ 750,00 R$ 75,00 
Menores que R$ 450,00 R$ 100,00 
38 
 
Opção 3: receber o salário de um funcionário e mostrar sua classificação usando 
a tabela a seguir: 
Salário Classificação 
Até R$ 700,00 (inclusive) Mal remunerado 
Maiores que R$ 700,00 Bem remunerado 
5. Considere a situação em que um cliente faz uma determinada compra em uma 
loja. Ao realizar o pagamento, são-lhe oferecidas as seguintes condições para 
pagamento: 
 Pagamento à vista: 15% de desconto sobre o valor total da compra. 
 Pagamento com cheque pré-datado para 30 dias: 10% de desconto sobre o 
valor total da compra. 
 Pagamento parcelado em 3 vezes: 5% de desconto sobre o valor total da 
compra. 
 Pagamento parcelado em 6 vezes: não tem desconto. 
 Pagamento parcelado em 12 vezes: 8% de acréscimo sobre o valor total da 
compra. 
De acordo com o valor total da compra, verifique a opção de pagamento do 
cliente, calcule o valor final da compra e, se a escolha for por pagamento 
parcelado, calcule também o valor das parcelas. 
Apresente ao usuário uma mensagem com o valor total da compra, o valor final 
da compra, a diferença entre os dois, identifique como desconto se a diferença 
for positiva, como juros se for negativa, mostre, também, a quantidade e o valor 
das parcelas. 
 
 
4.5 REFERÊNCIA BIBLIOGRÁFICA 
 
 
ASCENCIO, Ana F. G.; CAMPOS, Edilene A. V. Fundamentos da Programação de 
Computadores. São Paulo: Pearson Prentice Hall. 
 
DEITEL, Paul; DEITEL, Harvey. Java for Programmers, 2nd ed. Boston: Pearson 
Education, 2012. 
 
39 
 
LEWIS, John; DEPASQUALE, Peter J.; CHASE, Joseph. Java Foundations: 
Introduction to program design & data structures, 2nd ed. Boston: Addison-
Wesley, 2011 
 
SAVITCH, Walter. Absolute Java, 5th Ed. Boston: Pearson, 2013. 
 
SCHIDT, Herbert. Java: The Complete Reference, 7th Ed. New York: Mc Graw Hill, 
2007.