estrutura condicional - Profº Erinaldo Sanches Nascimento

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 teste de 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
.v.
.v.
.v.
.v.
.f.
.v.
.f.
.f.
.v.
.f.
.f.
.v.
.f.
.v.
.v.
.f.
.f.
.f.
.f.
.v.
possíveis
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
se
tem a mesma precedência. Então, calcula-
, 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.
condição
.V
.
Conjunto de
instruções
Fim
.F
.
Figura 1 – Fluxograma de uma estrutura condicional simples.
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 dos nú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.
condição
.V.
.F.
Conjunto de
instruções A
Conjunto de
instruções B
Figura 2 – Fluxograma para estrutura de seleção composta.
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
BONUS ← SALARIO * 0.20
8
9
SENÃO
BONUS ← SALARIO * 0.10
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
11
SENÃO
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.
.V.
Condição
_1
Condição
_2
.F.
.V.
.F.
Conjunto de
instruções A
Fim
Conjunto de
instruções B
Conjunto de
instruções C
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. Verificase, 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
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
ESCREVA (“É um triângulo equilátero”)
11
12
SENÃO
ESCREVA (“É um triângulo isósceles”)
13
14
FIM-SE
15
16
FIM-SE
SENÃO
ESCREVA (“Os valores não formam um triângulo”)
17
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
do segundo grau, deve-se ter a
0. Além disso, para que ela seja
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 ←
ESCREVA (“Raízes da equação: ”, X1, “e ”, X2)
10
11
SENÃO
ESCREVA (“A equação dada não tem raízes reais”)
12
13
14
15
FIM-SE
SENÃO
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
//recebe os 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.
Tal_coisa_
1
Conjunto
de instruções A
...
Tal_coisa_
2
Conjunto
de instruções A
...
Tal_coisa_
3
Conjunto
de instruções A
...
Conjunto
de instruções D
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
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 :
10
FIM-ESCOLHA
11
FIM PRODUTO
ESCREVA (“Diversos”)
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
d) A <= 2 .e. B = 7
b) A = 2 .e. B = 5
e) .não. A = 2 .e. B = 7
c) A < 3 .ou. B < > 7
f)
A < 5 .e. B > 2 .ou. B < > 7
2. Complete a tabela-verdade a seguir:
Operador
28
Expressão
A=4
B<>5
.e.
.ou.
.não.
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ão booleana 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 atual e 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
1a4
10
5a7
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é
1.499,15
de
R$
1.499,16
até
R$ 7,5%
2.246,76
até
R$ 15%
2.246,75
de
R$
2.995,70
R$
37
de
R$
2.995,71
até
R$ 22,5%
3.743,19
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$ R$ 50,00
650,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: AddisonWesley, 2011
SAVITCH, Walter. Absolute Java, 5th Ed. Boston: Pearson, 2013.
SCHIDT, Herbert. Java: The Complete Reference, 7th Ed. New York: Mc Graw Hill,
2007.