APS UNIP JAVA

Prévia do material em texto

UNIVERSIDADE PAULISTA
BRUNA GABRIELA BISPO DE ARAUJO G968HD6
GABRIEL AMORIM DOS SANTOS G56DJI5
GIOVANA DIAS CAVALCANTI G2761I7
JOÃO VITOR FELTRIN G74ICE1
LÍVIA DE SOUZA BARBOSA RA 190080
DESENVOLVIMENTO DE SISTEMAS PARA MANIPULAÇÃO DE SISTEMA DE UNIVERSIDADE
CAMPINAS
2025
Sumário
1.	Objetivo do trabalho	3
2.	Introdução	3
3.	Referencial Teórico	4
4.	Desenvolvimento	7
5.	Resultado e Discussão	18
6.	Considerações Finais	26
7.	Referência Bibliográfica	27
8.	Código fonte	27
9.	Ficha de Atividade Prática Supervisionada	47
1. Objetivo do trabalho 
O presente trabalho tem como objetivo fazer com que os alunos da graduação de ciência da computação desenvolvam um sistema computacional para gerenciamento da universidade “Amazonia”, instituição fictícia voltada à produção de conhecimento nas áreas de ciência e meio ambiente. O sistema será desenvolvido com a linguagem Java e com o uso de arquivo CSV como banco de dados e interface. 
Além de funcionalidades como o gerenciamento de dados de alunos, cursos e notas, o sistema deve ser capaz de lidar com arquivos específicos para cada curso e implementar controle de erros para garantir uma interação mais robusta com o usuário final. 
Outro objetivo fundamental é que este projeto estimula a interação em grupo, promovendo a colaboração, estimulando discussões e organização de todos os integrantes do grupo. A atividade permite que os alunos coloquem em prática os conceitos aprendidos nas aulas das disciplinas de Linguagem de Programação Orientada a Objetos e Banco de Dados, fortalecendo a aprendizagem por meio da atividade prática. 
2. Introdução 
A utilização da programação orientada a objetos (POO) nesse projeto foi muito importante pois, ela ajuda a deixar o código mais organizado e fácil de entender. A ideia da POO é dividir o sistema em partes menores, chamadas classes, e cada uma tem uma responsabilidade bem definida. Isso facilita a leitura do código e, se no futuro precisar fazer alguma mudança, fica mais fácil fazer isso sem danificar o restante. 
Além disso, a POO possibilita reaproveitar o código, quando é criada uma classe que resolve um problema pode-se reutilizar ela em outras partes do código sem precisar escrever novamente, isso economiza tempo, diminui a chance de erro e deixa o código mais limpo e fácil de manter. Um código organizado é fundamental para testar as funcionalidades, já que está separado facilitando então encontrar problemas caso haja.
Para o armazenamento e manipulação dos dados neste projeto, optou-se pela utilização de arquivos no formato CSV (Comma-Separated Values). Esse formato se destaca por sua simplicidade e eficiência na organização de grandes volumes de informações. Arquivos CSV estruturam os dados em formato tabular, separando os valores por vírgulas, o que facilita tanto a leitura quanto o processamento automatizado. Além disso, sua ampla compatibilidade com softwares como Microsoft Excel e editores de texto, como o Bloco de Notas, permite uma visualização rápida e acessível. Diante dessas vantagens, o uso de arquivos CSV mostrou-se uma solução prática e adequada às necessidades do projeto.
A escolha da linguagem Java representou uma decisão estratégica neste projeto, considerando sua robustez, ampla adoção tanto no mercado quanto no meio acadêmico, e seu sólido suporte ao trabalho com arquivos CSV. A linguagem oferece diversas bibliotecas e recursos que facilitam o processamento de dados, tornando a integração com arquivos externos mais eficiente e intuitiva.
Outro aspecto relevante do Java é sua base consistente para a aplicação dos princípios da programação orientada a objetos, como encapsulamento, herança e polimorfismo. Esses conceitos contribuem diretamente para a modularidade, reutilização e flexibilidade do código. O encapsulamento permite proteger os dados, expondo apenas o necessário para o funcionamento do sistema. A herança possibilita a extensão de funcionalidades sem duplicação de código, promovendo maior organização. Já o polimorfismo torna o sistema mais dinâmico, permitindo que métodos se comportem de maneira distinta conforme o contexto da classe que os implementa.
3. Referencial Teórico
O seguinte trabalho é feito da perspectiva de estudo na criação de um sistema acadêmico. O Sistema é escrito em linguagem de programação JAVA, e utiliza arquivos no formato CSV para processar e armazenar dados. O objetivo do trabalho é que o Sistema acadêmico montado consiga gerenciar informações de alunos, cursos, notas e usuários de forma eficiente. O presente testo busca descrever a arquitetura do sistema, os algoritmos utilizados, as classes, e a maneira como os dados são acessados, manipulados e apresentados ao usuário
Arquitetura do sistema: 
O sistema é composto por diversas classes com responsabilidades bem definidas: 
SistemaAcadêmico: Classe principal que organiza o funcionamento do sistema, apresentando menu de login, alteração de senha e acesso ao menu principal.
Aluno: há o encapsulamento dos dados de alunos, adicionando atributos como (ID, nome, notas) e métodos para o cálculo de média semestral dos alunos
ConsultaAluno: É introduzido ao sistema como uma forma de auxiliar a busca por alunos, através de dados cadastrados no sistema como (ID, exibição de notas, cursos e informações científicas. 
ListarAlunosPorCurso: Uma ferramenta para auxiliar na busca por alunos que estão matriculados em determinado curso. Listando todos os alunos que estão cadastrados nele. 
MatricularAluno: Realiza matrícula de alunos em cursos existentes dentro da faculdade e tem possibilidade de introduzir as notas dos alunos 
CriarCurso: tem como objetivo a criação de cursos dentro do sistema, e tem o poder de cadastrar os alunos interessados em estudá-los.
CadastroUtils: Tem como função a criação de ID único para cada, evitando que tenha duplicatas 
Processamento de Dados: Classes e algoritmos
Classe SistemaAcademico: É responsável pelo controle do menu principal, autenticação de usuário e chamada das funcionalidades. Faz uso de estruturas de repetição e condição para que se navegue pelas opções de menu no sistema. 
Algorirmos importantes:
· Leitura de Login.csv; 
· Acesso a lista completa de usuarios (carregarUsuarios());
· Autenticação de login e senha com conferência de strings.
Classe ConsultaAluno: Esta classe localiza e apresenta informações de um aluno com base em seu ID. 
· Para se obter o nome do aluno, utiliza-se da leitura do arquivo alunos.csv
· Arquivos de curso (*.csv) (busca em todos os arquivos de extensão .csv que representam cursos) para localização por notas
· Ic_art_ciet.csv para localizar via iniciação cientifica ou produção de artigos pelo aluno. 
Classe ListarAlunosPorCurso: Realiza a listagem de alunos de um curso específico, para isso carrega os recursos de Alunos.csv em um hashMap (estrutura em Java que permite armazenar pares de chave e valor – no caso do sistema acadêmico é ID do aluno (chave) ao seu nome (valor). O hashMap busca os IDs contidos no arquivo do curso e imprime os nomes. 
Classe MatricularAluno: permite colocar os alunos em cursos que já existem. No caso de alunos novos, é gerado um ID exclusivo pelo CadastroUtils. Também permite a entrada de notas, armazenando tudo no arquivo (nomeCurso.csv).
Processo de inserção:
1. Verifica se o aluno existe em Alunos.csv
2. Se é novo, salva os dados
3. Pergunta se deseja inserir as notas
4. Escreve os dados no arquivo do curso
Classe CriarCurso: Cria um curso acadêmico e permite cadastro de alunos e inserção de notas.
· Adiciona o curso ao cursos.csv
· Cria um arquivo nomeCruso.csv
· Para cada aluno: gera uma ID, salva em Alunos.csv e permite a entrada de notas
Clasee aluno: Modela as propriedades do aluno. Os principais algoritmos desta classe estão relacionados ao cálculo da média, e define a situação do aluno como “aprovado” ou “reprovado” com base no resultado da nota final. 
Classe CadastroUtils: Gera IDs únicos para novos alunos. Usa um conjunto (HashSet – que é uma estrutura de dados em Java que representa umconjunto, ou seja, uma coleção que não permite elementos duplicados-) com os IDs existentes para evitar a repetição.
Acesso aos Dados:
Todos os dados do sistema são armazenados em arquivos .csv, as operações de leitura e escrita são feitas via classes de I/O (bufferedReader e bufferedwriter). 
Os principais manipuladores dos arquivos são:Login.csv: Dados de usuário e senha; Alunos.csv: IDs e nomes dos alunos; Curso.csv: Lista de cursos; NomeCurso.csv: Notas dos alunos em cada curso; Ic_art_ciet.csv: Iniciação e artigos científicos
Visualização dos Dados: 
A visualização ocorre diretamente no terminal. O sistema imprime:Mensagens informativas; Lista de alunos e cursos; Notas, médias e situações dos alunos; Quantidade de artigos e iniciações.
A interface é simples e apenas textual, usando o System.out.printn() para exibir resultados. 
4. Desenvolvimento 
Inicia-se o código com a importação de bibliotecas padrões do Java, com a intensão de auxiliar na entrada e saída de dados, manipulação de arquivos e coleta de entrada do usuário:
A seguir, continua a escrita do código onde é introduzido a classe SistemaAcademico:
Cria-se uma estrutura de looping para prosseguir com o login, alterar senha ou até que o usuário escolha sair: 
Criação do método CarregarUsuarios, que tem por finalidade carregar usuários a partir do arquivo Login.csv 
A seguir a criação do código para que sejam os usuários sejam salvos:
Criação do método para realização do login, e verificação se está correto:
Em caso de erro de senha ou usuário:
É possível alterar a senha: 
Criação do método menuPrincipal, e as opções que aparece após o login do usuário:
Importação de bibliotecas importantes para o desenvolvimento do código:
Criação da classe ConsultaAluno, com a criação do método principal, consultarAlunoporId, que tem por função encontrar as informações principais do aluno cadastrado no sistema. 
O Método ehArquivoDeCurso, tem a função de filtrar os arquivos, descartando dados que não são interessantes para a consulta.
Os métodos seguintes têm suas funcionalidades na busca por informações do aluno: Seu nome, ID, o curso que está cursando, suas notas, se está reprovado ou não, se já escreveu algum artigo científico ou se está em uma iniciação cientifica. Importante salientar que os métodos de consulta usam mecanismos de tratamento de erro para que o programa não seja interrompido nos casos de erro. 
Importações necessárias:
 
Criação da classe ListarAlunosPorCurso e o método principal que lista cursos e permite ver os alunos de um curso:
O restante do código chama métodos que permite ao usuário do sistema consultar se há alunos em um curso específico.
Importação das bibliotecas necessárias
Criação da classe MatricularAluno, essa classe conta com dois atributos estáticos alinos_csv e cursos_csv, e tem como método principal o matricularAluno(), que mostra os cursos disponíveis e permite a escolha de um curso. O método também pergunta se o aluno já possui cadastro, em negativa, gera um novo ID e o cadastra.
O método ainda conta com a implementação das notas de np1, np2, reposição e exame, e salva todos os arquivos no curso correspondente. Os métodos seguintes:
Método listarCursos(): Lê o arquivo cursos.csv retorna uma lista com os nomes dos cursos disponíveis, auxilia o usuário no processo de matrícula. 
Método AlunoExiste(int id): Verifica no arquivo Alunos.csv se já existe um aluno com o ID informado retorna true se encontrar, false caso não. 
Método obterNomeAluno(int id): Se o ID do aluno for conhecido, retorna o nome correspondente no arquivo Alunos.csv. 
Método solicitarNota(Scanner, String): Pergunta ao usuário uma nota (número), se receber algo digitado que não supre a condição até receber uma condição válida (número).
Importações necessárias: 
Criação da classe CriarCurso, como na classe passada aqui contamos com mais dois atributos estáticos: CURSOS_CSV (são salvos os dados de cursos) e ALUNOS_CSV (são registrados os alunos). O método principal dessa classe é o criar (), o método solicita o nome do curso, o nível e o ano de início. Dado as informações elas são salvas em cursos.csv, e cria um arquivo .csv com o nome do curso, e quantos alunos serão cadastrados, gerando um ID único para cada aluno, seu nome, podendo colocar notas, e por fim salva os dados no Alunos.csv.
Importação necessárias 
Criação da classe cadastroUtils: composta por um atributo estático ALUNOS_CSV, onde ficam registrados todos os alunos do sistema, com seus atributos (ID e nome). O método principal da classe é o gerarIdUnico(), que cria um número aleatório de 4 dígitos, e chama o método carregarIdsExistentes() para que nenhum número atribuído seja igual ao outro.
5. Resultado e Discussão 
Nesta seção, serão apresentados os principais resultados e testes do projeto desenvolvido. 
Login e senha: Neste teste o usuário seleciona a opção 1 “login”, digita login e senha para entrar no sistema, se o login e senha estiver corretos ele vai imprimir na tela “Login realizado com sucesso” e vai apresentar o menu principal. Se o login estiver errado vai imprimir na tela “Login ou senha incorretos” e não entrará no sistema.
5.1 Alterar senha: Ao selecionar a opção 2 “Alterar senha” é solicitado login e senha atual, caso esteja errado o programa não irá alterar. Se estiver correto vai ser solicitado o novo login e senha e assim o login vai ser alterado. 
5.2 Tratativa de erro no menu principal: Caso o usuário selecione uma opção no menu principal que não existe é impresso na tela “Opção inválida”.
Consultar aluno por ID: Ao selecionar a opção 1 “Consultar aluno por ID” no menu principal, é solicitado para o usuário o ID do aluno, se o ID estiver correto é apresentado o nome, curso, notas (N1, N2), reposição, exame, media final, situação (Aprovado ou Reprovado), iniciações científicas e artigos científicos do aluno. Caso o ID estiver errado imprime na tela “Aluno não encontrado”. 
 
5.3 Listar alunos por cursos: Ao selecionar a opção 2 “Listar alunos por curso” é mostrado para o usuário todos os cursos que existem e pede para selecionar qual curso quer consultar, após escolher o curso mostra o ID e nome dos alunos matriculado neste curso. Caso o usuário escolha um curso que não está na lista vai ser impresso na tela “curso inválido”. 
5.4 Matricular aluno em um curso existente: Ao selecionar a opção 3 “Matricular aluno em curso existente” o sistema vai mostrar uma lista de cursos disponíveis, o usuário escolhe o curso que deseja matricular o aluno, o sistema vai perguntar “o aluno já está cadastrado?” se não digite “n”, o sistema automaticamente vai criar um ID para este aluno, o usuário vai digitar o nome do aluno. O sistema vai perguntar se deseja inserir notas, se não selecionar a opção “n” e assim vai ser impresso na tela “Aluno matriculado com sucesso no curso (nome do curso que escolheu)”. Se o aluno já foi cadastrado no curso selecione a opção “s”, vai ser solicitado o ID do aluno, se deseja inserir notas selecione a opção “s” e assim inserir a nota 1, nota 2, reposição e exame e assim vai ser impresso na tela “Aluno matriculado com sucesso (nome do curso que escolheu)”.
Se o aluno já foi cadastrado no curso e o usuário digitou o ID errado vai ser impresso na tela “Aluno não encontrado no sistema’ 
5.5 Criar novo curso com novos alunos: Ao selecionar a opção 4 “Criar novo curso com novos alunos” o sistema vai solicitar o nome do curso, nível (Ex: Graduação, Pós), ano de início, quantos alunos deseja cadastrar. Para cadastrar aluno o sistema gera um ID, é solicitado o nome do aluno e se deseja inserir notas, se não selecionar a opção “n” e ele solicita para cadastrar outro aluno ou cadastra o curso e aluno. Se sim selecionar opção “s” e inserir nota 1, nota 2, reposição e exame. Após esse procedimento vai ser impresso na tela “Curso e alunos cadastrados com sucesso”.
5.6 Sair: Ao selecionar a opção 0 “Sair” o sistema irá sair do menu principal e encerra o sistema.6. Considerações Finais 
O desenvolvimento do sistema para a universidade fictícia “Amazonia” representou um grande desafio, tanto no aspecto técnico quanto na organização do grupo. A escolha das tecnologias — linguagem Java e arquivos CSV — foi determinada pela proposta do trabalho, o que direcionou os esforços da equipe para o aprofundamento nessas ferramentas. Apesar das limitações impostas, foi possível explorar bem os conceitos de Programação Orientada a Objetos e aplicar técnicas de manipulação de dados de forma prática e eficiente.
Durante o processo de codificação, enfrentamos diversos erros que exigiram atenção e persistência para serem resolvidos. A etapa mais desafiadora foi a implementação do sistema de login, que exigiu uma lógica mais refinada e um controle mais rigoroso dos dados. Para superar essas dificuldades, foi necessário realizar pesquisas, revisar conceitos e estudar exemplos de código. Os testes no terminal foram fundamentais para identificar falhas e garantir o funcionamento do sistema, permitindo ajustes contínuos até que todos os requisitos fossem atendidos.
Em relação ao trabalho em grupo, houve uma divisão entre os membros responsáveis pelo desenvolvimento do sistema e os que cuidaram da parte escrita. Apesar de dificuldades iniciais na comunicação, todos participaram de alguma forma e contribuíram para a finalização do projeto. Isso proporcionou aprendizado para todos os envolvidos, tanto em termos técnicos quanto na experiência de lidar com um projeto colaborativo.
Como resultado final, o sistema atendeu a todos os tópicos exigidos pela proposta, incluindo funcionalidades como cadastro de alunos, criação de cursos, matrícula e controle de arquivos separados por curso. Em resumo, o trabalho cumpriu seu papel de integrar os conhecimentos das disciplinas envolvidas e proporcionou uma vivência prática importante, tanto no desenvolvimento de software quanto no trabalho em equipe.
7. Referência Bibliográfica 
Ricarte, I. L. M. Programação orientada a objetos: uma abordagem com Java. Campinas: Universidade Estadual de Campinas, 2001. Disponível em: https://www.dca.fee.unicamp.br/cursos/PooJava/Aulas/poojava.pdf. Acesso em: 10 abril 2025.
Do Back ao Front - Programação FullStack. Polimorfismo JAVA: POO JAVA na Prática. Polimorfismo POO. 2024. [Vídeo]. Disponível em: https://youtu.be/glvlW-L-HeE. Acesso em: 12 abril 2025.
Sharpax. O que é POLIMORFISMO na programação?. 2022. [Vídeo]. Disponível em: https://www.youtube.com/watch?v=r5phkHHHsA0. Acesso em: 12 abril 2025.
DevSuperior. Como ler arquivo texto CSV em Java (aplicação real) - Aulão #002. 2020. [Vídeo]. Disponível em: https://youtu.be/xLDViuYlqGM. Acesso em: 15 abril 2025.
Junior, Jose. Como tratar exceções na linguagem Java. DEVMEDIA, 2019. Disponível em: https://www.devmedia.com.br/como-tratar-excecoes-na-linguagem-java/39163. Acesso em: 15 de abril de 2025.
Academia dos Devs. Como usar TRY CATCH no Java (tratamento de exceções) - Curso Java POO Aula #19. 2023. [Vídeo]. Disponível em: https://youtu.be/BG4kOOfbOjc. Acesso em: 15 abril 2025.
BAELDUNG. Java FileReader vs BufferedReader. 2021. Disponível em: https://www.baeldung.com/java-filereader-vs-bufferedreader. Acesso em: 15 abril 2025.
8. Código fonte 
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class SistemaAcademico {
private static final String ARQUIVO_LOGIN = "data/Login.csv";
private static final Scanner scanner = new Scanner(System.in);
private static final List usuarios = new ArrayList();
public static void main(String[] args) {
carregarUsuarios();
while (true) {
System.out.println("\n==== Sistema Acadêmico ====");
System.out.println("1. Login");
System.out.println("2. Alterar Senha");
System.out.println("0. Sair");
System.out.print("Escolha uma opção: ");
String opcao = scanner.nextLine();
switch (opcao) {
case "1":
if (fazerLogin()) {
menuPrincipal();
}
break;
case "2":
alterarSenha();
break;
case "0":
System.out.println("Encerrando o sistema.");
return;
default:
System.out.println("Opção inválida. Tente novamente.");
}
}
}
private static void carregarUsuarios() {
usuarios.clear();
try (BufferedReader br = new BufferedReader(new FileReader(ARQUIVO_LOGIN))) {
String linha;
while ((linha = br.readLine()) != null) {
String[] dados = linha.split(",");
if (dados.length == 2) {
usuarios.add(new Usuario(dados[0], dados[1]));
}
}
} catch (IOException e) {
System.out.println("Erro ao carregar dados de login: " + e.getMessage());
}
}
private static void salvarUsuarios() {
try (BufferedWriter bw = new BufferedWriter(new FileWriter(ARQUIVO_LOGIN))) {
for (Usuario usuario : usuarios) {
bw.write(usuario.getLogin() + "," + usuario.getSenha());
bw.newLine();
}
} catch (IOException e) {
System.out.println("Erro ao salvar dados de login: " + e.getMessage());
}
}
private static boolean fazerLogin() {
System.out.print("Login: ");
String login = scanner.nextLine().trim();
System.out.print("Senha: ");
String senha = scanner.nextLine().trim();
for (Usuario usuario : usuarios) {
if (usuario.getLogin().equals(login) && usuario.getSenha().equals(senha)) {
System.out.println("Login realizado com sucesso.");
return true;
}
}
System.out.println("Login ou senha incorretos.");
return false;
}
private static void alterarSenha() {
System.out.print("Login: ");
String login = scanner.nextLine().trim();
System.out.print("Senha atual: ");
String senhaAtual = scanner.nextLine().trim();
for (Usuario usuario : usuarios) {
if (usuario.getLogin().equals(login) && usuario.getSenha().equals(senhaAtual)) {
System.out.print("Nova senha: ");
String novaSenha = scanner.nextLine().trim();
if (novaSenha.length() >= 4) {
usuario.setSenha(novaSenha);
salvarUsuarios();
System.out.println("Senha alterada com sucesso.");
} else {
System.out.println("Senha muito curta. Mínimo de 4 caracteres.");
}
return;
}
}
System.out.println("Login ou senha atual incorretos.");
}
private static void menuPrincipal() {
while (true) {
System.out.println("\n=== Menu Principal ===");
System.out.println("1. Consultar aluno por ID");
System.out.println("2. Listar alunos por curso");
System.out.println("3. Matricular aluno em curso existente");
System.out.println("4. Criar novo curso com novos alunos");
System.out.println("0. Sair");
System.out.print("Escolha: ");
String opcao = scanner.nextLine();
switch (opcao) {
case "1":
System.out.print("Digite o ID do aluno: ");
try {
int id = Integer.parseInt(scanner.nextLine());
ConsultaAluno.consultarAlunoPorId(id);
} catch (NumberFormatException e) {
System.out.println("ID inválido. Deve ser numérico.");
}
break;
case "2":
ListarAlunosPorCurso.listar();
break;
case "3":
MatricularAluno.matricularAluno();
break;
case "4":
CriarCurso.criar();
break;
case "0":
return;
default:
System.out.println("Opção inválida.");
}
}
}
}
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class SistemaAcademico {
private static final String ARQUIVO_LOGIN = "data/Login.csv";
private static final Scanner scanner = new Scanner(System.in);
private static final List usuarios = new ArrayList();
public static void main(String[] args) {
carregarUsuarios();
while (true) {
System.out.println("\n==== Sistema Acadêmico ====");
System.out.println("1. Login");
System.out.println("2. Alterar Senha");
System.out.println("0. Sair");
System.out.print("Escolha uma opção: ");
String opcao = scanner.nextLine();
switch (opcao) {
case "1":
if (fazerLogin()) {
menuPrincipal();
}
break;
case "2":
alterarSenha();
break;
case "0":
System.out.println("Encerrando o sistema.");
return;
default:
System.out.println("Opção inválida. Tente novamente.");
}
}
}
private static void carregarUsuarios() {
usuarios.clear();
try (BufferedReader br= new BufferedReader(new FileReader(ARQUIVO_LOGIN))) {
String linha;
while ((linha = br.readLine()) != null) {
String[] dados = linha.split(",");
if (dados.length == 2) {
usuarios.add(new Usuario(dados[0], dados[1]));
}
}
} catch (IOException e) {
System.out.println("Erro ao carregar dados de login: " + e.getMessage());
}
}
private static void salvarUsuarios() {
try (BufferedWriter bw = new BufferedWriter(new FileWriter(ARQUIVO_LOGIN))) {
for (Usuario usuario : usuarios) {
bw.write(usuario.getLogin() + "," + usuario.getSenha());
bw.newLine();
}
} catch (IOException e) {
System.out.println("Erro ao salvar dados de login: " + e.getMessage());
}
}
private static boolean fazerLogin() {
System.out.print("Login: ");
String login = scanner.nextLine().trim();
System.out.print("Senha: ");
String senha = scanner.nextLine().trim();
for (Usuario usuario : usuarios) {
if (usuario.getLogin().equals(login) && usuario.getSenha().equals(senha)) {
System.out.println("Login realizado com sucesso.");
return true;
}
}
System.out.println("Login ou senha incorretos.");
return false;
}
private static void alterarSenha() {
System.out.print("Login: ");
String login = scanner.nextLine().trim();
System.out.print("Senha atual: ");
String senhaAtual = scanner.nextLine().trim();
for (Usuario usuario : usuarios) {
if (usuario.getLogin().equals(login) && usuario.getSenha().equals(senhaAtual)) {
System.out.print("Nova senha: ");
String novaSenha = scanner.nextLine().trim();
if (novaSenha.length() >= 4) {
usuario.setSenha(novaSenha);
salvarUsuarios();
System.out.println("Senha alterada com sucesso.");
} else {
System.out.println("Senha muito curta. Mínimo de 4 caracteres.");
}
return;
}
}
System.out.println("Login ou senha atual incorretos.");
}
private static void menuPrincipal() {
while (true) {
System.out.println("\n=== Menu Principal ===");
System.out.println("1. Consultar aluno por ID");
System.out.println("2. Listar alunos por curso");
System.out.println("3. Matricular aluno em curso existente");
System.out.println("4. Criar novo curso com novos alunos");
System.out.println("0. Sair");
System.out.print("Escolha: ");
String opcao = scanner.nextLine();
switch (opcao) {
case "1":
System.out.print("Digite o ID do aluno: ");
try {
int id = Integer.parseInt(scanner.nextLine());
ConsultaAluno.consultarAlunoPorId(id);
} catch (NumberFormatException e) {
System.out.println("ID inválido. Deve ser numérico.");
}
break;
case "2":
ListarAlunosPorCurso.listar();
break;
case "3":
MatricularAluno.matricularAluno();
break;
case "4":
CriarCurso.criar();
break;
case "0":
return;
default:
System.out.println("Opção inválida.");
}
}
}
}
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
public class ConsultaAluno {
//
public static void consultarAlunoPorId(int idBusca) {
String nomeAluno = buscarNomeAluno(idBusca); // buscarnomealuno é um metodo
if (nomeAluno == null) {
System.out.println("Aluno não encontrado.");
return;
}
System.out.println("Nome do Aluno: " + nomeAluno);
boolean encontrouCurso = false;
File pasta = new File("data");
File[] arquivos = pasta.listFiles(); 
if (arquivos != null) {
for (File arquivo : arquivos) { // : é um operador de referencia de metodo 
String nomeArquivo = arquivo.getName();
if (arquivo.isFile() && nomeArquivo.endsWith(".csv") && ehArquivoDeCurso(nomeArquivo)) {
if (verificarAlunoNoCurso(arquivo, idBusca)) {
encontrouCurso = true;
}
}
}
}
if (!encontrouCurso) {
System.out.println("Aluno não está matriculado em nenhum curso.");
}
buscarInformacoesCientificas(idBusca); //metodo 
}
private static boolean ehArquivoDeCurso(String nome) {
return !nome.equalsIgnoreCase("Alunos.csv") &&
!nome.equalsIgnoreCase("Login.csv") &&
!nome.equalsIgnoreCase("Cursos.csv") &&
!nome.equalsIgnoreCase("ic_art_ciet.csv");
}
private static String buscarNomeAluno(int idBusca) {
try (BufferedReader br = new BufferedReader(new FileReader("data/Alunos.csv"))) {
String linha;
while ((linha = br.readLine()) != null) {
String[] partes = linha.split(","); // separa as colunas do arquivo por virgula e confirma se tem a quantidade necessaria de informaçoes
if (partes.length >= 2) {
int id = Integer.parseInt(partes[0]);
if (id == idBusca) {
return partes[1];
}
}
}
} catch (IOException e) {
System.out.println("Erro ao ler Alunos.csv: " + e.getMessage());
}
return null;
}
private static boolean verificarAlunoNoCurso(File arquivoCurso, int idBusca) {
try (BufferedReader br = new BufferedReader(new FileReader(arquivoCurso))) {
String linha;
while ((linha = br.readLine()) != null) {
String[] partes = linha.split(",");
if (partes.length >= 1) {
int id = Integer.parseInt(partes[0].trim());
if (id == idBusca) {
double n1 = (partes.length > 1 && !partes[1].trim().isEmpty()) ? Double.parseDouble(partes[1].trim()) : 0.0;
double n2 = (partes.length > 2 && !partes[2].trim().isEmpty()) ? Double.parseDouble(partes[2].trim()) : 0.0;
double reposicao = (partes.length > 3 && !partes[3].trim().isEmpty()) ? Double.parseDouble(partes[3].trim()) : 0.0;
double exame = (partes.length > 4 && !partes[4].trim().isEmpty()) ? Double.parseDouble(partes[4].trim()) : 0.0;
double notaFinal = Math.max(n1, reposicao) + n2;
String status = (notaFinal >= 7 || (notaFinal + exame) / 2 >= 5) ? "Aprovado" : "Reprovado";
System.out.println("Curso: " + arquivoCurso.getName().replace(".csv", ""));
System.out.printf("Notas: N1=%.1f, N2=%.1f, Reposição=%.1f, Exame=%.1f%n", n1, n2, reposicao, exame);
System.out.printf("Média final: %.2f - Situação: %s%n", (notaFinal + exame) / 2, status);
return true;
}
}
}
} catch (IOException e) {
System.out.println("Erro ao ler curso: " + arquivoCurso.getName());
} catch (NumberFormatException e) { //tratativa de erro ao conversor de string para numero
System.out.println("Erro ao converter número no curso: " + arquivoCurso.getName());
}
return false;
}
private static void buscarInformacoesCientificas(int idBusca) {
try (BufferedReader br = new BufferedReader(new FileReader("data/ic_art_ciet.csv"))) {
String linha;
while ((linha = br.readLine()) != null) {
String[] partes = linha.split(",");
if (partes.length >= 3) {
int id = Integer.parseInt(partes[0]);
if (id == idBusca) {
System.out.println("Iniciações Científicas: " + partes[1]);
System.out.println("Artigos Científicos: " + partes[2]);
return;
}
}
}
} catch (IOException e) {
System.out.println("Erro ao ler ic_art_ciet.csv: " + e.getMessage());
}
}
}
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Scanner;
public class ListarAlunosPorCurso {
public static void listar() {
File pasta = new File("data/");
List arquivosCurso = new ArrayList();
System.out.println("\n=== Cursos Disponíveis ===");
int index = 1;
for (File arq : Objects.requireNonNull(pasta.listFiles())) {
String nome = arq.getName();
if (nome.endsWith(".csv") &&
!nome.equals("Alunos.csv") &&
!nome.equals("Login.csv") &&
!nome.equals("cursos.csv")&&
!nome.equals("ic_art_ciet.csv")) { // ignorar estes arquivos
System.out.println(index + ". " + nome.replace(".csv", ""));
arquivosCurso.add(nome);
index++;
}
}
if (arquivosCurso.isEmpty()) {
System.out.println("Nenhum curso encontrado.");
return;
}
Scanner scanner = new Scanner(System.in);
System.out.print("Escolha o número do curso: ");
int escolha;
try {
escolha = Integer.parseInt(scanner.nextLine());
} catch (NumberFormatException e) {
System.out.println("Entrada inválida.");
return;
}
if (escolha arquivosCurso.size()) {
System.out.println("Curso inválido.");
return;
}
String arquivoSelecionado = arquivosCurso.get(escolha - 1);
listarAlunosDoCurso(arquivoSelecionado);
}
private static void listarAlunosDoCurso(String nomeArquivoCurso) {
System.out.println("\n--- Alunos matriculados em: " + nomeArquivoCurso.replace(".csv", "") + " ---");
Map mapaAlunos = carregarAlunos();// coloca em lista
try (BufferedReader br = new BufferedReader(new FileReader("data/" + nomeArquivoCurso))) {
String linha;
while ((linha = br.readLine()) != null) {
String[] dados = linha.split(",");
int id = Integer.parseInt(dados[0]);
String nome = mapaAlunos.getOrDefault(id, "Nome não encontrado"); // se o valor informado estiver associado a id este será retornado, senão sera retronardo o valor de default "nome nao encontrado"
System.out.println("ID: " + id + " | Nome: " + nome);
}
} catch (IOException e) {
System.out.println("Erro ao ler o arquivo do curso.");
}
}
private static Map carregarAlunos() {
Map mapa = new HashMap();
try (BufferedReader br = new BufferedReader(new FileReader("data/Alunos.csv"))) {
String linha;
while ((linha = br.readLine()) != null) {
String[] dados = linha.split(",");
if (dados.length >= 2) {
int id = Integer.parseInt(dados[0]);
String nome = dados[1];
mapa.put(id, nome);
}
}
} catch (IOException e) {
System.out.println("Erro ao carregar Alunos.csv");
}
return mapa;
}
}
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class MatricularAluno {
private static final String ALUNOS_CSV = "data/Alunos.csv";
private static final String CURSOS_CSV = "data/cursos.csv";
public static void matricularAluno() {
Scanner scanner = new Scanner(System.in);
System.out.println("\n=== Matricular Aluno em Curso Existente ===");
// Mostrar lista de cursos disponíveis
List cursosDisponiveis = listarCursos();
if (cursosDisponiveis.isEmpty()) {
System.out.println("Nenhum curso encontrado.");
return;
}
System.out.println("Cursos disponíveis:");
for (int i = 0; i cursosDisponiveis.size()) throw new Exception(); //mostra uma mensagem de erro
} catch (Exception e) {
System.out.println("Opção inválida.");
return;
}
String nomeCurso = cursosDisponiveis.get(escolhaCurso - 1);
String arquivoCurso = nomeCurso + ".csv";
// Perguntar se aluno já existe
System.out.print("O aluno já está cadastrado? (s/n): ");
String resp = scanner.nextLine().trim().toLowerCase();
int idAluno;
String nomeAluno;
if (resp.equals("s")) {
System.out.print("Digite o ID do aluno: ");
try {
idAluno = Integer.parseInt(scanner.nextLine());
} catch (NumberFormatException e) {
System.out.println("ID inválido.");
return;
}
if (!alunoExiste(idAluno)) {
System.out.println("Aluno não encontrado no sistema.");
return;
}
nomeAluno = obterNomeAluno(idAluno);
} else {
idAluno = CadastroUtils.gerarIdUnico();
System.out.println("ID gerado: " + idAluno);
System.out.print("Digite o nome do aluno: ");
nomeAluno = scanner.nextLine().trim();
salvarAluno(idAluno, nomeAluno);
}
// Inserir notas 
double n1 = 0.0, n2 = 0.0, rep = 0.0, ex = 0.0;
System.out.print("Deseja inserir as notas agora? (s/n): ");
if (scanner.nextLine().trim().toLowerCase().equals("s")) {
n1 = solicitarNota(scanner, "Nota 1");
n2 = solicitarNota(scanner, "Nota 2");
rep = solicitarNota(scanner, "Reposição");
ex = solicitarNota(scanner, "Exame");
}
// 4. Escrever no arquivo do curso
try (BufferedWriter bw = new BufferedWriter(new FileWriter(arquivoCurso, true))) {
bw.write(idAluno + "," + n1 + "," + n2 + "," + rep + "," + ex);
bw.newLine();
System.out.println("Aluno matriculado com sucesso no curso " + nomeCurso + ".");
} catch (IOException e) {
System.out.println("Erro ao escrever no arquivo do curso.");
}
}
private static List listarCursos() {
List cursos = new ArrayList();
try (BufferedReader br = new BufferedReader(new FileReader(CURSOS_CSV))) {
String linha;
while ((linha = br.readLine()) != null) {
String[] partes = linha.split(",");
if (partes.length >= 1) {
cursos.add(partes[0]);
}
}
} catch (IOException e) {
System.out.println("Erro ao ler cursos.");
}
return cursos;
}
private static boolean alunoExiste(int id) {
try (BufferedReader br = new BufferedReader(new FileReader(ALUNOS_CSV))) {
String linha;
while ((linha = br.readLine()) != null) {
String[] partes = linha.split(",");
if (Integer.parseInt(partes[0]) == id) {
return true;
}
}
} catch (IOException | NumberFormatException e) {
return false;
}
return false;
}
private static String obterNomeAluno(int id) {
try (BufferedReader br = new BufferedReader(new FileReader(ALUNOS_CSV))) {
String linha;
while ((linha = br.readLine()) != null) {
String[] partes = linha.split(",");
if (Integer.parseInt(partes[0]) == id) {
return partes[1];
}
}
} catch (IOException | NumberFormatException e) {
return "";
}
return "";
}
private static void salvarAluno(int id, String nome) {
try (BufferedWriter bw = new BufferedWriter(new FileWriter(ALUNOS_CSV, true))) {
bw.write(id + "," + nome);
bw.newLine();
} catch (IOException e) {
System.out.println("Erro ao salvar aluno.");
}
}
private static double solicitarNota(Scanner scanner, String campo) {
while (true) {
System.out.print(campo + ": ");
try {
return Double.parseDouble(scanner.nextLine().trim());
} catch (NumberFormatException e) {
System.out.println("Nota inválida. Digite um número.");
}
}
}
}
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Scanner;
public class CriarCurso {
private static final String CURSOS_CSV = "data/cursos.csv";
private static final String ALUNOS_CSV = "data/Alunos.csv";
public static void criar() { // metodo 
Scanner scanner = new Scanner(System.in); // scanner das informaçõesa passadas pelo usuario no terminal 
System.out.println("\n=== Criar Novo Curso ===");
System.out.print("Nome do curso (sem espaços): ");
String nomeCurso = scanner.nextLine().trim().replace(" ", "_");
System.out.print("Nível (Ex: Graduação, Pós): ");
String nivel = scanner.nextLine().trim();
System.out.print("Ano de início: ");
String ano = scanner.nextLine().trim();
// Adiciona ao cursos.csv
try (BufferedWriter bw = new BufferedWriter(new FileWriter(CURSOS_CSV, true))) {
bw.write(nomeCurso + "," + nivel + "," + ano);
bw.newLine();
} catch (IOException e) {
System.out.println("Erro ao salvar curso.");
return;
}
// Cria arquivo do curso
String nomeArquivoCurso = nomeCurso + ".csv";
File cursoFile = new File(nomeArquivoCurso);
try {
if (!cursoFile.createNewFile()) {
System.out.println("Arquivo do curso já existia, continuará sendo usado.");
}
} catch (IOException e) {
System.out.println("Erro ao criar arquivo do curso.");
return;
}
// 3. Cadastrar alunos
System.out.print("Quantos alunos deseja cadastrar? ");
int qtd;
try {
qtd = Integer.parseInt(scanner.nextLine()); //parseInt converte string em numero 
} catch (NumberFormatException e) {
System.out.println("Número inválido.");
return;
}
for (int i = 0; ido curso.");
}
}
System.out.println("\nCurso e alunos cadastrados com sucesso.");
}
private static void salvarAlunoSeNaoExistir(int id, String nome) {
boolean existe = false;
try (BufferedReader br = new BufferedReader(new FileReader(ALUNOS_CSV))) {
String linha;
while ((linha = br.readLine()) != null) {
String[] dados = linha.split(",");
if (dados.length >= 1 && Integer.parseInt(dados[0]) == id) {
existe = true;
break;
}
}
} catch (IOException ignored) {}
if (!existe) {
try (BufferedWriter bw = new BufferedWriter(new FileWriter(ALUNOS_CSV, true))) {
bw.write(id + "," + nome);
bw.newLine();
} catch (IOException e) {
System.out.println("Erro ao salvar novo aluno.");
}
}
}
private static double solicitarNota(Scanner scanner, String campo) {
while (true) {
System.out.print(campo + ": ");
try {
return Double.parseDouble(scanner.nextLine().trim()); //parseDouble converte string em numero flutuante
} catch (NumberFormatException e) {
System.out.println("Valor inválido. Digite um número.");
}
}
}
}
public class Aluno {
private int id;
private String nome;
private String curso;
private double nota1;
private double nota2;
private double reposicao;
private double exame;
private int artigos;
private int iniciacoes;
public Aluno(int id, String nome) { // construtor que chama na lista o id e nome
this.id = id;
this.nome = nome;
}
public double calcularMedia() { // metodo para calculo de média
double mediaInicial = (nota1 + nota2) / 2.0;
if (mediaInicial >= 7.0) {
return mediaInicial;
}
// Considera a nota de reposição
if (reposicao > 0) {
double melhorNota = Math.max(nota1, nota2);
mediaInicial = (melhorNota + reposicao) / 2.0;
if (mediaInicial >= 7.0) return mediaInicial;
}
// Considera nota de exame
return (mediaInicial + exame) / 2.0;
}
public String getSituacao() {
return calcularMedia() >= 5.0 ? "Aprovado" : "Reprovado";
}
public int getId() {
return id;
}
public String getNome() {
return nome;
}
public String getCurso() {
return curso;
}
public void setCurso(String curso) {
this.curso = curso;
}
public double getNota1() {
return nota1;
}
public void setNota1(double nota1) {
this.nota1 = nota1;
}
public double getNota2() {
return nota2;
}
public void setNota2(double nota2) {
this.nota2 = nota2;
}
public double getReposicao() {
return reposicao;
}
public void setReposicao(double reposicao) {
this.reposicao = reposicao;
}
public double getExame() {
return exame;
}
public void setExame(double exame) {
this.exame = exame;
}
public int getArtigos() {
return artigos;
}
public void setArtigos(int artigos) {
this.artigos = artigos;
}
public int getIniciacoes() {
return iniciacoes;
}
public void setIniciacoes(int iniciacoes) {
this.iniciacoes = iniciacoes;
}
}
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException; // leitura de arquivos
import java.util.HashSet;
import java.util.Random; // gera numeros aleatorios
import java.util.Set; 
public class CadastroUtils {
private static final String ALUNOS_CSV = "data/Alunos.csv";
public static int gerarIdUnico() {
Random random = new Random();
Set idsExistentes = carregarIdsExistentes();
int novoId;
do {
novoId = 1000 + random.nextInt(9000); // Gera entre 1000 e 9999
} while (idsExistentes.contains(novoId));
return novoId;
}
private static Set carregarIdsExistentes() {
Set ids = new HashSet(); // eliminar duplicatas
try (BufferedReader br = new BufferedReader(new FileReader(ALUNOS_CSV))) { 
String linha;
while ((linha = br.readLine()) != null) {
String[] partes = linha.split(",");
if (partes.length >= 1) {
try {
ids.add(Integer.parseInt(partes[0]));
} catch (NumberFormatException ignored) {}
}
}
} catch (IOException e) {
System.out.println("Erro ao carregar IDs existentes: " + e.getMessage());
}
return ids;
}
}
9. Ficha de Atividade Prática Supervisionada 
BRUNA GABRIELA BISPO DE ARAUJO G968HD6
GABRIEL AMORIM DOS SANTOS G56DJI5
GIOVANA DIAS CAVALCANTI G2761I7
JOÃO VITOR FELTRIN G74ICE1
LÍVIA DE SOUZA BARBOSA RA 190080
image5.png
image6.png
image7.png
image8.png
image9.png
image10.png
image11.png
image12.png
image13.png
image14.png
image15.png
image16.png
image17.png
image18.png
image19.png
image20.png
image21.png
image22.png
image23.png
image24.png
image25.png
image26.png
image27.png
image28.png
image29.png
image30.png
image31.png
image32.png
image33.jpeg
image34.jpeg
image35.jpeg
image36.jpeg
image37.jpeg
image38.jpeg
image39.jpeg
image40.jpeg
image41.jpeg
image42.jpeg
image43.jpeg
image44.jpeg
image45.jpeg
image46.jpeg
image47.png
image48.png
image49.png
image50.png
image51.png
image1.png
image2.png
image3.png
image4.png