2 - Modularizacao

APROG – Algoritmia e Programação
Modularização
Emanuel Cunha Silva
ecs@isep.ipp.pt
Modularização
Mecanismo fornecido pelas Linguagens de Programação que permite decomposição dum
programa em módulos
Módulo único Módulo 1

(RAIZQUADRADA)
Módulo 2
modularização (SENO)
Módulo 3
Módulo
Principal
Módulo
▪ Sequência de instruções que executa uma tarefa específica
▪ Exemplos
▪ RAIZQUADRADA() e SENO()
APROG - Modularização 2
Modularização
O programa é composto por um Módulo Principal e outros módulos
▪ Módulo Principal
▪ É sempre o primeiro módulo a ser executado
▪ Controla execução do programa
▪ Na chamada de um módulo, o controlo passa temporariamente para o

módulo chamado
▪ Após a execução de um módulo, o controlo retorna para o módulo que o

chamou e para a instrução seguinte à que originou a chamada
Modularização
▪ Na chamada de um módulo, o controlo passa temporariamente para o módulo chamado
▪ Após a execução de um módulo, o controlo retorna para módulo que o chamou
Módulo 1
Sequência de execução: Instrução 1.1
…
Módulo 2
Instrução 2.1
Módulo 1
…
Início Módulo Principal
…
Módulo 1
…
Módulo 2
…
Módulo 1
…
Fim
Modularização - Interesse
▪ Decomposição de programa em subprogramas mais pequenos
▪ Reduzir a complexidade do desenvolvimento
▪ Aplicação direta da estratégia dividir-para-conquistar
▪ Tornar mais rápido o desenvolvimento
▪ Módulos independentes podem ser desenvolvidos em paralelo
▪ Reutilização de módulos
▪ Tornar mais rápido desenvolvimento (evitar redundância)
▪ Tornar o programa mais pequeno e simples de ler/compreender
▪ Abstração da implementação de tarefas

▪ Facilitar o desenvolvimento
▪ Programador de um módulo abstrai-se dos detalhes da
implementação dos outros módulos
▪ Exemplo : RAIZQUADRADA(x)
Modularização
Exemplo: Calcular combinações
INICIO
ED: n, r, resultado, fn, fr, fnr, i INTEIRO redundância
LER (n, r)
//n!
resultado  1
REPETIR PARA i  2 ATE n PASSO 1
resultado  resultado * i
FIMREPETIR
fn  resultado
//r!
resultado  1
REPETIR PARA i  2 ATE r PASSO 1
FIMREPETIR
fr  resultado
//(n-r)!
resultado  1
REPETIR PARA i  2 ATE (n-r) PASSO 1
FIMREPETIR
fnr  resultado
ESCREVER (fn / (fr * fnr))

FIM
Modularização
Exemplo: Calcular combinações
reutilização
Módulo principal
INICIO
ED: n,r INTEIRO
LER (n, r)
ESCREVER (fatorial( n ) / (fatorial( r ) * fatorial( n - r ) ) )
FIM
Módulo fatorial
DEFINIR INTEIRO fatorial( numero ) independência
ED: resultado, i INTEIRO
resultado  1
REPETIR PARA i  2 ATE numero PASSO 1
FIMREPETIR
RETORNAR resultado abstração
FIM
Modularização – tipos
Procedimento
▪ Módulo que executa uma sequência de instruções
RAIZQUADRADA
▪ Exemplo: (função)
▪ ESCREVER (“Olá, bom dia”)
ESCREVER
(procedimento)
Função
▪ Módulo que executa uma sequência de instruções SENO
e, no final, retorna um valor ao ponto da sua (função)
chamada
▪ Exemplo da raiz quadrada de um número

Módulo Principal
▪ resultado  RAIZQUADRADA (25)
Modularização – âmbito das variáveis
Variáveis Globais
▪ Acessíveis em todo o programa, dentro de qualquer módulo
▪ Declaradas fora dos módulos
▪ Desvantagens
▪ Dificultam a compreensão do algoritmo porque é necessário analisar
em todo o programa a forma como são utilizadas
▪ Maior dificuldade em detetar eventuais erros
▪ Dificultam a reutilização dos módulos noutros algoritmos que usem as
mesmas variáveis globais
▪ Recomendação
▪ Evitar o uso de variáveis globais
▪ Usar variáveis locais
▪ Comunicar entre módulos com passagem de parâmetros
Variáveis Locais
▪ Declaradas dentro dos módulos
▪ Acessíveis apenas no módulo onde são declaradas
▪ Só existem durante a execução do respetivo módulo
▪ Vantagens
▪ Independência dos módulos
▪ Facilitam o desenvolvimento dos programas
ED: numero REAL
Variável global: válida em todos os módulos

Módulo 1
ED: numero INTEIRO
Módulo 2 Variável local com o mesmo nome de

variável global!
ED: altura REAL
Neste caso, a variável local sobrepõe-se à
Módulo 3 variável global dentro do módulo
ED: idade INTEIRO
Variável local: válida apenas dentro do módulo

Módulo Principal
ED: peso REAL
Modularização – passagem de parâmetros
Passagem de parâmetros
▪ Meio de Comunicação entre Módulos Independentes
▪ Suportam a transferência de informação entre módulos
▪ Entrada de Dados
▪ Saída de Resultados
▪ Os parâmetros funcionam como variáveis locais, só são visíveis dentro do
módulo e são inicializadas com os valores dos argumentos de chamada
▪ Tipos de Parâmetros
▪ Atuais
▪ valores passados para o módulo chamado para inicializar os seus
parâmetros formais (normalmente, designados por argumentos)
▪ Formais
▪ identificadores que recebem os valores passados para esse módulo
(normalmente, designados apenas por parâmetros)
Correspondência entre parâmetros atuais e parâmetros formais
▪ A correspondência é feita pela ordem dos parâmetros formais

▪ Primeiro parâmetro formal liga-se ao primeiro parâmetro atual e assim por
diante
▪ Exemplo:
maior(INTEIRO numero1, INTEIRO numero2 )
maior ( 5, 12)
Exemplo:
INTEIRO maior( INTEIRO numero1, INTEIRO numero2 )

…
SE (numero1 > numero2) ENTAO
RETORNAR numero1 Parâmetros formais
SENAO (parâmetros)
retorno RETORNAR numero2
…
Parâmetros atuais
…
(argumentos)
ESCREVER ( maior( 5, 3) )
ESCREVER ( maior( 235, 1523) )
x  maior( 5, maior( 90, 61 ) )
…
Modularização
▪ Função
▪ Sintaxe
DEFINIR tipo_retorno nome (tipo pf1, ..., tipo pfn) // cabeçalho
ED: // variáveis e constantes locais
INÍCIO
// corpo da função
RETORNAR valor_do_tipo_retorno
FIMDEFINIR
▪ Exemplo
DEFINIR INTEIRO maior(INTEIRO x, INTEIRO y)
ED: INTEIRO resultado
INÍCIO
SE (x > y) ENTÃO
resultado  x
SENÃO
resultado  y
FIMSE
RETORNAR resultado // resultado tem de ser INTEIRO (tipo_retorno)
FIMDEFINIR
Modularização
▪ Procedimento
▪ Sintaxe
DEFINIR nome (tipo pf1, ..., tipo pfn) // cabeçalho
ED: // variáveis e constantes locais
INÍCIO
// corpo do procedimento
FIMDEFINIR //não tem retorno
▪ Exemplo
DEFINIR mostrarNumerosDoIntervalo(INTEIRO limiteInf, INTEIRO limiteSup)
ED: INTEIRO x;
INÍCIO
REPETIR PARA x  limiteInf ATE limiteSup PASSO 1
ESCREVER ( x )
FIMREPETIR
FIMDEFINIR
Modularização ED: INTEIRO numero
INÍCIO
Problema: LER ( numero )
mostrarAlgarismos ( numero )
Leia um número inteiro e mostre os seus ESCREVER ( contarAlgarismos ( numero) )
algarismos linha a linha. Mostre também FIM
quantos algarismos possui esse número. DEFINIR mostrarAlgarismos(INTEIRO numero)
ED: INTEIRO algarismo
Desenvolva um programa adotando uma INÍCIO
estrutura modular. Para tal crie um REPETIR ENQUANTO ( numero > 9 )
procedimento para mostrar os algarismo  numero % 10
ESCREVER ( algarismo )
algarismos e uma função para calcular e numero  numero / 10
retornar a quantidade de algarismos de FIMREPETIR
ESCREVER ( numero )
um número inteiro. FIMDEFINIR
DEFINIR INTEIRO contarAlgarismos(INTEIRO numero)

ED: INTEIRO qtd
INÍCIO
qtd  1
REPETIR ENQUANTO ( numero > 9 )
numero  numero / 10
qtd  qtd + 1
FIMREPETIR
RETORNAR ( qtd )
FIMDEFINIR
<Java métodos>
Java - métodos
Um método é uma sequência de instruções que realiza uma tarefa específica e no final pode
retornar:
▪ Um valor de um determinado tipo (int, double, String, …)
▪ Nada (void)
▪ Tipos de Métodos
▪ Métodos de instância
▪ Métodos de classe
▪ Métodos de Instância
▪ Aplicam-se aos objetos da classe ( Ex: Scanner ler = new Scanner(System.in);
String s = ler.next(); )
▪ Métodos de Classe
▪ Aplicam-se à classe ( Ex: double a = Math.sqrt(25.0) )
▪ Declarados como métodos estáticos (static) ( Ex: public static double sqrt(double x) )
Java - métodos de classe
▪ Declaração Parâmetros formais
▪ Tipo Procedimento
modificador_acesso static void nome(tipo pf1, tipo pf2, ...., tipo pfn){
…
}
▪ Tipo Função
modificador_acesso static tipo_retorno nome(tipo pf1, tipo pf2, ...., tipo pfn){
...
return expressão;
}
Obs: O cabeçalho dos métodos de classe inclui o prefixo static
Java - métodos de instância
▪ Declaração Parâmetros formais
modificador_acesso void nome(tipo pf1, tipo pf2, ...., tipo pfn){
…
}
▪ Tipo Função
modificador_acesso tipo_retorno nome(tipo pf1, tipo pf2, ...., tipo pfn){
...
return expressão;
}
Obs: O cabeçalho dos métodos de instância não inclui o prefixo static
Java - métodos
▪ Declaração
modificador_acesso void nome(tipo pf1, tipo pf2, ...., tipo pfn){
…
}
▪ Tipo Função
modificador_acesso tipo_retorno nome(tipo pf1, tipo pf2, ...., tipo pfn){
...
return expressão;
}
▪ Modificadores de Acesso
▪ private // método só pode ser chamado por métodos da própria classe
▪ public // método pode ser chamado por métodos de qualquer classe
▪ Sem modificador // método pode ser chamado por métodos de classes do mesmo package
Java - métodos
▪ Parâmetro Formal de Tipo Primitivo
▪ Tipos primitivos: byte, short, int, long, float, double, boolean, char
▪ É passada a cópia de um valor

▪ Método chamado não tem acesso ao parâmetro atual
▪ Alterações posteriores do parâmetro formal não afetam parâmetro actual
▪ Exemplo:
public class Exemplo{
public static void main(String[] args){
int c=0;
metodo(c);
System.out.println("C=" + c);
}
private static void metodo(int c){

c=1;
}
} // Programa escreve C=0
Java - métodos
▪ Parâmetro Formal de Tipo Não Primitivo
▪ Tipos não primitivos
▪ Tipos criados pelo programador
▪ Estruturas indexadas (arrays)
▪ O identificador é seguido de []
▪ Exemplo: int[], float[], double[], String[], …
▪ É passada a cópia de uma referência

▪ Método chamado tem acesso ao parâmetro atual
▪ Alterações posteriores do parâmetro formal afetam parâmetro actual
▪ String é exceção – é imutável
Java - métodos public class Algarismos {
Problema: public static void main(String[] args) {

Scanner ler = new Scanner(System.in);
Leia um número inteiro e int numero;
mostre os seus algarismos linha numero = ler.nextInt();
a linha. Mostre também mostrarAlgarismos(numero);
System.out.println(contarAlgarismos(numero));
quantos algarismos possui esse }
número.
public static void mostrarAlgarismos(int numero) {
Desenvolva um programa int algarismo;
adotando uma estrutura while (numero > 9) {
algarismo = numero % 10;
modular. Para tal crie um System.out.println(algarismo);
numero = numero / 10;
procedimento para mostrar os }
algarismos e uma função para System.out.println(numero);
}
calcular e retornar a quantidade
de algarismos de um número public static int contarAlgarismos(int numero) {
int qtd = 1;
inteiro. while (numero > 9) {
qtd = qtd + 1;
}
return (qtd);
}
}
SRP – Single Responsibility Principle
The Single Responsibility Principle (SRP) is a design pattern in computer
programming that states that every module, class, or function should have only
one reason to change. This means that each module should have a well-
defined responsibility, and solve only one small problem, not many.
The SRP helps to create modular and scalable systems, by ensuring that each
module has a clear, well-defined responsibility. This makes the code easier to
understand, maintain, and modify, and improves the overall quality of the code.
https://www.cleancode.studio/design-patterns/single-responsibility-design-pattern
DRY – Do not Repeat Yourself
DRY is a basic principle of software development aimed at reducing repetition of

information.
The DRY principle is stated as, “Every piece of knowledge or logic must have a
single, unambiguous representation within a system.”
Divide your code and logic into smaller reusable units (methods) and use that code by
calling it where you want.
Don’t write lengthy methods, but divide logic and try to use the existing piece in your
method.
Do not use copy and paste obsessively. Every time you see duplication in the code, it
represents a missed opportunity for abstraction (i.e. extracting that code to a separate
function).
https://www.cleancode.studio/design-patterns/single-responsibility-design-pattern
Methods should have verb or verb phrase names like
postPayment(), deletePage(), getName() or save().
</Java métodos>
<Java Strings>
Java - Strings
String
▪ Cadeia de carateres = texto
▪ Exemplos
▪ "ISEP"
▪ "Algoritmia e Programação"
▪ “JUPITER"
▪ Declaração
String v = ""; // String vazia
String s = "ISEP";
String nome = “Ana Berta Carla Dionísio”;
Java - Strings
Carateres especiais
• Strings podem conter carateres especiais com funções específicas (sequência de escape)
• Cada sequência de escape é um único carácter embora seja escrito com dois símbolos.
\t Insere um tab no texto

\b Insere um backspace no texto
\n Insere uma mudança de linha no texto
\r Insere um carriage return no texto
\’ Insere uma plica no texto.
\“ Insere uma aspa no texto.
\\ Insere uma barra para trás (backslash) no texto
▪ Exemplos
String s = "Aprog\t, é \”fixe\” e fácil"; //s=“Aprog , é “fixe” e fácil”
Java - Strings
String
String s = “Bom dia, Rui"; conteúdo
B o m d i a , R u i
0 1 2 3 4 5 6 7 8 9 10 11
posições
a posição inicial é zero (0) e não um (1)
System.out.println( s.charAt(0) );
Java - Strings
Métodos
▪ int length()
▪ String toLowerCase()
▪ String toUpperCase()
▪ int compareTo(String outraString)
▪ boolean equals(String outraString)
▪ boolean equalsIgnoreCase(String outraString)
▪ String trim()
▪ char charAt( int índice )
▪ …
Java - Strings
▪ Exemplos // considerando: String s = "Aprog";
▪ int length()
▪ Retorna comprimento da string (quantidade de carateres)
int comprimento = s.length(); // comprimento = 5
▪ String toLowerCase()
▪ Retorna a string com todas as letras minúsculas
String s2 = s.toLowerCase(); // s2 = “aprog”
▪ String toUpperCase()
▪ Retorna a string com todas as letras maiúsculas
String s2 = s.toUpperCase(); // s2 = “APROG”
Java - Strings
▪ Comparação de Strings
Não se pode usar os operadores relacionais para comparar Strings
É necessário verificar se o conjunto de carateres é o mesmo e pela mesma ordem
▪ int compareTo(String outraString)

▪ Compara duas strings alfabeticamente e retorna um número inteiro
▪ Negativo Ex: s.compareTo("PPROG") s é anterior a "PPROG"
▪ Positivo Ex: s.compareTo("ALIN") s é posterior a "ALIN"
▪ Zero Ex: s.compareTo("Aprog") s e "Aprog" são iguais
if ( s.compareTo("APROG")==0 )
System.out.println(" s=APROG ");
else
System.out.println(" s≠APROG ");
Java - Strings
▪ boolean equals(String outraString) if ( s.equals("APROG") )

▪ Distingue maiúsculas de minúsculas System.out.println(" s=APROG ");
else
s ≠ “APROG” System.out.println(" s≠APROG ");
▪ boolean equalsIgnoreCase(String outraString)

▪ Compara duas strings alfabeticamente sem distinguir maiúsculas de minúsculas e
retorna:
▪ true caso sejam iguais
if ( s.equalsIgnoreCase("APROG"))
▪ false caso sejam diferentes System.out.println(" s=APROG ");
else
System.out.println(" s≠APROG ");
s = “APROG”
Java - Strings
▪ char charAt( int índice )

▪ Retorna o caráter que se encontra na posição “índice”
char c = s.charAt(0); // c = 'A'
char c = s.charAt(1); // c = 'p’
▪ String trim()
▪ Retorna cópia da string sem espaços brancos iniciais e finais
String s1 = " APROG ";
String s2 = s1.trim(); // s2 = "APROG"
Java - Strings
▪ Concatenar Strings - Usa-se o operador +
Permite criar uma nova string a partir da junção dos valores de várias strings ou números.
O primeiro elemento da junção tem de ser uma string.
▪ Exemplos
String s = “Hoje é” + “ domingo, dia ” + 15;
s = “Hoje é domingo, dia 15”

String s1 = “ D ”;
String s2 = “ia”;
int dia = 15;
String s = s1.trim() + s2 + dia;
s = “Dia15”
</Java Strings>
<modularização
casos de uso>
Java - métodos
Problema1(v1): Ler uma frase e mostrar quantas vogais existem nessa frase.
public class VogaisMetodoUnico {

public static void main(String[] args) {
String frase;
int qtdVogais=0;
frase=ler.nextLine();
frase = frase.toLowerCase(); //passar tudo para minúsculas para não repetir
for(int i=0; i<frase.length(); i++){

switch(frase.charAt(i)){
case 'a': percorrer todos os carateres da frase
case 'e':
case 'i':
case 'o':
case 'u': qtdVogais++;
break;
}
}
System.out.println("Vogais=“ + qtdVogais);
}
}
Java - métodos
Problema2(v1): Ler duas frases e mostrar quantas vogais tem cada uma.
String frase1;
int qtdVogais1=0;
frase1=ler.nextLine();
frase1 = frase1.toLowerCase(); //passar tudo para minúsculas para não repetir
for(int i=0; i<frase1.length(); i++){
switch(frase1.charAt(i)){
case 'a':
case 'e':
case 'i':
case 'o':
case 'u': qtdVogais1++; break;
}
} [Copy + Paste] (duplicar o código)
System.out.println("Vogais1="+qtdVogais1);
//------------------------------------------------------ + alterar o nome das variáveis
String frase2;
int qtdVogais2=0;
frase2 = frase2.toLowerCase();
case 'a':
case 'e': possível ocorrência de erros:
case 'i': Depois da cópia, escapou à alteração
case 'o':
}
}
}
}
Java - métodos
String frase1;
int qtdVogais1=0;
case 'a':
case 'e':
case 'i':
case 'o': Desvantagens:
} - Código duplicado
}
- Código extenso e difícil de ler
//------------------------------------------------------ - Maior possibilidade de erros
String frase2;
int qtdVogais2=0; - Mais difícil manter o código
case 'a':
case 'e':
case 'i':
case 'o':
}
}
}
}
Java - métodos
Problema2.1: Ler quatro frases e mostrar quantas vogais tem cada uma.
String frase1;
int qtdVogais1=0;
}
case 'a':
case 'e':
case 'i':
case 'o':
Parece razoável ???
}
//------------------------------------------------------
String frase2;
int qtdVogais2=0;
case 'a':
case 'e':
case 'i':
case 'o':
}
}
}
//------------------------------------------------------
String frase2;
int qtdVogais2=0;
case 'a':
case 'e':
case 'i':
case 'o':
}
}
}
//------------------------------------------------------
String frase2;
int qtdVogais2=0;
case 'a':
case 'e':
case 'i':
case 'o':
}
}
}
}
Java - métodos
public class VogaisMetodoSeparado {
Scanner ler = new Scanner(System.in); Abstração da implementação
String frase;
System.out.println("Vogais=“ + contarVogaisNaFrase(frase));
}
public static int contarVogaisNaFrase(String frase){

int qtdVogais=0;

case 'a':
case 'e':
case 'i':
case 'o':
break;
}
}
return qtdVogais;
}
}
Java - métodos
public class VogaisMetodoSeparado {
Scanner ler = new Scanner(System.in); Não há [Copy + Paste] do código
Há reutilização do código
String frase1 = ler.nextLine();
String frase2 = ler.nextLine();
System.out.println("Vogais1=“ + contarVogaisNaFrase(frase1));
System.out.println("Vogais2=“ + contarVogaisNaFrase(frase2));
}

int qtdVogais=0;

case 'a':
case 'e':
case 'i': O algoritmo está num local único e não
case 'o': tem de ser alterado fora daqui
break;
}
}
return qtdVogais;
}
}
Java - métodos
public class VogaisMetodoSeparadoAbstrato {
String frase;
}

return contarOcorrenciasDoSimbolo(frase, 'a')+ Há reutilização do código
contarOcorrenciasDoSimbolo(frase, 'e')+
contarOcorrenciasDoSimbolo(frase, 'i')+
contarOcorrenciasDoSimbolo(frase, 'o')+ A lógica de cada invocação está num
contarOcorrenciasDoSimbolo(frase, 'u');
} local único
public static int contarOcorrenciasDoSimbolo(String frase, char simbolo){

int qtd=0;

if(frase.charAt(i) == simbolo) Criar um método mais genérico
qtd++;
}
return qtd;
}
}
Java - métodos
Problema3: Ler uma frase e mostrar quantas vogais, vírgulas e pontos de
interrogação existem nessa frase.
public class VogaisMetodoSeparadoAbstrato {
String frase = ler.nextLine();

System.out.println("Vírgulas=“ + contarOcorrenciasDoSimbolo(frase, ‘,’));
System.out.println(“Pontos de interrogação=“ + contarOcorrenciasDoSimbolo(frase,’?’));
}
return contarOcorrenciasDoSimbolo(frase, 'a')+
contarOcorrenciasDoSimbolo(frase, 'e')+
contarOcorrenciasDoSimbolo(frase, 'i')+
contarOcorrenciasDoSimbolo(frase, 'o')+
contarOcorrenciasDoSimbolo(frase, 'u');
}
public static int contarOcorrenciasDoSimbolo(String frase, char simbolo){

int qtd=0;

if(frase.charAt(i) == simbolo)
qtd++;
}
return qtd;
}
}
Java - métodos
Problema 4: Ler a idade de uma pessoa. Considerar apenas o intervalo [0,120];
public class LerIdadeValida {

int idade = lerInteiroNoIntervalo(0,120);

System.out.println("Idade="+idade);
}
public static int lerInteiroNoIntervalo(int lim1, int lim2){
int numero;
System.out.println("Numero:["+lim1+","+lim2+"]:");
numero=ler.nextInt();
while(numero < lim1 || numero > lim2){
}
return numero;
}
}
Java - métodos
Problema 5: Ler a idade, o peso e a altura de uma pessoa. Considerar apenas válidos
valores dentro dos intervalos: idade=[0,120]; peso=[100g,300000g]; altura=[30cm,250cm];
public class LerIdadeValida { Há reutilização do código

int idade = lerInteiroNoIntervalo(0,120);
int peso = lerInteiroNoIntervalo(100,300000);
int altura = lerInteiroNoIntervalo(30,250);
} Parâmetros distintos para
usos diferentes
public static int lerInteiroNoIntervalo(int lim1, int lim2){
int numero;
método já existente
while(numero < lim1 || numero > lim2){
}
return numero;
}
}
Java - métodos
Problema 6: Ler uma string e verificar se é elegível para password. Uma password
tem de conter no mínimo 8 símbolos e pelo menos um elemento de cada um dos
seguintes conjuntos: letras maiúsculas, minúsculas e algarismos.
public class ValidarPassword {
Scanner ler = new Scanner(System.in); Abstração da implementação

String password = ler.nextLine();
if( ePasswordValida(password))
System.out.println("password válida");
else
System.out.println("password NAO É válida");
}
Java - métodos
Problema 6: Ler uma string e verificar se é elegível para password. Uma password
tem de conter no mínimo 8 símbolos e pelo menos um elemento de cada um dos
seguintes conjuntos: letras maiúsculas, minúsculas e algarismos.
…
public static boolean ePasswordValida(String pwd){
final int MIN_TAMANHO = 8;
final int MIN_SIMBOLOS = 1; Usar CONSTANTES em vez de literais
int maiusculas, minúsculas, numeros;
char simbolo;
if(pwd.length() < MIN_TAMANHO) A lógica da validação está num local único

return false;
e é completamente transparente para o
maiusculas = minúsculas = numeros = 0; resto do programa
for(int i=0; i < pwd.length(); i++) {
simbolo = pwd.charAt(i);
if( Character.isDigit(simbolo)) {
numeros++;
} else if (Character.isUpperCase(simbolo)) {
maiúsculas++;
} else if (Character.isLowerCase(simbolo)) {
minúsculas++;
}
}
if(numeros < MIN_SIMBOLOS || maiúsculas < MIN_SIMBOLOS || minúsculas < MIN_SIMBOLOS)

return false;
else
return true;
}
Java - métodos
Problema 6.1: Ler uma string e verificar se é elegível para password. Uma password tem
de conter no mínimo 12 símbolos e pelo menos dois elementos de cada um dos seguintes
conjuntos: letras maiúsculas, minúsculas e algarismos.
…
public static boolean ePasswordValida(String pwd){
final int MIN_TAMANHO = 12;
final int MIN_SIMBOLOS = 2;
int maiusculas, minúsculas, numeros; Se mudar a lógica da validação, as alterações
char simbolo; serão efetuadas apenas neste módulo.
if(pwd.length() < MIN_TAMANHO)
return false; Não tem qualquer impacto no código dos
outros módulos
maiusculas = minúsculas = numeros = 0;
for(int i=0; i < pwd.length(); i++) {
simbolo = pwd.charAt(i);
if( Character.isDigit(simbolo)) {
numeros++;
} else if (Character.isUpperCase(simbolo)) {
maiúsculas++;
} else if (Character.isLowerCase(simbolo)) {
minúsculas++;
}
}
if(numeros < MIN_SIMBOLOS || maiúsculas < MIN_SIMBOLOS || minúsculas < MIN_SIMBOLOS)

return false;
else
return true;
}
Java - métodos
Problema 7 (v1): Quantas vezes surge o algarismo 3 entre os números 100 e 1000?
public class OcorrenciasDoAlgarismo3 {

int qtd = 0;
for (int numero = 100; numero <= 1000; numero++) {
int num = numero;
while (num > 9) {
int resto = num % 10; Intervalo de pesquisa
num = num / 10;
if (resto == 3) {
qtd++;
}
} Algarismo a comparar
if (num == 3) {
qtd++;
}
}
System.out.println(qtd);
}
}
Java - métodos
public class OcorrenciasDoAlgarismo3NoIntervalo {

System.out.println(contar3NoIntervalo(100, 1000));
}
public static int contar3NoIntervalo(int lim1, int lim2) {

int qtd = 0;
for (int numero = lim1; numero <= lim2; numero++) {
int num = numero;
while (num > 9) {
int resto = num % 10; Intervalo de pesquisa definido pelos parâmetros
num = num / 10;
if (resto == 3) {
qtd++;
}
} Algarismo a comparar é fixo !
if (num == 3) {
qtd++;
}
}
return qtd;
}
}
Java - métodos
public class OcorrenciasDeAlgarismoNoIntervalo {
System.out.println(contarAlgarismoNoIntervalo(3, 100, 140));
}
public static int contarAlgarismoNoIntervalo(int algarismo, int lim1, int lim2) {

int qtd = 0;
int num = numero;
while (num > 9) {
int resto = num % 10; Intervalo de pesquisa definido pelos parâmetros
num = num / 10;
if (resto == algarismo) {
qtd++;
}
}
if (num == algarismo) { Algarismo a comparar definido por parâmetro
qtd++;
}
}
return qtd;
}
}
Java - métodos
Problema 8: Quantas vezes surge o algarismo 3, 1 e 5 entre os números 100 e 1000 e o 2
e 4 entre os números 11 e 64?
public class OcorrenciasDeAlgarismoNoIntervalo {
}
public static int contarAlgarismoNoIntervalo(int algarismo, int lim1, int lim2) {

int qtd = 0;
int num = numero;
while (num > 9) {
int resto = num % 10;
num = num / 10; Há abstração da implementação.
if (resto == algarismo) {
qtd++; Há reutilização do código
}
}
if (num == algarismo) {
qtd++;
}
}
return qtd;
}
}
Java - métodos
Problema 9: Ler o nome de uma disciplina, a quantidade de positivas e negativas
e mostrar no seguinte formato (exemplo: “Algorimia” 4 2):
Disciplina : Algoritmia
Positivas : ****
Negativas : **

Scanner sc=new Scanner(System.in);
String disciplina=sc.next();
int positivas=sc.nextInt();
int negativas=sc.nextInt();
System.out.println(“Disciplina : ” + disciplina);
System.out.print(“Positivas : “);
for (int i = 0; i < positivas; i++) {
System.out.print(“*”);
} Redundância
System.out.println();
System.out.print(“Negativas : “);
for (int i = 0; i < negativas; i++) {
}
}
Java - métodos
Positivas : ****
Negativas : **

Scanner sc=new Scanner(System.in);
Reutilização
System.out.println(“Disciplina : “ + disciplina);
verInfoDaDisciplina(“Positivas : “, positivas);
verInfoDaDisciplina(“Negativas : “, negativas);
}
public static void verInfoDaDisciplina(String mensagem, int valor) {

System.out.print(mensagem);
for (int i = 0; i < valor; i++) {
System.out.print(“*”); Abstração
}
System.out.println(); Independência
}
Java - métodos
Positivas : ****
Negativas : **
Scanner sc=new Scanner(System.in); Maior nível de Abstração
tratarDisciplina(disciplina, positivas, negativas);
}
public static void tratarDisciplina(String disciplina, int positivas, int negativas){
System.out.println(“Disciplina : “ + disciplina);
verInfoDaDisciplina(“Positivas : “, positivas);
verInfoDaDisciplina(“Negativas : “, negativas);
}
public static void verInfoDaDisciplina(String mensagem, int valor) {
System.out.print(mensagem);
for (int i = 0; i < valor; i++) {
}
System.out.println();
}
código
Excertos de resoluções submetidas no Mooshak Sugestões de melhoria
DRY
Java - métodos “Don’t Repeat Yourself”
Excertos de resoluções: Exemplo 1:

i = 0; public static void método(int num1, int num2){
j = 1; i = 0;
if (num1 > num2) { j = 1;
for (j = 1;i==0; j++) { for (j = 1;i==0; j++) {
mmc = num1 * j; mmc = num1 * j;
if (mmc % num2 == 0) { if (mmc % num2 == 0) {
System.out.println(mmc); System.out.println(mmc);
i++; i++;
} Redundância } Parametrizar método
} }
} else { }
for (j = 1; i==0; j++) {
mmc = num2 * j;
if (mmc % num1 == 0) {
System.out.println(mmc); public static void main(String[] args){
i++; if (num1 > num2) {
} método(num1, num2);
}else{ Personalizar
} método(num2, num1); parâmetros
} }
}
KISS
Java - métodos “Keep It Simple Stupid”

int digito = 24209849; boolean existeImpar = false;
while (numero>0){ while (numero>0){
if (numero % 2 != 0){ if (numero % 2 != 0){
digito = numero%10; existeImpar = true;
produto = produto * digito;
Qual é a lógica? digito = numero%10;
numero = numero/10; Que valor é este? produto = produto * digito;
}else { numero = numero/10;
numero = numero / 10; }else {
} numero = numero / 10;
}if (digito !=24209849){ } usar lógica adequada?
System.out.println(produto); }if (existeImpar){
}else{ System.out.println(produto);
System.out.println("no odd digits"); }else{
} System.out.println("no odd digits");
}
Single
Java - métodos Responsibility
public static int combinations( int factorial, int factorial2, int factorial3){
int combination = factorial / (factorial2 * factorial3);
return combination;
}
public static int permutations( int factorial, int factorial3){
int permutation = factorial / (factorial3);
return permutation;
}
public static void main(String[] args) { Não garantem o que o nome do método representa!
Scanner input = new Scanner(System.in);
int num = input.nextInt();
int num2 = input.nextInt();
int factorial = factorial(num);
int factorial2 = factorial(num2); Cálculos fundamentais fora dos métodos
int factorial3 = factorial(num-num2);
if(factorial3>0){
int combination = combinations(factorial, factorial2, factorial3);
int permutation = permutations(factorial, factorial3);
public static int getCombinations( int m, int n){

int combination = factorial(m) / (factorial(n) * factorial(m-n));
return combination;
}
public static int getPermutations( int m, int n){
int permutation = factorial(m) / factorial(m-n);
Garante que faz o que representa!
return permutation; É responsável pelos cálculos necessários
}
KISS DRY
Java - métodos “Keep It Simple Stupid” “Don’t Repeat Yourself”

. . .
System.out.printf("ang(a,b)=" + "%.2f%n", anguloInterno1(lado1, lado2, lado3));
System.out.printf("ang(a,c)=" + "%.2f%n", anguloInterno2(lado1, lado2, lado3));
System.out.printf("ang(b,c)=" + "%.2f%n", anguloInterno3(lado1, lado2, lado3));
}
public static double anguloInterno1(double l1, double l2, double l3) {
double ang1 = Math.pow(l1, 2) + Math.pow(l2, 2) - Math.pow(l3, 2);
ang1 /= (2 * l1 * l2);
ang1 = Math.acos(ang1);
return Math.toDegrees(ang1);
} Redundância
public static double anguloInterno2(double n1, double n2, double n3) {
double ang2 = Math.pow(n1, 2) + Math.pow(n3, 2) - Math.pow(n2, 2);
ang2 /= (2 * n1 * n3);
}
public static double anguloInterno3(double x1, double x2, double x3) {
double ang3 = Math.pow(x2, 2) + Math.pow(x3, 2) - Math.pow(x1, 2);
ang3 /= (2 * x2 * x3);
} Nome representativo (verbo)
. . .
System.out.printf("ang(a,b)=" + "%.2f%n", calcularAngulo(lado1, lado2, lado3));
System.out.printf("ang(a,c)=" + "%.2f%n", calcularAngulo(lado1, lado3, lado2)); Reutilização
System.out.printf("ang(b,c)=" + "%.2f%n", calcularAngulo(lado2, lado3, lado1));
}
public static double calcularAngulo(double l1, double l2, double l3) {
double ang1 = Math.pow(l1, 2) + Math.pow(l2, 2) - Math.pow(l3, 2);
ang1 /= (2 * l1 * l2);
}
Single
Java - métodos 2 values Responsibility
public static double getVolume(String type, double value1, double value2){
double res = 0;
switch(type){
case "cylinder": calcula 3 coisas diferentes
res = Math.PI * Math.pow(value1,2) * value2;
break;
case "sphere":
res = (4.0/3) * Math.PI * Math.pow(value1,3);
break;
case "cone":
res = (1.0/3) * Math.PI * Math.pow(value1,2) * value2; Mas, só usa value1 !!!
}
E value2 para que serve neste caso?
return res;
}
public static double getCylinderVolume(double value1, double value2){

return Math.PI * Math.pow(value1,2) * value2;
}
public static double getSphereVolume(double value1){ - Calcula separadamente
return (4.0/3) * Math.PI * Math.pow(value1,3);
}
- usa apenas o que necessita
public static double getConeVolume(double value1, double value2){
return (1.0/3) * Math.PI * Math.pow(value1,2) * value2;
}
Single KISS
Java - métodos Responsibility “Keep It Simple Stupid”

if(Math.abs(lado_b-lado_c) < lado_a && lado_a < lado_b+lado_c && Math.abs(lado_a-lado_c) < lado_b
&& lado_b < lado_a+lado_c && Math.abs(lado_a-lado_b) < lado_c && lado_c < lado_b+lado_a){
...
}
Múltiplas responsabilidades
public static boolean eTriangulo(double lado_a, double lado_b, double lado_c){

if(Math.abs(lado_b-lado_c) < lado_a && lado_a < lado_b+lado_c && Math.abs(lado_a-lado_c) < lado_b
&& lado_b < lado_a+lado_c && Math.abs(lado_a-lado_b) < lado_c && lado_c < lado_b+lado_a)
return true;
else
return false;
}
Responsabilidade única
. . .
if(eTriangulo(lado_a, lado_b, lado_c)){

...
}
</modularização – casos de uso>
Java - métodos
int numero1, numero2, N,res=0,n1=0,n2=0;
N = ler.nextInt();
for (int i = 0; i <= N; i++) {
do {
numero1 = ler.nextInt();
} while (numero1 < 0);
do { Redundância
numero2 = ler.nextInt();
} while (numero2 < 0);
if (ContDig (numero1, numero2) >= res){
res=ContDig (numero1, numero2); Repetição na invocação do método!
n1=numero1;
n2=numero2;
}
}
if (res > 0){
System.out.println(n1 + "/" + n2);
}else {
System.out.println("sem resultados");
}
}
Java - métodos
public static void main(String[] args) { static Scanner ler = new Scanner(System.in);
int numero1, numero2, N,res=0,n1=0,n2=0; public static void main(String[] args) {
Scanner ler = new Scanner(System.in); int numero1, numero2, N, n1 = 0, n2 = 0;
N = ler.nextInt(); int res = 0;
for (int i = 0; i <= N; i++) { N = ler.nextInt();
do { for (int i = 0; i <= N; i++) {
numero1 = ler.nextInt(); numero1 = lerNumeroMaiorQueZero();
} while (numero1 < 0); numero2 = lerNumeroMaiorQueZero();
do { int contaDig = ContDig(numero1, numero2);
numero2 = ler.nextInt(); if ( contaDig >= res) {
} while (numero2 < 0); res = contaDig;
if (ContDig (numero1, numero2) >= res){ n1 = numero1; Evitar repetição
res=ContDig (numero1, numero2); n2 = numero2;
n1=numero1; }
n2=numero2; }
} . . .
} }
if (res > 0){
System.out.println(n1 + "/" + n2); private static int lerNumeroMaiorQueZero() {
}else { int numero1;
System.out.println("sem resultados"); do {
} numero1 = ler.nextInt();
} } while (numero1 < 0);
return numero1; Abstração
}
Independência
Java - métodos
Scanner ler= new Scanner((System.in));
int N,num;
N=ler.nextInt();
num=0;
while (num<=N){
if (numArmtrong(num)==num) Verificação da condição fora do método!
System.out.println(num);
num++;
}
}
public static double numArmtrong(int num){ O método deve verificar se é nº de Armstrong
double res,dig,ndig;
int val;
val=num;
ndig=0;
res=0;
while (val>0){
val=val/10;
ndig++;
}
while (num>0){ Cálculos diferentes no mesmo método!
dig=num%10;
res=res+Math.pow(dig,ndig);
num=num/10;
}
return (res);
}
Java - métodos
int N = ler.nextInt();
for (int numero = 0; numero <= N; numero++) {
if (eNumeroDeArmstrong(numero))
System.out.println(numero);
}
}
private static boolean eNumeroDeArmstrong(int numero) {

int totalDeAlgarismos = quantidadeDeAlgarismos(numero);
int resultado = calcular(numero, totalDeAlgarismos);
O método verifica e retorna se
return (resultado == numero); é ou não um nº de Armstrong
}
private static int calcular(int numero, double totalDeAlgarismos) {

int resultado = 0;
while (numero > 0) {
int algarismo = numero % 10;
resultado = resultado + (int) Math.pow(algarismo, totalDeAlgarismos);
}
return resultado;
}
private static int quantidadeDeAlgarismos(int numero) {

int totalDeAlgarismos = 0;
while (numero > 0) {
numero = numero / 10; Cálculos diferentes realizados
totalDeAlgarismos++;
} em métodos diferentes
return totalDeAlgarismos;
}

2 - Modularizacao

Enviado por

Dados do documento

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

2 - Modularizacao

Enviado por

Direitos autorais:

Formatos disponíveis

APROG – Algoritmia e Programação

Módulo único Módulo 1

▪ Na chamada de um módulo, o controlo passa temporariamente para o

▪ Após a execução de um módulo, o controlo retorna para o módulo que o

▪ Abstração da implementação de tarefas

ESCREVER (fn / (fr * fnr))

▪ Exemplo da raiz quadrada de um número

Variável global: válida em todos os módulos

ED: numero INTEIRO

Módulo 2 Variável local com o mesmo nome de

ED: idade INTEIRO

Variável local: válida apenas dentro do módulo

ED: peso REAL

▪ A correspondência é feita pela ordem dos parâmetros formais

maior(INTEIRO numero1, INTEIRO numero2 )

INTEIRO maior( INTEIRO numero1, INTEIRO numero2 )

DEFINIR INTEIRO contarAlgarismos(INTEIRO numero)

Obs: O cabeçalho dos métodos de classe inclui o prefixo static

Obs: O cabeçalho dos métodos de instância não inclui o prefixo static

▪ public // método pode ser chamado por métodos de qualquer classe

▪ É passada a cópia de um valor

private static void metodo(int c){

▪ É passada a cópia de uma referência

Problema: public static void main(String[] args) {

DRY is a basic principle of software development aimed at reducing repetition of

\t Insere um tab no texto

String s = "Aprog\t, é \”fixe\” e fácil"; //s=“Aprog , é “fixe” e fácil”

String s = “Bom dia, Rui"; conteúdo

a posição inicial é zero (0) e não um (1)

Não se pode usar os operadores relacionais para comparar Strings

É necessário verificar se o conjunto de carateres é o mesmo e pela mesma ordem

▪ Exemplos // considerando: String s = "Aprog";

▪ int compareTo(String outraString)

▪ boolean equals(String outraString) if ( s.equals("APROG") )

▪ boolean equalsIgnoreCase(String outraString)

▪ char charAt( int índice )

s = “Hoje é domingo, dia 15”

public class VogaisMetodoUnico {

frase = frase.toLowerCase(); //passar tudo para minúsculas para não repetir

for(int i=0; i<frase.length(); i++){

public static int contarVogaisNaFrase(String frase){

for(int i=0; i<frase.length(); i++){

public static int contarVogaisNaFrase(String frase){

for(int i=0; i<frase.length(); i++){

public static int contarVogaisNaFrase(String frase){

public static int contarOcorrenciasDoSimbolo(String frase, char simbolo){

for(int i=0; i<frase.length(); i++){

String frase = ler.nextLine();

public static int contarOcorrenciasDoSimbolo(String frase, char simbolo){

for(int i=0; i<frase.length(); i++){

public class LerIdadeValida {

int idade = lerInteiroNoIntervalo(0,120);

public class LerIdadeValida { Há reutilização do código

public static void main(String[] args) {

Scanner ler = new Scanner(System.in); Abstração da implementação

if(pwd.length() < MIN_TAMANHO) A lógica da validação está num local único

if(numeros < MIN_SIMBOLOS || maiúsculas < MIN_SIMBOLOS || minúsculas < MIN_SIMBOLOS)

if(numeros < MIN_SIMBOLOS || maiúsculas < MIN_SIMBOLOS || minúsculas < MIN_SIMBOLOS)

public class OcorrenciasDoAlgarismo3 {

public static void main(String[] args) {

public static void main(String[] args) {

public static int contar3NoIntervalo(int lim1, int lim2) {

public static int contarAlgarismoNoIntervalo(int algarismo, int lim1, int lim2) {

public static int contarAlgarismoNoIntervalo(int algarismo, int lim1, int lim2) {