UNIVERSIDADE VEIGA DE ALMEIDA

ENGENHARIA DE SOFTWARE

GUSTAVO SENRA TEIXEIRA – 1250115817

JOÃO ADOLFO MARTINS ARAÚJO – 1250108351

JOÃO CARLOS SEQUEIRA CANDEZUNER – 1250115069

JOÃO VITOR SOUZA DA SILVA – 1250113805

JULLIE DA SILVA NUNES – 1250113236

LUIZ HENRIQUE SIMÕES SOARES – 1250107519

GERADOR DE SENHAS AUTOMÁTICO

PARADIGMA DE LINGUAGEM DE PROGRAMAÇÃO

TIJUCA

2025
 Gustavo Senra Teixeira – 1250115817

João Adolfo Martins Araújo – 1250108351

João Carlos Sequeira Candezuner – 1250115069

João Vitor Souza da Silva – 1250113805

Jullie da Silva Nunes – 1250113236

Luiz Henrique Simões Soares – 1250107519

GERADOR DE SENHAS AUTOMÁTICO

Atividade apresentada como requisito

para avaliação da disciplina de
Paradigma de Linguagem de
Programação, no curso de Engenharia de
Software, sob orientação da professor
Claúdio Ribeiro da Silva.

TIJUCA

2025
 LISTA DE FIGURAS

1. FIGURA 1 ..............................................................................................................9

2. FIGURA 2 ..............................................................................................................9

3. FIGURA 3 ............................................................................................................ 9

4. FIGURA 4 ........................................................................................................... 10

5. FIGURA 5 ........................................................................................................... 15

6. FIGURA 6 ........................................................................................................... 15

7. FIGURA 7 ........................................................................................................... 16

8. FIGURA 8 ........................................................................................................... 16

9. FIGURA 9 ........................................................................................................... 21

10. FIGURA 10 ......................................................................................................... 21

11. FIGURA 11 ......................................................................................................... 21

12. FIGURA 12 ......................................................................................................... 22

13. FIGURA 13 ......................................................................................................... 25

14. FIGURA 14 ......................................................................................................... 25

15. FIGURA 15 ......................................................................................................... 25

16. FIGURA 16 ......................................................................................................... 26

 SUMÁRIO

1. INTRODUÇÃO ..............................................................................................5

2. DESENVOLVIMENTO ..................................................................................6

3. CONCLUSÃO .............................................................................................27

4. REFERÊNCIAS BIBLIOGRÁFICAS ...........................................................28

 5

1. INTRODUÇÃO

Neste trabalho, a gente colocou em prática dois jeitos de programar que

a gente aprendeu durante as aulas: a programação estruturada e a orientada a
objetos. Para isso, a gente fez um projeto simples, mas bem útil: um gerador de
senhas. Um projeto simples, porém, muito útil, desenvolvido nas linguagens C,
Python e Java.

A proposta foi criar o mesmo tipo de programa nas três linguagens, mas
aplicando os dois estilos de programação para comparar como cada um
funciona. Em C e Python, usamos a programação estruturada, que segue uma
lógica direta, com o código organizado em funções. Já em Python (de novo) e
Java, usamos a orientação a objetos, onde o código é separado em classes e
objetos, o que ajuda a deixar tudo mais organizado e fácil de reutilizar.

Foi testada cada versão do programa e observamos como cada

linguagem se comporta com os diferentes paradigmas. Isso ajudou a gente a
entender melhor as diferenças entre os dois estilos, e como eles influenciam na
forma de escrever o código, na organização e até na hora de fazer alterações
ou melhorias no futuro.
 6

2. DESENVOLVIMENTO

2.1 CÓDIGOS EM PYTHON ESTRUTURADO:

import random

import string

def gerar_senha(tamanho, usar_maiusculas, usar_numeros,

usar_simbolos):

caracteres = string.ascii_lowercase

if usar_maiusculas:

caracteres +=

string.ascii_uppercase if

usar_numeros:

caracteres +=

[Link] if

usar_simbolos:

caracteres += [Link]

senha = ''.join([Link](caracteres) for _ in range(tamanho))

return
senha

def

ler_resposta_sim_nao(pergunta):

while True:
 7

resposta =

input(pergunta).strip().lower() if

resposta == "sim":

return True elif resposta ==

"nao" or resposta == "nao":

return

False

else:

print("Resposta inválida! Por favor, digite apenas 'sim' ou

'nao'.")

def main():

print("=== GERADOR DE SENHAS ===\n")

tamanho = int(input("Digite o tamanho da senha desejada: "))

usar_maiusculas = ler_resposta_sim_nao("Incluir letras maiúsculas? (sim/nao):

") usar_numeros = ler_resposta_sim_nao("Incluir números? (sim/nao): ")

usar_simbolos = ler_resposta_sim_nao("Incluir símbolos? (sim/nao): ")

senha = gerar_senha(tamanho, usar_maiusculas, usar_numeros,

usar_simbolos)

print("\nSenha gerada:")
print(senha)

print("\n========================")
 8

if __name__ == "__main__":

main()

No código apresentado:

• Função para gerar senha def gerar_senha(tamanho,

usar_maiusculas, usar_numeros, usar_simbolos):

Existe uma função que gera a senha, com parâmetros bem definidos.
A função é modular, ou seja, isolada, e pode ser reutilizada.

• Função para ler "sim" ou "não"

corretamente def

ler_resposta_sim_nao(pergunta): while

True:

A função ler_resposta_sim_nao () demonstra o uso de repetição (while) e

condição
(if)

• Função principal

def main(): if

__name__ ==

"__main__":

main()

Existe um fluxo principal do programa, iniciado pela função main(), como

recomendado na programação estruturada.

A execução segue uma sequência linear: entrada de dados → processamento

→ saída.
 9

TESTES DE SENHA 1 (4):

Figura 1 - Teste de senha Python Estruturado 1

Figura 2 - Teste de senha Python Estruturado 2

Figura 3 - Teste de senha Python Estruturado 3

 10

Figura de Teste 4 - Teste de senha Python Estruturado 4

2.2 CÓDIGOS EM C ESTRUTURADO

#include
<stdio.h>

#include <stdlib.h>

#include
<time.h>

#include <string.h> #include <ctype.h> void gerarSenha(int

tamanho, int usarMaiusculas, int usarNumeros, int

usarSimbolos, char *senha) { char caracteres[200] =

"abcdefghijklmnopqrstuvwxyz";

if (usarMaiusculas) { strcat(caracteres,

"ABCDEFGHIJKLMNOPQRSTUVWXYZ");

if (usarNumeros) {

strcat(caracteres,

"0123456789");

}
 11

if (usarSimbolos) { strcat(caracteres,

"!@#$^&*()-_=+[]{};:,.<>/?");

int len = strlen(caracteres);

for (int i = 0; i < tamanho; i++) {

senha[i] = caracteres[rand() %

len];

senha[tamanho] = '\0'; // fim da string

int lerRespostaSimNao(const char

*mensagem) { char resposta[10];

while (1) { printf("%s", mensagem);

scanf("%9s", resposta); for (int i = 0;

resposta[i]; i++) { resposta[i] =

tolower(resposta[i]);

if (strcmp(resposta, "sim") == 0) {

return
1;

} else if (strcmp(resposta, "nao") == 0 || strcmp(resposta, "não") == 0) {

return 0;

} else { printf("Resposta invalida! Por favor, digite

apenas 'sim' ou 'nao'.\n");

}
 12

int lerTamanhoSenha() { char entrada[50];

int valido = 0; int tamanho = 0; while

(!valido) { printf("Digite o tamanho da

senha desejada: "); scanf("%49s",

entrada); valido = 1; for (int i = 0;

entrada[i] != '\0'; i++) { if

(!isdigit((unsigned char)entrada[i])) {

valido = 0; break;

} if (valido) {

tamanho =

atoi(entrada);

if (tamanho <= 0) { printf("Tamanho invalido!

Digite um numero positivo.\n"); valido = 0;

} } else { printf("Entrada invalida! Por favor,

digite apenas numeros.\n");

return tamanho;

int main() { int tamanho; int usarMaiusculas = 0, usarNumeros = 0,

usarSimbolos = 0; char *senha; srand(time(NULL)); printf("===

 13

GERADOR DE SENHAS (C - Estruturado) ===\n\n"); tamanho =

lerTamanhoSenha(); usarMaiusculas = lerRespostaSimNao("Incluir letras

maiusculas? (sim/nao): "); usarNumeros = lerRespostaSimNao("Incluir

numeros? (sim/nao): "); usarSimbolos = lerRespostaSimNao("Incluir

simbolos? (sim/nao): "); senha = (char *)malloc((tamanho + 1) *

sizeof(char)); if (senha == NULL) { printf("Erro ao alocar memoria.\n"); return

1;

gerarSenha(tamanho, usarMaiusculas, usarNumeros, usarSimbolos,

senha); printf("\nSenha gerada:\n%s\n", senha);

printf("\n===========================================\n");

free(senha);

return 0;

No código apresentado:

• Modularização por Funções

void gerarSenha (...);
int

lerRespostaSimNao

(...); int

lerTamanhoSenha ();
Isso segue o modelo apresentado no PDF da Aula 05, como nos exemplos de
multiplica() e areaquad() em C, que também usam funções para realizar ações
isoladas.
Torna o código mais organizado, legível e reutilizável, como sugerido na aula.
 14

• Controle de Fluxo - Condições

Dentro da função lerRespostaSimNao (), temos: if (strcmp(resposta,

"sim") == 0) {return 1; } else if (strcmp(resposta, "nao") == 0 ||

strcmp(resposta, "não") == 0) {return 0;}

Isso mostra o uso claro de estruturas condicionais, que definem

comportamentos diferentes dependendo da entrada do usuário, um dos pilares
do paradigma estruturado.

• Repetição com While

As funções lerRespostaSimNao() e lerTamanhoSenha() utilizam:

while (1) { ...

} while

(!valido){ ... }
Esses laços garantem que o programa só continue quando o usuário fornecer
dados válidos.
Uso a estrutura de repetição.
• Execução sequencial no main()
int main() {

...

tamanho = tamanho = lerTamanhoSenha();;

usarMaiusculas = lerRespostaSimNao (...);

...

gerarSenha(...);

}
A função main() segue uma sequência lógica de passos, característica essencial
da estrutura sequencial citada na aula: entrada → processamento → saída.
 15

TESTE DE SENHAS 2 (8):

Figura 5 - Teste em C Estruturado:

Figura 6 - Teste em C Estruturado:

 16

Figura 7 - Teste em C Estruturado:

Figura 8 - Teste em C Estruturado:

2.3 CÓDIGOS EM JAVA ORIENTADO AO OBJETO

import [Link];

import [Link];

public class GeradorSenha {

private int tamanho;

 17

private boolean usarMaiusculas;

private boolean usarNumeros;

private boolean usarSimbolos;

public GeradorSenha(int tamanho, boolean usarMaiusculas, boolean

usarNumeros, boolean usarSimbolos) {

[Link] = tamanho;

[Link] = usarMaiusculas;

[Link] = usarNumeros

; [Link] = usarSimbolos;

public String gerar() {

String caracteres =

"abcdefghijklmnopqrstuvwxyz"; if

(usarMaiusculas) {

caracteres += "ABCDEFGHIJKLMNOPQRSTUVWXYZ";

if (usarNumeros) {

caracteres += "0123456789";

if (usarSimbolos) { caracteres

+= "!@#$%^&*()-_=+[]{};:,.<>/?";

StringBuilder senha = new StringBuilder();

Random rand = new Random();

 18

for (int i = 0; i < tamanho; i++) {

int index = [Link]([Link]());

[Link]([Link](index));

return [Link]();

public static boolean lerRespostaSN(Scanner scanner, String

mensagem) { String resposta; while (true) {

[Link](mensagem);

resposta =

[Link]().trim().toLowerCase(); if

([Link]("sim")) { return true;

} else if ([Link]("nao")) {

return false;

} else {

[Link]("Resposta inválida! Por favor, digite apenas 'sim' ou

'nao'.");

public static void main(String[] args) {

Scanner scanner = new Scanner([Link]);

[Link]("=== GERADOR DE SENHAS (Java - OO) ===\n");

[Link]("Digite o tamanho da senha desejada: "); int tamanho =

 19

[Link](); boolean usarMaiusculas = lerRespostaSN(scanner,

"Incluir letras maiúsculas?

(sim/nao): "); boolean usarNumeros = lerRespostaSN(scanner, "Incluir

números? (sim/nao):

");

boolean usarSimbolos = lerRespostaSN(scanner, "Incluir símbolos?

(sim/nao):
");

GeradorSenha gerador = new GeradorSenha(tamanho, usarMaiusculas,

usarNumeros, usarSimbolos);

String senhaGerada = [Link]();

[Link]("\nSenha gerada:");

[Link](senhaGerada);

[Link]("\n=====================================");

[Link]();

No código apresentado:

public class GeradorSenha {

private int tamanho;

private boolean

usarMaiusculas; private

boolean usarNumeros;

private boolean

usarSimbolos;
 20

Existe uma classe chamada GeradorSenha, que modela o conceito de um

"gerador de senhas".
A classe tem atributos privados (tamanho, usarMaiusculas, usarNumeros,
usarSimbolos) que representam o estado do objeto, assim como o exemplo da
aula com a classe Pessoa, que tinha nome, sexo, idade, altura.

public GeradorSenha(int tamanho, boolean usarMaiusculas, boolean

usarNumeros, boolean usarSimbolos) { [Link] = tamanho;

[Link] = usarMaiusculas; [Link] = usarNumeros;

[Link] = usarSimbolos;

O construtor da classe permite criar um objeto (instância) com seus próprios

atributos, assim como no exemplo do pdf da aula 7:
Pessoa p1 = new Pessoa("Ana", "F", 20, 1.65);

public String gerar () { ... }

O método gerar() é um comportamento (método) da classe, que encapsula a
lógica de geração de senha.
Isto corresponde aos métodos da classe Pessoa no exemplo da aula: Feliz(),
Triste(), ExibirPessoa(). Cada método define uma ação que o objeto pode
realizar.
GeradorSenha gerador = new GeradorSenha(tamanho, usarMaiusculas,
usarNumeros, usarSimbolos);
String senhaGerada = [Link]();

O programa cria um objeto da classe GeradorSenha (uma instância), como no

exemplo do pdf da aula 7:
Pessoa p1 = new Pessoa("Ana", "F", 20, 1.65);

Em seguida, chama o método do objeto gerar(), que gera a senha.

• Encapsulamento:
A lógica de geração de senha está encapsulada na classe GeradorSenha. Os
dados (atributos) e comportamentos (métodos) ficam juntos, tornando o código
mais organizado e fácil de manter.
 21

TESTE DE SENHAS 3 (12):

Figura 9 - Teste em Java Orientado ao Objeto:

Figura 10 - Teste em Java Orientado ao Objeto:

Figura 11 - Teste em Java Orientado ao Objeto:

 22

Figura 12 - Teste em Java Orientado ao Objeto:

2.4 CÓDIGOS EM PYTHON ORIENTADO AO OBJETO

import random import string class GeradorSenha: def __init__(self,

tamanho, usar_maiusculas, usar_numeros, usar_simbolos):

[Link] = tamanho

self.usar_maiusculas = usar_maiusculas

self.usar_numeros = usar_numeros

self.usar_simbolos = usar_simbolos def

gerar(self):

caracteres =

string.ascii_lowercase if

self.usar_maiusculas:

caracteres +=

string.ascii_uppercase if

self.usar_numeros:
 23

caracteres +=

[Link] if

self.usar_simbolos:

caracteres += [Link] senha =

''.join([Link](caracteres) for _ in range([Link]))

return senha def ler_resposta_sim_nao(pergunta): while True:

resposta =

input(pergunta).strip().lower() if

resposta == "sim":

return True elif resposta ==

"não" or resposta == "nao":

return False else: print("Resposta inválida!

Por favor, digite apenas 'sim' ou 'não'.") def main():

print("=== GERADOR DE SENHAS (Orientado a Objeto) ===\n")

tamanho = int(input("Digite o tamanho da senha desejada: "))

usar_maiusculas = ler_resposta_sim_nao("Incluir letras maiúsculas? (sim/não): ")

usar_numeros = ler_resposta_sim_nao("Incluir números? (sim/não): ")

usar_simbolos = ler_resposta_sim_nao("Incluir símbolos? (sim/não): ")

gerador = GeradorSenha(tamanho, usar_maiusculas, usar_numeros,

usar_simbolos) senha = [Link]() print("\nSenha gerada:")

print(senha)

print("\n===========================================

=") if __name__ == "__main__":

 24

main()

No código apresentado:
class GeradorSenha: def __init__(self, tamanho, usar_maiusculas,

usar_numeros, usar_simbolos):

[Link] = tamanho

self.usar_maiusculas = usar_maiusculas

self.usar_numeros = usar_numeros

self.usar_simbolos = usar_simbolos

Temos a definição de uma classe, chamada GeradorSenha.

A classe possui atributos (tamanho, usar_maiusculas, usar_numeros,
usar_simbolos) que representam o estado do objeto.
def
gerar(self):

return senha

O comportamento da classe é definido no método gerar().

Como visto na aula (exemplo da classe Pessoa com métodos Feliz(), Triste(),
ExibirPessoa()), o método gerar() encapsula a lógica para criar a senha.

gerador = GeradorSenha(tamanho, usar_maiusculas, usar_numeros,

usar_simbolos) senha = [Link]()

Aqui o programa cria um objeto do tipo GeradorSenha, ou seja, uma instância

da classe.
O objeto é usado para chamar o método gerar() e produzir uma senha.
 25

TESTE DE SENHAS 4 (16):

Figura 13 - Teste em Java Orientado ao Objeto:

Figura 14 - Teste em Java Orientado ao Objeto:

Figura 15 - Teste em Java Orientado ao Objeto:

 26

Figura 16 - Teste em Java Orientado ao Objeto:

 27

3. CONCLUSÃO

Neste trabalho, entendemos na prática como funcionam dois dos

principais jeitos de programar: o paradigma estruturado e o orientado a objetos.
Pra isso, criamos um gerador de senhas em C, Python e Java, e isso foi
essencial pra enxergar como cada linguagem tem seu próprio estilo e jeito de
organizar o código.

Na programação estruturada, que usamos em C e Python, ficou claro que

o foco está em seguir um passo a passo bem definido: entrada de dados,
processamento e depois a saída. Usamos funções para organizar melhor o
código e deixar tudo mais limpo e reutilizável. Esse tipo de lógica funciona muito
bem em programas mais simples ou quando queremos ter mais controle sobre
a ordem das ações.

Por outro lado, quando partimos para a programação orientada a objetos,

principalmente no Java e também no Python, percebemos uma diferença no
jeito de pensar. Em vez de escrever somente funções soltas, a gente cria
"objetos", que são como mini-programas com suas próprias características (os
atributos) e comportamentos (os métodos). Isso deixa o código mais organizado
e fácil de manter, além de parecer mais com o jeito que vemos as coisas no dia
a dia. Por exemplo, no Java e no Python OO, usamos a classe GeradorSenha,
que representava um "ser" capaz de gerar senhas com diferentes
características.

Além disso, os testes realizados em cada linguagem mostraram que os

programas funcionaram corretamente, gerando senhas diferentes conforme as
escolhas do usuário. Também conseguimos ver como cada linguagem lida com
entrada de dados, estrutura de repetição, condições e tratamento de strings.

Por fim, essa atividade foi importante para nos mostrar que cada
paradigma tem suas vantagens e que o mais importante é saber escolher a
abordagem certa para cada tipo de problema. Programar vai muito além de
digitar comandos, é planejar, organizar e pensar logicamente em como resolver
um desafio da melhor forma possível.
 28

5. REFERÊNCIAS BIBLIOGRÁFICAS

[Link]. C library reference. Disponível em: <

[Link] >. Acesso em: 20 jun. 2025.

FERNANDADEV. Poo - Java (Aula 1 - Classes, Objetos, Atributos e Métodos).

YouTube, 2020. 10min14s. Disponível em: <
[Link] >. Acesso em: 17 jun.
2025.

FIGUEREDO, Francisco. EDL - Módulo 02 - Amarração de Nomes (2/5). YouTube,

2020. 29min13s. Disponível em: < [Link] >.
Acesso em: 20 jun. 2025.

HASHTAG, Programação. Como funcionam classes e programação orientada a

objetos em Python - Aprenda em 10 minutos! YouTube, 2022. 11min52s. Disponível
em: < [Link] >. Acesso em: 20 jun. 2025.

ORACLE. Class Random (Java Platform SE 8). Disponível em: <

[Link] >. Acesso em: 22 jun.
2025.

ORACLE. Class StringBuilder (Java Platform SE 8). Disponível em: <

[Link] >. Acesso em:
22 jun. 2025.

PYTHON SOFTWARE FOUNDATION. random — Geração de números

pseudoaleatórios. Disponível em: < [Link]
br/3/library/[Link] >. Acesso em: 20 jun. 2025.

PYTHON SOFTWARE FOUNDATION. string — Operações comuns com texto.

Disponível em: < [Link] >. Acesso em: 20
jun. 2025.

W3SCHOOLS. Java OOP (Object-Oriented Programming). Disponível em: <

[Link] >. Acesso em: 22 jun. 2025.
 29

W3SCHOOLS. Python Classes and Objects. Disponível em: <

[Link] >. Acesso em: 20 jun. 2025.

YES+. Aula 04 – Construindo um Programa em C. YouTube, 2020. 12min53s.

Disponível em: < [Link] >. Acesso em:
20 jun. 2025.

Materiais de aulas:

Aula05 - [Link] Aula07 - [Link]