9. Modularização
9.9. Exemplo de Modularização em Java
1. Desenvolva um algoritmo que receba dois valores numéricos inteiros e o símbolo da operação conforme tabela abaixo, calcule e mostre a operação efetuada:
Símbolo da operação Nome da operação
+ adição - subtração * multiplicação / divisão class Calculo {
// módulo função Mais que recebe dois valores inteiros e retorna
// um valor inteiro
static int Mais (int n1 , int n2) {
// declaração de variáveis que só podem ser usados dentro // deste módulo int res; // processamento de dados res = n1 + n2; // retorno do módulo return res;
} // fim do módulo Mais
// módulo procedimento Menos que recebe dois valores inteiros static void Menos (int n1 , int n2)
{
// declaração de variáveis que só podem ser usadas dentro // deste módulo
int res;
res = n1 - n2;
// saída de resultados
System.out.println (“A diferença de ” + n1 + “ com ” + n2 + “ é ” + res);
} // fim do módulo Menos
// módulo procedimento Vezes que recebe dois valores inteiros static void Vezes (int n1 , int n2)
{
// declaração de variáveis que só podem ser usadas dentro // deste módulo
int res;
// processamento de dados res = n1 * n2;
// saída de resultados
System.out.println (“O produto de ” + n1 + “ com ” + n2 + “ é ” + res);
} // fim do módulo Vezes
// módulo função Dividido que recebe dois valores inteiros e
// retorna um valor real
static double Dividido (int n1 , int n2) {
// declaração de variáveis que só podem ser usadas dentro // deste módulo
double res;
// processamento de dados res = (double)n1 / (double)n2; // retorno do módulo
return res;
} // fim do módulo Dividido
// módulo principal
public static void main (String args [ ]) {
// declaração de variáveis e/ou constantes que podem ser // usadas no algoritmo Calculo
double d ;
int oper, soma, num1, num2;
// mensagem ao usuário e entrada de dados
num1 = Integer.parseInt(JOptionPane.showInputDialog(“Digite um número inteiro”)); num2 = Integer.parseInt(JOptionPane.showInputDialog(“Digite um
número inteiro”)); oper = Integer.parseInt(JOptionPane.showInputDialog(“Digite a
operação: \n1 para somar \n2 para subtrair \n3 para multiplicar \n4 para dividir”)); // processamento de dados
{
case 1: // chamada do módulo função Mais, passando num1 e
// num2 como parâmetro e atribuindo o retorno do // módulo na variável soma
soma = Mais(num1 , num2); // saída de resultados
System.out.println (“A soma de ” + num1 + “ com ” + num2 + “ é ” + soma);
break;
case 2: // chamada domódulo procedimento Menos, passando
// num1 e num2 como parâmetro Menos (num1 , num2);
break;
case 3: // chamada do módulo procedimento vezes, passando
// num1 e num2 como parâmetro Vezes (num1 , num2);
break;
case 4: // chamada do módulo função Dividido, passando num1
// e num2 como parâmetro e atribuindo o retorno do // módulo na variável d
d = Dividido (num1 , num2); // saída de resultados
System.out.println (“A divisão de ” + num1 + “ com ” + num2 + “ é ” + d);
break;
default: // saída de resultados
System.out.println (“operação inválida”);
} // fim do switch
System.exit(0);
} // fim do void main } // fim da classe
2. Desenvolva um algoritmo que mostre um menu de opções para: calcular a soma de três números fornecidos pelo usuário; verificar se um número fornecido pelo usuário é par; e verificar se um número fornecido pelo usuário é divisível por 3.
class Somador {
// módulo procedimento Menu public static int Menu()
{
String msg = “”; int op;
msg = msg + “Digite 1 para somar três números\n”;
msg = msg + “Digite 2 para verificar se um número é par\n”; msg = msg + “Digite 3 para verificar se um número é divisível
por 3\n”;
msg = msg + “Digite 0 para sair do programa\n”;
return op; } // Menu
// módulo função SomaTudo que retorna um valor inteiro public static int SomaTudo ()
{
// declaração de variáveis que só podem ser usadas dentro // deste módulo int s = 0, i; // processamento de dados i = Integer.parseInt(JOptionPane.showInputDialog (“Digite um número”)); s = s + i; i = Integer.parseInt(JOptionPane.showInputDialog (“Digite um número”)); s = s + i; i = Integer.parseInt(JOptionPane.showInputDialog (“Digite um número”)); s = s + i; // retorno do módulo return s; } // SomaTudo
// módulo procedimento Pares que recebe um valor inteiro public static void Pares (int par)
{
// processamento de dados
if ((par % 2) == 0) {
// saída de resultados
System.out.println (“O número ” + par + “ é par ”);
}
else
{
// saída de resultados
System.out.println (“O número ” + par + “ não é par ”);
}
} // Pares
// módulo função Divisivel3 que recebe um valor inteiro e retorna
// um valor booleano
public static boolean Divisivel3 (int d) {
// declaração de variáveis que só podem ser usadas dentro // deste módulo
boolean res;
// processamento de dados
if ((d % 3) == 0) {
res = true; } else { res = false; } // retorno da função return res; } // Divisivel3 // módulo principal
public static void main (String arg []) {
// declaração de variáveis que só podem ser usadas dentro do // algoritmo principal
int op = 0, soma, num; boolean log; // processamento de dados do { op = Menu(); // entrada de dados switch (op) {
case 1: soma = SomaTudo();
System.out.println (“A somatória de três números fornecidos pelo usuário é: ” + soma);
break;
case 2: num = Integer.parseInt(JOptionPane.showInputDialog
(“Digite um número”)); Pares(num);
break;
case 3: num = Integer.parseInt(JOptionPane.showInputDialog
(“Digite um número”)); log = Divisivel3(num);
if (log == true) {
System.out.println (“O número ” + num + “ é divisível por 3 ”);
} else
{
System.out.println (“O número ” + num + “ não é divisível por 3 ”);
}
break;
case 0: System.out.println (“Saindo do programa!”);
System.exit(0);
default: System.out.println (“opção inválida, tente
}
} while (op != 0); } // main
} // classe Somador
3. Desenvolva um algoritmo modularizado que receba o nome e os dados para cálculo da área de uma figura geométrica conforme tabela abaixo, e a partir da escolha do usuário por um menu de opções, calcule e mostre a área da figura geométrica:
Figura geométrica Fórmula
quadrado lado * lado
triângulo (base * altura) / 2 retângulo base * altura
trapézio ((Base maior + base menor) * altura) / 2
class CalculoArea {
// módulo procedimento Menu public static int Menu()
{
String msg = “”; int op;
msg = msg + “Digite 1 para área do quadrado\n”; msg = msg + “Digite 2 para área do triângulo\n”; msg = msg + “Digite 3 para área do retângulo\n”; msg = msg + “Digite 4 para área do trapézio\n”; msg = msg + “Digite 0 para sair do programa\n”;
op = Integer.parseInt (JOptionPane.showInputDialog(msg));
return op; } // Menu
// módulo função Quadrado que recebe um valor real e retorna um
// valor real
public static double Quadrado (double l) {
// declaração de variáveis que só podem ser usadas dentro // deste módulo double res; // processamento de dados res = l * l; // retorno do módulo return res; } // Quadrado
public static void Triangulo (double b, double h) {
// declaração de variáveis que só podem ser usadas dentro // deste módulo
double res;
// processamento de dados res = (b * h) / 2;
// saída de resultados
System.out.println (“A área do triângulo de base ” + b + “ e altura ” + h + “ é ” + res);
} // Triangulo
// módulo procedimento Retangulo que recebe dois valores reais public static void Retangulo (double b, double h)
{
// declaração de variáveis que só podem ser usadas dentro // deste módulo
double res;
// processamento de dados res = b * h;
// saída de resultados
System.out.println (“A área do retângulo de base ” + b + “ e altura ” + h + “ é ” + res);
} // Retangulo
// módulo função Trapezio que retorna um valor real public static double Trapezio ( )
{
// declaração de variáveis que só podem ser usadas dentro // deste módulo double res, b1, b2, h; // entrada de dados b1 = Double.parseDouble(JOptionPane.showInputDialog(“Digite a base menor”)); b2 = Double.parseDouble(JOptionPane.showInputDialog(“Digite a base maior”)); h = Double.parseDouble(JOptionPane.showInputDialog(“Digite a altura”)); // processamento de dados res = ((b1 + b2) * h) / 2; // retorno do módulo return res; } // Trapezio // módulo principal
public static void main (String arg []) {
// declaração de variáveis e/ou constantes que podem ser // usadas no algoritmo principal
double retorno, lado, base, altura; int figura = 0; do { figura = Menu(); switch (figura) {
case 1: // entrada de dados
lado = Double.parseDouble
(JOptionPane.showInputDialog (“Digite o lado”)); // chamada do módulo função Quadrado, passando lado // como parâmetro e atribuindo o retorno do módulo // na variável retorno
retorno = Quadrado(lado); // saída de resultados
System.out.println (“A área do quadrado de lado ” + lado + “ é ” + retorno);
break;
case 2: // entrada de dados
base = Double.parseDouble
(JOptionPane.showInputDialog (“Digite a base”)); altura = Double.parseDouble
(JOptionPane.showInputDialog (“Digite a altura”)); // chamada do módulo procedimento Triangulo,
// passando base e altura como parâmetro Triangulo (base, altura);
break;
case 3: // entrada de dados
base = Double.parseDouble
(JOptionPane.showInputDialog (“Digite a base”)); altura = Double.parseDouble
(JOptionPane.showInputDialog (“Digite a altura”)); // chamada do módulo procedimento Retangulo,
// passando base e altura como parâmetro Retangulo (base, altura);
break;
case 4: // chamada do módulo função Trapezio e atribuindo
// o retorno do módulo na variável retorno retorno = Trapezio ( );
// saída de resultados
System.out.println (“A area do trapézio é ” + retorno);
break;
case 0: System.out.println (“Saindo do programa!”);
System.exit(0);
default: // saída de resultados
System.out.println (“operação inválida”);
}
} while (figura != 0); }
4. Desenvolva um algoritmo que mostre um menu de opções para: calcular a soma de todos os números compreendidos entre 1 e 100; calcular a soma de todos os números pares
compreendidos entre 1 e 100; e calcular a soma de todos os números divisíveis por 3.
class Somador {
// módulo função Menu static int Menu()
{
int op;
String msg = “”;
msg = msg + “Digite 1 para soma de todos os números entre 1 e 100\nDigite 2 para soma de todos os números pares entre 1 e 100\nDigite 3 para soma de todos os números divisíveis por 3 entre 1 e 100\nDigite 0 para sair do programa\n”;
op = Integer.parseInt(JOptionPane.showInputDialog(msg));
return op;
} // fim do módulo Menu
// módulo função SomaTudo que retorna um valor inteiro static int SomaTudo ()
{ int s = 0, i; i = 1; // processamento de dados while (i <= 100) { s = s + i; i = i + 1; } // fim do while
return s; // retorno do módulo } // fim do módulo SomaTudo
// módulo procedimento SomaPares que recebe um valor inteiro static void SomaPares (int par)
{ int s=0, i; i = 1; // processamento de dados do { if ((i % par) == 0) { s = s + i; } // fim do if i = i + 1; } while (i <= 100);
System.out.println (“A somatória dos números pares de 1 até 100 é ” + s);
} // fim do móduloSomaPares
/* módulo função SomaDivisivel3 que recebe um valor inteiro e retorna
um valor inteiro*/
static int SomaDivisivel3 (int d) { int i, s = 0; // processamento de dados for ( i = 1 ; i <= 100 ; i++ ) { if ((i % d) == 0) { s = s + i; } // fim do if } // fim do for
return s; // retorno da função }// fim do módulo SomaDivisivel3
// módulo principal
public static void main (String args [ ]) {
int op, soma, d;
// processamento de dados
do {
op = Menu(); // entrada de dados
switch (op) {
case 1 : soma = SomaTudo();
System.out.println (“A somatória de 1 até 100 é” + soma);
break;
case 2 : SomaPares(2);
break;
case 3 : d = SomaDivisivel3(3);
System.out.println (“A somatória dos números divisíveis por 3 de 1 até 100 é ” + d); break;
case 0 : System.out.println (“Saindo do programa!”);
System.exit(0);
default :System.out.println (“opção inválida, tente
novamente”);
} // fim do switch } while (op != 0); } // fim do void main } // fim da classe
Exercícios de Modularização
01. Desenvolva um módulo procedimento que receba dois números inteiros, calcule e mostre o resto da divisão entre os números inteiros, sem utilizar o operador mod ou %.
02. Desenvolva um módulo função que receba dois números inteiros, calcule e retorne o quociente da divisão entre os números inteiros, sem utilizar o operador div ou / (para inteiros).
03. Desenvolva um módulo função que receba um número inteiro, calcule e retorne a raiz quadrada inteira mais próxima desse número.
04. Desenvolva um módulo procedimento que receba um número, verifique e mostre se esse número é ou não divisível por 5.
05. Desenvolva um módulo procedimento que receba um número, verifique e mostre se esse número é ou não primo.
06. Desenvolva um módulo procedimento que receba um número, verifique e mostre se esse número é ou não par.
07. Desenvolva um módulo procedimento que receba um número inteiro e mostre todos os divisores desse número.
08. Desenvolva um módulo função que receba um número real, calcule e retorne o valor absoluto desse número.
09. Desenvolva um módulo função que receba um número inteiro, calcule e retorne o fatorial desse número.
10. Desenvolva um módulo principal com um menu de opções para a chamada dos módulos
desenvolvidos nos exercícios 1 até 9, mostrando os respectivos resultados dos módulos função. O usuário é quem deve escolher o módulo que será executado.
11. Desenvolva um algoritmo modularizado que receba cinco valores inteiros e, a partir de um menu de opções, permita o usuário escolher entre:
a. entrar e mostrar os valores a serem armazenados em cinco variáveis; (procedimento sem parâmetros);
b. calcular e mostrar o valor da somatória dos valores das cinco variáveis; (procedimento com parâmetros)
c. calcular e retornar a média aritmética dos valores das cinco variáveis; (função sem parâmetros) d. calcular e retornar a média ponderada dos valores das cinco variáveis, sendo peso 2 para as
duas primeiras entradas, peso 5 para as duas próximas entradas e peso 10 para a última entrada; (função com parâmetros)
e. mostrar os cinco valores em ordem crescente. (procedimento com parâmetros)
Obs1.: após a chamada das funções, mostrar o resultado.
Obs2.: uma das opções do menu deve ser a de sair do programa.
12. Desenvolva um algoritmo modularizado que receba um valor inteiro e, a partir de um menu de opções, permita o usuário escolher entre:
a. entrar e mostrar o valor a ser armazenado em uma variável n; (procedimento sem parâmetros) b. calcular e retornar o valor da somatória dos vinte primeiros termos da série de Fibonnacci;
(função sem parâmetros)
c. verificar e mostrar se o número armazenado na variável n é divisível por 7; (função com parâmetros)
d. verificar e mostrar se o número armazenado na variável n é par ou ímpar; (procedimento com parâmetros)
Obs1.: após a chamada das funções, mostrar os resultados. Obs2.: uma das opções do menu deve ser a de sair do programa.
13. Desenvolva um algoritmo modularizado que receba o valor da compra de um produto e, a partir de um menu de opções, permita ao usuário escolher entre:
a. calcular e retornar o pagamento a vista com 20% de desconto; (função com parâmetros) b. calcular e mostrar o pagamento em duas vezes com entrada e com 10% de desconto;
(procedimento com parâmetros)
c. calcular e retornar o pagamento a vista no cartão com 15% de desconto; (função com parâmetros)
d. calcular e mostrar o pagamento em duas vezes no cartão com 5% de desconto; (função com parâmetros)
e. calcular e mostrar o pagamento a prazo em duas vezes sem entrada com acréscimo de 5%; (procedimento com parâmetros)
f. calcular e retornar o pagamento a prazo em três vezes sem entrada com acréscimo de 10%. (função com parâmetros)
Obs1.: após a chamada das funções, mostrar o resultado.
Obs2.: uma das opções do menu deve ser a de sair do programa.
14. Desenvolva um algoritmo modularizado que receba o nome de um aluno, o registro desse aluno e quatro valores reais referentes às notas bimestrais desse aluno e, a partir de um menu de opções, permita ao usuário escolher entre:
a. entrar e mostrar o nome e o registro do aluno bem como suas notas bimestrais; (procedimento sem parâmetros)
b. calcular e mostrar o valor da média desse aluno com a mensagem de aprovação (média >= 5.0) ou reprovação, bem como, seu nome e seu registro; (procedimento com parâmetros)
c. calcular e retornar o valor da média ponderada desse aluno com pesos 1, 2, 3 e 4, respectivamente para cada nota; (função com parâmetros)
d. calcular a média aritmética desse aluno e retornar a mensagem de aprovado ou reprovado. (função com parâmetros)
Obs1.: após a chamada das funções, mostrar o resultado.
Obs2.: uma das opções do menu deve ser a de sair do programa.
15. Desenvolva um algoritmo modularizado que receba um mês e um dia da semana e a partir de um menu de opções, permita ao usuário escolher entre:
a. entrar e mostrar o mês e o dia da semana; (procedimento sem parâmetros)
b. verificar e mostrar se no mês informado ele tem alguma avaliação; (procedimento com parâmetros)
c. verificar e retornar se no mês e dia da semana informados ele precisa ir para o IBTA; (função com parâmetros)
d. verificar e retornar quantos meses por ano ele está de férias escolares (função sem parâmetros)
Obs1.: após a chamada das funções, mostrar o resultado.
Obs2.: uma das opções do menu deve ser a de sair do programa.
16. Desenvolva um algoritmo modularizado que receba um valor inteiro positivo e, a partir de um menu de opções, permita ao usuário escolher entre:
a. entrar e mostrar o valor inteiro armazenado numa variável n; (procedimento sem parâmetros) b. calcular e mostrar a somatória dos números 100 e n ; (procedimento com parâmetros)
c. calcular e retornar o produto dos números 20 e n; (função com parâmetros) d. verificar e retornar se n é primo ou não (função sem parâmetros)
Obs1.: após a chamada das funções, mostrar o resultado.
Obs2.: uma das opções do menu deve ser a de sair do programa.
17. Desenvolva um algoritmo modularizado que receba o nome e os dados para cálculo da área de uma figura geométrica conforme tabela abaixo e, a partir de um menu de opções, permita ao usuário escolher entre calcular e mostrar a área da figura geométrica:
Figura geométrica Fórmula
quadrado lado * lado
triângulo (base * altura) / 2 retângulo base * altura
Obs1.: usar procedimentos e funções com e sem parâmetros.
Obs2.: uma das opções do menu deve ser a de sair do programa.
18. Desenvolva um algoritmo modularizado que receba dois valores reais e o código do produto notável conforme tabela abaixo e, a partir de um menu de opções, permita ao usuário escolher entre calcular e mostrar o valor do produto notável:
Código Produto Notável Fórmula
1 quadrado da diferença de dois números (a - b) * (a - b)
2 quadrado da soma de dois números (a + b) * (a + b)
3 soma do quadrado de dois números a * a + b * b
4 diferença do quadrado de dois números a * a - b * b 5 produto da soma com a diferença de dois números (a - b) * (a + b)
Obs1.: usar procedimentos e funções com e sem parâmetros. Obs2.: uma das opções do menu deve ser a de sair do programa.
19. Desenvolva um algoritmo modularizado que receba o nome de um lugar e, a partir de um menu de opções, permita ao usuário escolher entre mostrar para o usuário o que ele deve fazer nesse lugar, conforme tabela abaixo:
Lugar O que fazer
Escola Estudar
Banco Pagar contar
Farmácia Comprar remédios
Casa Descansar
Correio Remeter cartas
Obs1.: usar procedimentos e funções com e sem parâmetros. Obs2.: uma das opções do menu deve ser a de sair do programa.
20. Desenvolva um algoritmo modularizado que receba o código da condição de pagamento e o preço de um produto e, a partir de um menu de opções, permita ao usuário escolher entre calcular o que deve ser pago pelo produto e mostrar a condição de pagamento e o preço a ser pago, conforme a tabela abaixo:
Código Condição de pagamento
A a vista em dinheiro ou cheque tem 20% de desconto B a vista em cartão de crédito tem 10% de desconto C em 2 vezes, preço normal de etiqueta sem juros
Obs1.: usar procedimentos e funções com e sem parâmetros. Obs2.: uma das opções do menu deve ser a de sair do programa.
21. Desenvolva um algoritmo modularizado que receba o salário de um funcionário e, a partir de um menu de opções, permita ao usuário escolher entre calcular e mostrar o valor do aumento salarial e o salário final a ser recebido pelo funcionário, considerando que:
a. se o funcionário recebe menos que 500,00, terá reajuste de 100%;
b. se o funcionário recebe mais ou igual 500,00 e menos que 1.000,00, terá reajuste de 75%; c. se o funcionário recebe mais ou igual a 1.000,00 e menos que 1.500,00, terá reajuste de 50%; d. se o funcionário recebe mais ou igual a 1.500,00 e menos que 2.000,00, terá reajuste de 25%; e. se o funcionário recebe mais ou igual a 2.000,00 e menos que 3.000,00, terá reajuste de 10%; f. se o funcionário recebe mais ou igual a 3.000,00 e menos que 5.000,00, terá reajuste de 5%; g. se o funcionário recebe mais ou igual a 5.000,00, terá reajuste de 2%.
Obs1.: usar procedimentos e funções com e sem parâmetros. Obs2.: uma das opções do menu deve ser a de sair do programa.
22. Desenvolva um algoritmo modularizado que receba o tipo de investimento e o valor do investimento e, a partir de um menu de opções, permita ao usuário escolher entre calcular e mostrar o valor corrigido do investimento após o período de 30 dias, considerando que o rendimento mensal para cada tipo de investimento varia conforme a tabela abaixo:
Tipo de investimento Rendimento
Poupança 3%
Fundo de renda fixa 5%
CDB 6%
Ações 10%
Obs1.: usar procedimentos e funções com e sem parâmetros. Obs2.: uma das opções do menu deve ser a de sair do programa.
23. Desenvolva um algoritmo modularizado que receba a data de nascimento de uma pessoa e a data atual e, a partir de um menu de opções, permita ao usuário escolher entre verificar e mostrar: a. em qual estação do ano (primavera, verão, outono ou inverno) essa pessoa nasceu; b. em qual século essa pessoa nasceu;
c. se a pessoa nasceu em um ano bissexto; d. qual o signo dessa pessoa;
e. quantos dias essa pessoa já viveu; f. quantos meses essa pessoa já viveu; g. quantos anos essa pessoa tem.
Obs1.: usar procedimentos e funções com e sem parâmetros. Obs2.: uma das opções do menu deve ser a de sair do programa.
24. Desenvolva um algoritmo modularizado que receba três valores numéricos reais e um código e, a partir de um menu de opções, permita ao usuário escolher entre calcular e mostrar dados
conforme a tabela abaixo:
código Operação
1 os três valores em ordem crescente 2 os três valores em ordem decrescente 3 somente os valores pares
4 somente os valores ímpares 5 somente os valores positivos 6 somente os valores negativos
Obs1.: usar procedimentos e funções com e sem parâmetros. Obs2.: uma das opções do menu deve ser a de sair do programa.
25. Desenvolva um algoritmo modularizado que receba o preço atual e a venda mensal média de um produto e, a partir de um menu de opções, permita ao usuário calcular e mostrar o novo preço para um dos seguintes casos:
a. se a venda média mensal for menor que 500 e o preço atual menor que 30,00, então o produto