1
resposta

Ajuda no meu projeto

Não consigo realizar ele, alguem poderia me ajudar/auxiliar, vou enviar o git com o meu codigo atual: https://github.com/Duduenri/POObiblioteca

Desenvolver um sistema de gerenciamento de uma biblioteca utilizando os conceitos de Programação Orientada a Objetos (POO). Este projeto servirá para revisar e aplicar os principais conceitos abordados ao longo da unidade curricular, como classes, objetos, herança, polimorfismo, encapsulamento, e manipulação de arquivos.

Descrição do Projeto:

Os alunos deverão criar um sistema que permita o gerenciamento de livros, membros da biblioteca e empréstimos de livros. Os grupos poderão ser de até 3 integrantes. O sistema deve ser capaz de realizar as seguintes operações:

  1. Cadastro de Livros
    • Adicionar novo livro (com atributos como título, autor, ISBN, ano de publicação).
    • Listar todos os livros cadastrados.
    • Atualizar informações de um livro.
    • Remover um livro do cadastro.
  2. Cadastro de Membros
    • Adicionar novo membro (com atributos como nome, número de matrícula, endereço, telefone).
    • Listar todos os membros cadastrados.
    • Atualizar informações de um membro.
    • Remover um membro do cadastro.
  3. Gerenciamento de Empréstimos
    • Realizar empréstimo de um livro para um membro (registrar data de empréstimo e data de devolução).
    • Listar todos os empréstimos ativos.
    • Registrar devolução de um livro.
    • Listar histórico de empréstimos.

Requisitos Técnicos:

  • Classes e Objetos:
    • Criar classes para Livro, Membro e Empréstimo.
    • Utilizar encapsulamento para proteger os atributos das classes.
    • Implementar métodos para adicionar, atualizar, remover e listar objetos.
  • Herança e Polimorfismo:
    • Implementar uma classe base "Pessoa" e derivar a classe "Membro" dela.
    • Demonstrar o uso de polimorfismo através de métodos que podem ser sobrepostos.
  • Manipulação de Arquivos:
    • Salvar e carregar os dados dos livros, membros e empréstimos de/para arquivos para garantir a persistência dos dados.
    • Utilizar arquivos de texto ou CSV para armazenamento.
  • Interface:
    • Desenvolver uma interface de linha de comando (CLI) para interação com o usuário.
    • Oferecer um menu para navegar entre as diferentes funcionalidades do sistema.

Passo a Passo para a Execução:

  1. Planejamento:
    • Dividir o projeto em módulos: Cadastro de Livros, Cadastro de Membros, Gerenciamento de Empréstimos, e Interface CLI.
    • Definir as classes e seus atributos.
    • Especificar os métodos necessários para cada funcionalidade.
  2. Implementação:
    • Implementar as classes Livro, Membro (herdando de Pessoa) e Empréstimo.
    • Desenvolver métodos de manipulação de dados (CRUD) para livros e membros.
    • Implementar funções para realizar e registrar empréstimos, além de devolver livros.
  3. Persistência de Dados:
    • Criar métodos para salvar e carregar dados de arquivos.
    • Garantir que todas as alterações (adicionar, atualizar, remover) sejam refletidas nos arquivos correspondentes.
  4. Interface de Usuário:
    • Desenvolver uma interface de linha de comando para facilitar a interação com o sistema.
    • Implementar um menu principal que permita ao usuário escolher entre as funcionalidades disponíveis (Cadastro de Livros, Cadastro de Membros, Empréstimos).
1 resposta

Olá, Eduardo.

Tudo bem?

Muito legal o seu projeto de gerenciamento de biblioteca, ideia top! Vou te dar algumas dicas e exemplos para tentar te ajudar:

Estrutura do Projeto

Primeiro, vamos organizar as classes principais que você vai precisar:

  1. Classe Pessoa (base para Membro):

    class Pessoa {
        constructor(
            public nome: string,
            public endereco: string,
            public telefone: string
        ) {}
    }
    
  2. Classe Membro (herdando de Pessoa):

    class Membro extends Pessoa {
        constructor(
            nome: string,
            endereco: string,
            telefone: string,
            public numeroMatricula: string
        ) {
            super(nome, endereco, telefone);
        }
    }
    
  3. Classe Livro:

    class Livro {
        constructor(
            public titulo: string,
            public autor: string,
            public isbn: string,
            public anoPublicacao: number
        ) {}
    }
    
  4. Classe Emprestimo:

    class Emprestimo {
        constructor(
            public livro: Livro,
            public membro: Membro,
            public dataEmprestimo: Date,
            public dataDevolucao: Date | null = null
        ) {}
    }
    

Métodos CRUD

Vamos criar métodos para adicionar, atualizar, remover e listar livros e membros. Aqui está um exemplo para a classe Livro:

class Biblioteca {
    private livros: Livro[] = [];
    private membros: Membro[] = [];
    private emprestimos: Emprestimo[] = [];

    adicionarLivro(livro: Livro): void {
        this.livros.push(livro);
    }

    listarLivros(): Livro[] {
        return this.livros;
    }

    atualizarLivro(isbn: string, novoLivro: Livro): void {
        const index = this.livros.findIndex(l => l.isbn === isbn);
        if (index !== -1) {
            this.livros[index] = novoLivro;
        }
    }

    removerLivro(isbn: string): void {
        this.livros = this.livros.filter(l => l.isbn !== isbn);
    }

    // Métodos para membros e empréstimos seguem a mesma lógica...
}

Persistência de Dados

Para salvar e carregar dados de arquivos, você pode usar o módulo fs do Node.js. Aqui está um exemplo básico de como salvar e carregar livros:

import * as fs from 'fs';

class Biblioteca {
    // ... outros métodos

    salvarLivros(): void {
        fs.writeFileSync('livros.json', JSON.stringify(this.livros));
    }

    carregarLivros(): void {
        const data = fs.readFileSync('livros.json', 'utf8');
        this.livros = JSON.parse(data);
    }
}

Interface de Linha de Comando (CLI)

Para a interface CLI, você pode usar o pacote readline do Node.js para interagir com o usuário. Aqui está um exemplo simples de como criar um menu:

import * as readline from 'readline';

const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
});

function menu() {
    console.log('1. Adicionar Livro');
    console.log('2. Listar Livros');
    console.log('3. Sair');
    rl.question('Escolha uma opção: ', (opcao) => {
        switch (opcao) {
            case '1':
                // Lógica para adicionar livro
                break;
            case '2':
                // Lógica para listar livros
                break;
            case '3':
                rl.close();
                break;
            default:
                console.log('Opção inválida!');
                menu();
        }
    });
}

menu();

Esses são apenas alguns exemplos e sugestões para te ajudar a começar. Dê uma olhada no seu código atual no GitHub e veja como você pode integrar essas ideias.

Veja se faz sentido, qualquer dúvida manda aqui de novo.

Espero ter ajudado e bons estudos!