GitHub - juletopi/POO_Programacao_Orientada_a_Objetos: 🧩 • Repositório back-end com os conteúdos de Programação Orientada a Objetos, utilizando o Visual Studio e a linguagem CSharp como ferramentas de aprendizado.

Programação Orientada a Objetos 🧩

• Este é um repositório com o conteúdo das aulas de Programação Orientada a Objetos,
ministradas pelo professor Elias de Abreu, utilizando o Visual Studio, linguagem
CSharp e framework .NET Framework como ferramentas de aprendizado.

Sumário 🧾

Professor | Sobre o tópico | Conceitos Aprendidos 1 | Conceitos Aprendidos 2

Revisão de P.O.O 1 | Revisão de P.O.O 2 | Revisão de P.O.O 3 | Revisão de P.O.O 4

Conexão com MySQL em P.O.O | Autor

👨‍🏫 Professor:

Elias de Abreu Domingos da Silva - Entusiasta em T.I. | Perito Criminal na Área da Informática | Professor de Curso Técnico e Superior
IFRO Campus Ji-Paraná • Atuando desde Dezembro de 2017
Linguagens & Tecnologias: Visual Studio • MySQL • C# • PHP • Java • E outros...
Contato: Elias de Abreu (LinkedIn)

🌟 Programação Orientada a Objetos (P.O.O)

❓ O que é isso?

A Programação Orientada a Objetos (P.O.O) é uma maneira de escrever código pensando em objetos interconectados, cada um com suas próprias características e habilidades. Isso nos ajuda a organizar o código de forma lógica, dividindo-o em classes e objetos.

📋 Principais Conceitos

🧩 Classe: É um modelo para criar "objetos", especificando os "atributos" e "métodos" que os objetos terão.
- 🔖 Atributos: São as características ou propriedades de uma classe. Eles definem o estado ou dados que os objetos dessa classe podem ter.
- 🔍 Objeto: É uma "instância" de uma classe que representa uma entidade específica com dados e funcionalidades definidos pela classe.
- 📦 Instância: É um objeto concreto criado a partir de uma classe. Cada instância de uma classe pode ter diferentes valores para seus atributos, mesmo que compartilhem a mesma estrutura e comportamento definidos pela classe.
⚙️ Métodos: São as ações que um objeto pode realizar, definidos dentro das classes. Eles podem receber parâmetros, realizar operações e retornar valores, permitindo que os objetos interajam entre si e com o ambiente. Tipos especiais de métodos são "Método Construtor" e "Método Virtual".
- 🏗️ Método Construtor: É um tipo especial de método que é chamado automaticamente quando uma nova instância de uma classe é criada. Ele tem o mesmo nome da classe, não possui tipo de retorno, e seu principal objetivo é inicializar os atributos do objeto. Os construtores podem ser "sobrecarregados", ou seja, pode haver mais de um construtor com diferentes parâmetros na mesma classe.
- 🔄 Sobrecarga de Método: É uma característica que permite que uma classe tenha mais de um método com o mesmo nome, mas com diferentes assinaturas (número ou tipo de parâmetros). A sobrecarga de método facilita a criação de métodos que executam funções similares, mas com diferentes tipos ou números de parâmetros.
- 🌀 Método Virtual: São métodos definidos em uma classe base que podem ser substituídos por métodos nas classes derivadas. Eles permitem que as classes derivadas forneçam uma implementação específica para o método. Em P.O.O, classes bases e classes derivadas são um conceito de "herança".
⚠️ Exceções: São mecanismos para lidar com erros que ocorrem durante a execução do programa. Exceções permitem que o programa continue rodando, mesmo quando erros imprevistos acontecem. Elas são tratadas usando blocos try-catch.
🧬 Herança: Permite que uma classe herde características de outra, evitando repetição de código.
🔒 Encapsulamento: Esconde partes do código e permite acesso apenas por métodos específicos.
🔀 Polimorfismo: Permite que diferentes objetos podem ser tratados de maneira uniforme, mesmo sendo de classes diferentes.
📝 Abstração: É o processo de identificar as características essenciais de um objeto, ignorando os detalhes irrelevantes. Isso é feito definindo classes que encapsulam o comportamento e estado das entidades do mundo real.

P.O.O torna o código mais organizado, fácil de entender e reutilizável, principalmente em programas maiores e mais complexos onde há centenas e centenas de linhas de código. É como se tivéssemos uma pilha de roupas e as separássemos em um armário com cada compartimento para um tipo de roupa diferente, assim conseguimos nos organizar melhor ao trabalharmos com programação.

Voltar para o início ↺

📚 Conceitos Aprendidos:

1. Classes, Objetos e Métodos

Note

Retirado da aula de "Software_de_Gerenciamento_(POO)"

Nesta aula foram aprendidos:

Conceitos básicos para a criação de Classes
Conceitos básicos para a criação de Objetos
Criação de Métodos na mesma instância das Classes

public class Funcionario // <-- Criação da Classe "Funcionário"
{
    public string nome; 
    public string cpf;
    public string email;
    public string senhaAcesso;
    public DateTime dataNascimento;
    public string sexo;

    public int CalcularIdade() // <-- Criação dum Método que calcula a idade do funcionário
    {
        DateTime dataAtual = DateTime.Today;
        int idade = dataAtual.Year - dataNascimento.Year;

        if (dataAtual < dataNascimento.AddYears(idade))
        {
            idade--;
        }

        return idade;
    }
}

static void Main(string[] args) // <-- Main program
{
    // SOFTWARE DE GERENCIAMENTO - APRENDENDO A FAZER CLASSES E ATRIBUTOS

    // A empresa "Plugar Tecnologia" deseja desenvolver um software para gerenciar os serviços oferecidos aos clientes.
    // Para isso, é necessário cadastrar os clientes com os seguintes dados: Nome, CPF, Data de Nascimento e Sexo.
    // Também é necessário cadastrar os funcionários com: Nome, CPF, E-mail, Senha de Acesso, Data de Nascimento e Sexo.
    // Cada serviço serviço possui: Um código, Nome, Valor Estimado, Garantias e o Tempo Estimado para a realização.

    // Um caixa tem um dos serviços oferecidos aos clientes em forma de vendas, cada venda tem uma Data, Horário,
    // Valor Total, Cliente, os Serviços Oferecidos e um Caixa de ata de abertura, uma Data de Fechamento,
    // um Funcionário Responsável, Valor de Abertura, Status (Aberto ou Fechado) e o Saldo Final.

    // -------------------------------------------------------------------------------

    Funcionario f1 = new Funcionario(); // <-- Criando um novo objeto para a classe e atribuindo valores
    f1.nome = "Bernado";
    f1.cpf = "011.900.605-12";
    f1.email = "bernadin1101@gmail.com";
    f1.senhaAcesso = "090001";
    f1.dataNascimento = new DateTime(1998, 11, 01);
    f1.sexo = "M";
    int idade = f1.CalcularIdade();

    Console.Write("\r\n ┌────────────────────────────────────────┐");
    Console.Write("\r\n │ Calculando a idade dos funcionários... │");
    Console.Write("\r\n └────────────────────────────────────────┘\r\n");

    Console.WriteLine($" A idade do(a) funcionário(a) {f1.nome} é {idade} anos.");

    Funcionario f2 = new Funcionario();
    f2.nome = "Túlio";
    f2.cpf = "073.743.623-24";
    f2.email = "tuliomurilo03@gamil.com";
    f2.senhaAcesso = "090002";
    f2.dataNascimento = new DateTime(2003, 01, 17);
    f2.sexo = "M";
    idade = f2.CalcularIdade();
    Console.WriteLine($" A idade do(a) funcionário(a) {f2.nome} é {idade} anos.");

    Funcionario f3 = new Funcionario();
    f3.nome = "Letícia";
    f3.cpf = "061.807.612-14";
    f3.email = "kirbystar99@gmail.com";
    f3.senhaAcesso = "090003";
    f3.dataNascimento = new DateTime(2000, 01, 30);
    f3.sexo = "F";
    idade = f3.CalcularIdade();
    Console.WriteLine($" A idade do(a) funcionário(a) {f3.nome} é {idade} anos.");

    Console.ReadKey();
}

Voltar para o início ↺

2. Listas e Classes

Note

Retirado da aula de "Cadastro_de_Alunos_(POO)"

Nesta aula foram aprendidos:

Implementação de listas simples na criação de classes, objetos e atributos

public class Aluno // <-- Criação da classe "Aluno"
{
    public string nome;  // <-- Atributo para armazenar o nome do aluno
    public string cpf;   // <-- Atributo para armazenar o CPF do aluno
    public string email; // <-- Atributo para armazenar o email do aluno
}

static void Main(string[] args)
{
    // CADASTRO DE ALUNO - IMPLEMENTANDO LISTAS NA CRIAÇÃO DE CLASSES E ATRIBUTOS

    // Faça um algoritmo de "Cadastro de Alunos". Nesse algoritmo terá uma interação com o usuário
    // onde será perguntado se ele deseja cadastrar um aluno com Nome, CPF e Email até que ele
    // selecione que não deseja mais cadastrar nenhum aluno, assim finalizando o cadastro e
    // mostrando uma lista de todos cadastrados com seus respectivos Nomes, CPFs e Emails.

    // -------------------------------------------------------------------------------

    List<Aluno> alunos = new List<Aluno>(); // <-- Lista para armazenar os alunos cadastrados

    Console.Write("\r\n ┌────────────────────┐");
    Console.Write("\r\n │ Cadastro de Alunos │");
    Console.Write("\r\n └────────────────────┘\r\n");

    while (true)
    {
        Console.WriteLine("\n Deseja cadastrar um aluno? (s/n)");
        string resposta = Console.ReadLine();

        if (resposta.ToLower() != "s")
        {
            break;
        }

        Aluno aluno = new Aluno(); // <-- Cria um novo objet "Aluno"

        Console.Write("\n Nome do(a) aluno: ");
        aluno.nome = Console.ReadLine();

        Console.Write(" CPF do aluno: ");
        aluno.cpf = Console.ReadLine();

        Console.Write(" Email do aluno: ");
        aluno.email = Console.ReadLine();

        alunos.Add(aluno); // <-- Adiciona o aluno à lista de alunos cadastrados
    }

    Console.WriteLine("\r\n -----------------------------------------");
    Console.Write("\r\n ┌──────────────────────────────┐");
    Console.Write("\r\n │ Lista de alunos cadastrados: │");
    Console.Write("\r\n └──────────────────────────────┘\r\n");
    foreach (var aluno in alunos) // Para cada aluno na lista de alunos cadastrados...
    {
        Console.WriteLine($"\n Nome: {aluno.nome}, CPF: {aluno.cpf}, Email: {aluno.email}"); // ...exibe na tela o nome, CPF e email do aluno
    }
    Console.WriteLine("\r\n -----------------------------------------");
    Console.ReadKey();
}

Voltar para o início ↺

⚠️ AVISO
A partir deste ponto em diante, devido a greve das universidades federais em 2024, o conteúdo da disciplina será reestudado.

3. Revisão de P.O.O 1

Note

Retirado da aula de "RevisaoPOO"

Nesta aula foram revisionados os "conceitos básicos" de P.O.O:
- Classes, Objetos e Atributos
- Visibilidade (Modificador de Acesso)
- Métodos e Métodos Construtores
- Encapsulamento (Get e Set)

public class Aluno // <-- Classe "Aluno"
{
    // Atributos da classe "Aluno"
    public string nome; // <-- Nome do aluno
    public DateTime dataNasc; // <-- Data de nascimento do aluno
    public int idade; // <-- Idade do aluno

    // Método construtor da classe "Aluno"
    public Aluno(string nome, DateTime dataNasc) 
    {
        this.nome = nome; // <-- Parâmetro do atributo "nome"
        this.dataNasc = dataNasc; // <-- Parâmetro do atributo "dataNasc"

        // Calcula a idade do aluno com base no ano atual e no ano de nascimento do aluno
        idade = DateTime.Now.Year - dataNasc.Year;

        // Ajusta a idade caso a data de aniversário do aluno ainda não chegou no ano corrente
        if (DateTime.Now.DayOfYear < dataNasc.DayOfYear)
        {
            idade--; // <-- Reduz 1 ano se o aluno ainda não fez aniversário este ano
        }
    }

    // Método para exibir informações do aluno
    public void ExibirInformacoes()
    {
        Console.WriteLine($"Nome: {nome}"); // <-- Exibe o nome do aluno
        Console.WriteLine($"Data de Nascimento: {dataNasc.ToShortDateString()}"); // <-- Exibe a data de nascimento do aluno formatada como string
        Console.WriteLine($"Idade: {idade}"); // <-- Exibe a idade do aluno
    }
}

internal class Program
{
    static void Main(string[] args)
    {
        // Solicita ao usuário o nome do aluno
        Console.Write("Digite o nome do aluno: ");
        string nome = Console.ReadLine();

        // Solicita ao usuário a data de nascimento do aluno
        Console.Write("Digite a data de nascimento do aluno (dd/MM/yyyy): ");
        DateTime dataNasc;

        // Tenta converter a entrada do usuário para DateTime até que uma data válida seja fornecida
        while (!DateTime.TryParse(Console.ReadLine(), out dataNasc))
        {
            Console.Write("Data inválida. Digite a data de nascimento do aluno (dd/MM/yyyy): ");
        }

        // Criação de um objeto da classe "Aluno"
        Aluno a1 = new Aluno(nome, dataNasc);

        // Chama o método para exibir as informações do aluno
        a1.ExibirInformacoes();

        Console.ReadKey();
    }
}

Vamos destacar quais conceitos foram aprendidos e como eles foram aplicados no código:

1. Classes

Definição: Uma classe é um molde para criar objetos. Define atributos e métodos que os objetos dessa classe terão.
Exemplo no código: public class Aluno define uma classe chamada Aluno.

2. Objetos

Definição: Um objeto é uma instância de uma classe.
Exemplo no código: Aluno a1 = new Aluno(nome, dataNasc); cria uma instância da classe Aluno.

3. Atributos

Definição: Variáveis dentro de uma classe que armazenam dados.
Exemplo no código: public string nome;, public DateTime dataNasc; e public int idade; são atributos da classe Aluno.

4. Métodos

Definição: Funções dentro de uma classe que definem comportamentos dos objetos.
Exemplo no código: public void ExibirInformacoes() é um método na classe Aluno.

5. Métodos Construtores

Definição: Métodos especiais que são chamados quando um objeto é criado. Inicializam atributos.
Exemplo no código: public Aluno(string nome, DateTime dataNasc) é o construtor da classe Aluno.

6. Encapsulamento (Get e Set)

Definição: Protege os dados de uma classe e permite acesso controlado. No exemplo dado, não há uso explícito de propriedades com get e set, mas a lógica de encapsulamento foi seguida com os atributos e métodos.
Exemplo no código: public string nome;, public DateTime dataNasc; e public int idade; são acessados e modificados diretamente. Em um design mais robusto, você poderia usar propriedades para encapsular esses campos.

Voltar para o início ↺

4. Revisão de P.O.O 2

Note

Retirado da aula de "RevisaoPOO2"

Nesta aula foram revisionados "Listas":
- Criação de listas
- Manipulação de listas
- Exibição dos resultados destas listas

public class Alunos // <-- Classe Alunos
{
    // Atributos da classe Alunos
    public string nome;
    public int matricula;
    public string cpf;
    public string email;
    public DateTime dataNasc;

    // Método construtor da classe Alunos
    public Alunos (string alunoNome, int alunoMatricula, string alunoCPF, string alunoEmail, DateTime alunoDataNasc)
    {
        nome = alunoNome;
        matricula = alunoMatricula;
        cpf = alunoCPF;
        email = alunoEmail;
        dataNasc = alunoDataNasc;
    }

    // Sobrescrevendo o método ToString para fornecer uma representação em string dos dados do aluno
    public override string ToString()
    {
        return "Nome: " + nome + " - " + "Matrícula: " + matricula + " - " + "CPF: " + cpf + " - " + "E-mail: " + email + " - " + "Data de Nascimento: " + dataNasc.ToString();
    }
}

internal class Program
{
    static void Main(string[] args)
    {
        // Criação de uma lista de objetos da classe Alunos
        List<Alunos> listAlunos = new List<Alunos>();

        // Criação de objetos da classe Alunos
        Alunos aluno1 = new Alunos("Rafaela", 048, "625552980-20", "rafa022@gmail.com", new DateTime(2001, 09, 12));
        Alunos aluno2 = new Alunos("Júlio", 027, "073743612-38", "julio03@gmail.com", new DateTime(2003, 09, 17));
        Alunos aluno3 = new Alunos("Breno", 089, "390900176-46", "brenopd@gmail.com", new DateTime(2005, 09, 01));
        Alunos aluno4 = new Alunos("Iberê", 021, "192236608-36", "tenoriomm@gmail.com", new DateTime(1998, 11, 21));
        Alunos aluno5 = new Alunos("João", 055, "902630047-18", "jaovictor001@gmail.com", new DateTime(1991, 07, 03));

        // Adicionando os objetos Alunos à lista
        listAlunos.Add(aluno1);
        listAlunos.Add(aluno2);
        listAlunos.Add(aluno3);
        listAlunos.Add(aluno4);
        listAlunos.Add(aluno5);

        // Exibindo todos os alunos da lista
        Console.WriteLine("Exibindo a lista de alunos:\r\n");
        foreach (Alunos alunos in listAlunos)
        {
            Console.WriteLine(alunos.ToString());
        }
        Console.WriteLine("\r\n---------------------------------------------\r\n");

        // Buscando e exibindo um aluno específico pela matrícula
        Console.WriteLine("Exibindo a busca por um aluno específico:\r\n");
        Alunos search = listAlunos.Find(x => x.matricula == 027);
        Console.WriteLine(search.ToString());
        Console.WriteLine("\r\n---------------------------------------------\r\n");

        // Buscando e exibindo alunos com número de matrícula maior que 40
        Console.WriteLine("Exibindo a lista de alunos com o número de matrícula maior que 40:\r\n");
        List<Alunos> searchList = listAlunos.Where(x => x.matricula > 40).ToList();
        foreach (Alunos alunos in searchList)
        {
            Console.WriteLine(alunos.ToString());
        }
        Console.WriteLine("\r\n---------------------------------------------\r\n");

        // Buscando e exibindo o maior número de matrícula
        Console.WriteLine("Exibindo o maior número de matrícula:\r\n");
        int b = listAlunos.Max(x => x.matricula);
        Console.WriteLine(b);
        Console.WriteLine("\r\n---------------------------------------------\r\n");

        // Ordenando e exibindo a lista de alunos pelo número de matrícula em ordem crescente
        Console.WriteLine("Exibindo a lista de alunos ordenados a partir do número de matrícula em ordem crescente:\r\n");
        List<Alunos> ordenedList = listAlunos.OrderBy(x => x.matricula).ToList();
        foreach (Alunos alunos in ordenedList)
        {
            Console.WriteLine(alunos.ToString());
        }
        Console.WriteLine("\r\n---------------------------------------------\r\n");

        // Buscando e exibindo alunos cujos nomes contêm a letra 'e'
        Console.WriteLine("Exibindo a busca por alunos com a letra 'e' em seus nomes:\r\n");
        List<Alunos> distinctiveList = listAlunos.Where(x => x.nome.ToLower().Contains("e")).ToList();
        foreach (Alunos alunos in distinctiveList)
        {
            Console.WriteLine(alunos.ToString());
        }
        Console.WriteLine("\r\n---------------------------------------------\r\n");

        // Buscando e exibindo alunos cujos nomes começam com a letra 'j'
        Console.WriteLine("Exibindo a busca por alunos com nomes que começam com a letra 'j':\r\n");
        List<Alunos> startsWithList = listAlunos.Where(x => x.nome.ToLower().StartsWith("j")).ToList();
        foreach (Alunos alunos in startsWithList)
        {
            Console.WriteLine(alunos.ToString());
        }

        Console.ReadKey();
    }
}

Vamos destacar quais conceitos foram aprendidos e como eles foram aplicados no código:

1. Listas

Definição: Listas são coleções genéricas que podem armazenar elementos de um tipo específico e fornecer métodos para manipulação de dados.
Exemplo no código: List<Alunos> listAlunos cria uma lista para armazenar objetos da classe Alunos. Métodos como Add, Find, Where, OrderBy, Max, e ToList são usados para manipular a lista, como adicionar elementos, buscar, filtrar, ordenar e encontrar o valor máximo.

2. LINQ (Language Integrated Query)

Definição: LINQ é uma tecnologia para realizar consultas a coleções de dados de maneira declarativa, integrando capacidades de consulta diretamente na linguagem C#.
Exemplo no código: Exemplos incluem:
- Find(x => x.matricula == 027) para encontrar um aluno específico pela matrícula.
- Where(x => x.matricula > 40).ToList() para filtrar alunos com número de matrícula maior que 40.
- OrderBy(x => x.matricula).ToList() para ordenar os alunos pelo número de matrícula.
- Max(x => x.matricula) para encontrar o maior número de matrícula.
- Where(x => x.nome.ToLower().Contains("e")).ToList() para encontrar alunos com a letra 'e' nos nomes.
- Where(x => x.nome.ToLower().StartsWith("j")).ToList() para encontrar alunos cujos nomes começam com a letra 'j'.

3. Entrada e Saída de Dados

Definição: Entrada e saída de dados referem-se à interação do programa com o usuário ou outras fontes de dados, permitindo que o programa receba informações e exiba resultados.
Exemplo no código:
- Console.WriteLine é usado para exibir mensagens e resultados das operações realizadas na lista.
- Console.ReadKey é usado para pausar a execução do programa até que uma tecla seja pressionada, permitindo ao usuário ver os resultados antes que o programa feche.

Voltar para o início ↺

5. Revisão de P.O.O 3

Note

Retirado da aula de "RevisaoPOO3"

Nesta aula foram revisionados "Heranças":
- Criação de heranças (Classes "pai" e classes "filho")
- Polimorfismo
- Métodos Virtuais e Override

public class Cliente // <-- Classe Base "pai" Cliente
{
    // Propriedades comuns a todos os clientes
    public string ID { get; set; }
    public string Nome { get; set; }
    public string Email { get; set; }
    public string Telefone { get; set; }

    // Método virtual que pode ser sobrescrito nas classes derivadas para cadastrar as informações do cliente
    public virtual void Cadastrar()
    {
        // Este método será implementado nas classes derivadas...
    }

    // Método virtual que pode ser sobrescrito para exibir informações do cliente
    public virtual void ExibirInformacoes()
    {
        Console.WriteLine($"ID: {ID} - Nome: {Nome} - Email: {Email} - Telefone: {Telefone}");
    }
}

public class ClientePJ : Cliente // <-- Classe Derivada "filho" ClientePJ
{
    // Propriedades específicas para clientes pessoa jurídica (PJ)
    public string CNPJ { get; set; }
    public string RazaoSocial { get; set; }
    public string NomeFantasia { get; set; }

    // Implementação do método para cadastrar informações do cliente PJ
    public override void Cadastrar()
    {
        Console.Write("Digite o ID: ");
        ID = Console.ReadLine();

        Console.Write("Digite o Nome: ");
        Nome = Console.ReadLine();

        Console.Write("Digite o Email: ");
        Email = Console.ReadLine();

        Console.Write("Digite o Telefone: ");
        Telefone = Console.ReadLine();

        Console.Write("Digite o CNPJ: ");
        CNPJ = Console.ReadLine();

        Console.Write("Digite a Razão Social: ");
        RazaoSocial = Console.ReadLine();

        Console.Write("Digite o Nome Fantasia: ");
        NomeFantasia = Console.ReadLine();
    }

    // Método para exibir informações do cliente PJ
    public override void ExibirInformacoes()
    {
        base.ExibirInformacoes(); // <-- Chamando o método da classe base para exibir informações comuns
        Console.WriteLine($"CNPJ: {CNPJ} - Razão Social: {RazaoSocial} - Nome Fantasia: {NomeFantasia}");
    }
}

public class ClientePF : Cliente // <-- Classe Derivada "filho" ClientePF
{
    // Propriedades específicas para clientes pessoa física (PF)
    public string CPF { get; set; }
    public string FormacaoAcademica { get; set; }

    // Implementação do método para cadastrar informações do cliente PF
    public override void Cadastrar()
    {
        Console.Write("Digite o ID: ");
        ID = Console.ReadLine();

        Console.Write("Digite o Nome: ");
        Nome = Console.ReadLine();

        Console.Write("Digite o Email: ");
        Email = Console.ReadLine();

        Console.Write("Digite o Telefone: ");
        Telefone = Console.ReadLine();

        Console.Write("Digite o CPF: ");
        CPF = Console.ReadLine();

        Console.Write("Digite a Formação Acadêmica: ");
        FormacaoAcademica = Console.ReadLine();
    }

    // Método para exibir informações do cliente PF
    public override void ExibirInformacoes()
    {
        base.ExibirInformacoes(); // <-- Chamando o método da classe base para exibir informações comuns
        Console.WriteLine($"CPF: {CPF} - Formação Acadêmica: {FormacaoAcademica}");
    }
}

Vamos destacar quais conceitos foram aprendidos e como eles foram aplicados no código:

1. Herança

Definição: Herança é um princípio da P.O.O. que permite que uma classe derivada (filho) herde atributos e métodos de outra classe base (pai), promovendo a reutilização de código.
Exemplo no código: public class ClientePJ : Cliente e public class ClientePF : Cliente. Aqui, ClientePJ e ClientePF herdam propriedades e métodos da classe Cliente, como ID, Nome, Email, e Telefone.

2. Polimorfismo

Definição: Polimorfismo permite que métodos em classes derivadas tenham diferentes implementações com a mesma assinatura de método na classe base, permitindo que o mesmo método se comporte de maneira diferente.
Exemplo no código: O método Cadastrar e ExibirInformacoes são sobrescritos (override) em ClientePJ e ClientePF para fornecer funcionalidades específicas para cada tipo de cliente. Por exemplo, Cadastrar em ClientePJ inclui a solicitação de CNPJ, enquanto em ClientePF inclui CPF.

3. Métodos Virtuais e Override

Definição: Métodos virtuais são métodos na classe base que podem ser sobrescritos nas classes derivadas usando a palavra-chave override, permitindo que a classe derivada forneça uma implementação específica.
Exemplo no código: public virtual void Cadastrar() na classe Cliente é um método virtual que é sobrescrito (override) nas classes ClientePJ e ClientePF com suas próprias implementações específicas.

Voltar para o início ↺

6. Revisão de P.O.O 4

Note

Retirado da aula de "RevisaoPOO4"

Nesta aula foram revisionados "Exceções":
- Conceito de exceções
- Uso de exceções para casos de erro por interação do usuário

internal class Program
{
    static void Main(string[] args)
    {
        bool continuar = true;

        while (continuar)
        {
            try // <-- Início do bloco 'try-catch' para capturar 'Exceções'
            {
                Console.Write("Digite o primeiro número: ");
                int num1 = Convert.ToInt32(Console.ReadLine());

                Console.Write("Digite o segundo número: ");
                int num2 = Convert.ToInt32(Console.ReadLine());

                int resultado = num1 / num2;

                Console.WriteLine($"\r\nResultado: {resultado}");
            }
            catch (DivideByZeroException) // <-- Exceção lançada quando ocorre uma tentativa de divisão por zero.
            {
                Console.WriteLine("\r\nErro: Divisão por zero não é permitida!");
            }
            catch (FormatException) // Exceção lançada quando a conversão de um tipo de dado para outro falha.
            {
                Console.WriteLine("\r\nErro: Entrada inválida. Por favor, insira um número inteiro!");
            }

            Console.Write("\r\nDeseja realizar outra operação? (s/n): ");
            string resposta = Console.ReadLine().ToLower();
            Console.WriteLine("\r\n---------------------------------------------\r\n");

            if (resposta != "s")
            {
                continuar = false;
            }
        }
        Console.WriteLine("Finalizando a aplicação...");

        Console.ReadKey();
    }
}

Vamos destacar quais conceitos foram aprendidos e como eles foram aplicados no código:

1. Exceções

Definição: Exceções são eventos que ocorrem durante a execução de um programa e que interrompem o fluxo normal de instruções, se não forem tratadas. Elas são usadas para indicar e tratar erros.
Exemplo no código: No bloco try-catch, foram capturadas exceções específicas, como DivideByZeroException e FormatException, para lidar com erros de divisão por zero e de formato de entrada inválido, respectivamente.

2. DivideByZeroException

Definição: Uma exceção lançada quando ocorre uma tentativa de dividir um número por zero.
Exemplo no código: catch (DivideByZeroException). Isso captura a exceção e exibe uma mensagem de erro informando que a divisão por zero não é permitida.

3. FormatException

Definição: Uma exceção lançada quando uma tentativa de conversão de um tipo de dado para outro falha.
Exemplo no código: catch (FormatException). Isso captura a exceção e exibe uma mensagem de erro informando que a entrada foi inválida e solicitando que seja inserido um número inteiro.

Voltar para o início ↺

➕ EXTRA
A partir deste ponto, é apresentado um "conteúdo extra". Este material adicional complementa o aprendizado de P.O.O juntamente com práticas sobre Banco de Dados, fazendo uma conexão com MySQL.

7. Conexão com MySQL em P.O.O

Note

Retirado da aula de "Conexao_com_SQL_(POO)"
Link do conteúdo sobre Conexão com MySQL em PDF: Conexao_com_MySql.pdf

Nesta aula foram aprendidos:
- Instalação do Pacote NuGet
- Uso do MySQL Workbench
- Criação do Banco de Dados para um Gerenciamento de Alunos
- Conexão e Manipulação de Dados com MySQL em CSharp

Instalação do Pacote NuGet

Para conectar um projeto em C# ao MySQL, é necessário instalar o pacote MySql.Data via NuGet, que contém as bibliotecas necessárias para a comunicação entre a aplicação C# e o banco de dados MySQL.

Passos para instalar o pacote MySql.Data no Visual Studio

Abrir o Gerenciador de Soluções:
- No menu superior do Visual Studio, clique em Exibir > Gerenciador de Soluções.
Acessar os Pacotes NuGet:
- Clique com o botão direito sobre o nome do seu projeto e selecione Gerenciar Pacotes do NuGet.
Buscar o Pacote MySql.Data:
- Na aba Procurar, digite MySql.Data na barra de busca.
Selecionar e Instalar o Pacote:
- Escolha a versão desejada do pacote e clique em Instalar.
Finalizar a Instalação:
- O pacote será adicionado ao projeto, permitindo o uso das classes e métodos necessários para a conexão com MySQL.

Uso do MySQL Workbench

O MySQL Workbench é uma ferramenta gráfica de modelação, gerenciamento e administração de bancos de dados MySQL. Além de criar e modificar esquemas de banco de dados, ele também permite executar consultas SQL e visualizar resultados de maneira interativa. E é com esta ferramenta que criaremos o nosso banco de dados.

Passos para instalar o MySQL Workbench

Baixar o MySQL Workbench:
- Acesse a página oficial de downloads do MySQL: Download MySQL Workbench.
- Selecione a versão adequada para o seu sistema operacional (Windows, macOS, Linux).
Instalar o MySQL Workbench:
- Execute o arquivo baixado e siga as instruções do instalador.
- No Windows, é recomendado instalar o MySQL Workbench juntamente com o MySQL Installer, que facilita a instalação de outros componentes necessários.
Configuração Inicial:
- Após a instalação, abra o MySQL Workbench.
- Configure a conexão com o servidor MySQL, utilizando as credenciais fornecidas durante a instalação do MySQL Server.

Tip

Caso tenha dificuldade durante o processo, este vídeo tutorial pode ajudar a configurar e conectar o MySQL Workbench pela primeira vez.

Criando um banco de dados com o MySQL Workbench

Com o MySQL Workbench instalado e configurado, podemos agora criar o nosso banco de dados.

Passos para criar um banco de dados no MySQL Workbench:

Abrir o MySQL Workbench.
Conectar-se ao servidor MySQL:
- Use as credenciais configuradas (nome de usuário e senha) para acessar o servidor.
Criar um novo banco de dados:
- Na barra de menus, vá para Database e selecione Create New Database....
- Defina um nome para o banco de dados e clique em Apply.
Criar tabelas e definir colunas:
- Na aba Schemas, clique com o botão direito no banco de dados recém-criado e selecione Create Table....
- Adicione as colunas, defina os tipos de dados, e configure restrições.
- Clique em Apply para salvar as alterações.

Criando o banco de dados em SQL

-- Criação do banco de dados
CREATE DATABASE BancoDeDadosAlunos;

USE BancoDeDadosAlunos;

-- Criação da tabela Alunos
CREATE TABLE Alunos (
    IdAluno INT PRIMARY KEY AUTO_INCREMENT,  -- Coluna para o ID único do Aluno
    Nome VARCHAR(100),                       -- Coluna para o Nome do Aluno
    CPF VARCHAR(11),                         -- Coluna para o CPF do Aluno
    Email VARCHAR(100),                      -- Coluna para o Email do Aluno
    Telefone VARCHAR(20),                    -- Coluna para o Telefone do Aluno
    DataNascimento DATE                      -- Coluna para a Data de Nascimento do Aluno
);

SELECT * FROM Alunos;

Criando o algoritmo de banco de dados em CSharp

namespace Conexao_com_SQL__POO_.Models
{
    internal class Aluno
    {
        public int IdAluno { get; set; }
        public string Nome { get; set; }
        public string CPF { get; set; }
        public string Email { get; set; }
        public string Telefone { get; set; }
        public DateTime DataNascimento { get; set; }
    }
}

using MySql.Data.MySqlClient; // <-- Importa a biblioteca necessária para trabalhar com MySQL

namespace Conexao_com_SQL__POO_
{
    public static class Conexao
    {
        static MySqlConnection conexao; // <-- Objeto responsável por controlar a conexão com a base
        public static MySqlConnection Conectar()
        {
            try
            {
                // Texto-string de conexão com o banco de dados
                string connectionString = "server=localhost;port=3306;uid=root;pwd=sua_senha_aqui;database=nome_do_seu_banco_de_dados_aqui";
                conexao = new MySqlConnection(connectionString);
                conexao.Open();
            }
            catch (Exception ex)
            {
                Console.WriteLine("\r\nErro ao realizar a conexão com a base de dados!");
            }
            return conexao;
        }

        // Método para fechar a conexão com o banco de dados
        public static void FecharConexao()
        {
            conexao.Close();
        }
    }
}

using MySql.Data.MySqlClient; // <-- Importa a biblioteca necessária para trabalhar com MySQL
using System;
using System.Collections.Generic;
using Conexao_com_SQL__POO_.Models;

namespace Conexao_com_SQL__POO_.DAO
{
    internal class AlunoDAO
    {
        // Método para inserir um novo aluno no banco de dados
        public void Insert(Aluno aluno)
        {
            try
            {
                // Converte a data de nascimento do aluno para o formato "yyyy-MM-dd"
                string dataNascimento = aluno.DataNascimento.ToString("yyyy-MM-dd");

                // SQL para INSERIR um novo aluno na tabela "alunos"
                string sql = "INSERT INTO alunos(nome_alu, cpf_alu, email_alu, telefone_alu, data_nascimento_alu) " +
                             "VALUES(@nome, @cpf, @email, @telefone, @dataNascimento)";

                MySqlCommand comando = new MySqlCommand(sql, Conexao.Conectar()); // <-- Cria um comando MySQL para executar a instrução SQL

                // Adiciona os parâmetros ao comando, substituindo os placeholders na SQL
                comando.Parameters.AddWithValue("@nome", aluno.Nome);
                comando.Parameters.AddWithValue("@cpf", aluno.CPF);
                comando.Parameters.AddWithValue("@email", aluno.Email);
                comando.Parameters.AddWithValue("@telefone", aluno.Telefone);
                comando.Parameters.AddWithValue("@dataNascimento", aluno.DataNascimento);
                comando.ExecuteNonQuery(); // <-- Executa o comando de inserção no banco de dados

                Console.WriteLine("\r\nAluno cadastrado com sucesso!");
                Conexao.FecharConexao(); // <-- Fecha a conexão com o banco de dados
            }
            catch (Exception ex)
            {
                throw new Exception($"Erro ao cadastrar o aluno! {ex.Message}");
            }
        }

        // Método para deletar um aluno do banco de dados com base no ID
        public void Delete(Aluno aluno)
        {
            try
            {
                // SQL para DELETAR um aluno da tabela "alunos" com base no ID
                string sql = "DELETE FROM alunos WHERE id_alu = @id_aluno";
                MySqlCommand comando = new MySqlCommand(sql, Conexao.Conectar());

                comando.Parameters.AddWithValue("@id_aluno", aluno.IdAluno);
                comando.ExecuteNonQuery();

                Console.WriteLine("\r\nAluno excluído com sucesso!");
                Conexao.FecharConexao();
            }
            catch (Exception ex)
            {
                throw new Exception($"\r\nErro ao excluir o aluno! {ex.Message}");
            }
        }

        // Método para atualizar os dados de um aluno no banco de dados
        public void Update(Aluno aluno)
        {
            try
            {
                // SQL para ATUALIZAR os dados do aluno na tabela "alunos"
                string sql = "UPDATE alunos SET nome_alu = @nome, cpf_alu = @cpf, email_alu = @email, " +
                             "telefone_alu = @telefone WHERE id_alu = @id_aluno";
                MySqlCommand comando = new MySqlCommand(sql, Conexao.Conectar());

                comando.Parameters.AddWithValue("@nome", aluno.Nome);
                comando.Parameters.AddWithValue("@cpf", aluno.CPF);
                comando.Parameters.AddWithValue("@email", aluno.Email);
                comando.Parameters.AddWithValue("@telefone", aluno.Telefone);
                comando.Parameters.AddWithValue("@id_aluno", aluno.IdAluno);
                comando.ExecuteNonQuery();

                Console.WriteLine("\r\nAluno atualizado com sucesso!");
                Conexao.FecharConexao();
            }
            catch (Exception ex)
            {
                throw new Exception($"\r\nErro ao atualizar o aluno! {ex.Message}");
            }
        }

        // Método para listar todos os alunos cadastrados no banco de dados
        public List<Aluno> List()
        {
            List<Aluno> alunos = new List<Aluno>(); // <-- Cria uma lista para armazenar os alunos
            try
            {
                // SQL para SELECIONAR todos os alunos da tabela "alunos", ordenados por nome
                var sql = "SELECT * FROM alunos ORDER BY nome_alu";
                MySqlCommand comando = new MySqlCommand(sql, Conexao.Conectar());

                // Executa o comando e obtém os dados retornados pelo banco
                using (MySqlDataReader dr = comando.ExecuteReader())
                {
                    while (dr.Read()) // <-- Itera sobre os dados retornados e cria objetos Aluno para cada linha
                    {
                        Aluno aluno = new Aluno
                        {
                            IdAluno = dr.GetInt32("id_alu"), // <-- Atribui o ID do aluno
                            Nome = dr.GetString("nome_alu"), // <-- Atribui o Nome do aluno
                            Email = dr.GetString("email_alu"), // <-- Atribui o Email do aluno
                            CPF = dr.GetString("cpf_alu"), // <-- Atribui o CPF do aluno
                            Telefone = dr.GetString("telefone_alu"), // <-- Atribui o Telefone do aluno
                            DataNascimento = dr.GetDateTime("data_nascimento_alu") // <-- Atribui a Data de Nascimento do aluno
                        };
                        alunos.Add(aluno);
                    }
                }
                Conexao.FecharConexao();
            }
            catch (Exception ex)
            {
                throw new Exception($"\r\nErro ao listar os alunos! {ex.Message}");
            }
            return alunos;
        }
    }
}

Vamos destacar quais conceitos foram aprendidos e como eles foram aplicados no código:

1. Instalação do Pacote NuGet

Definição: Permite adicionar bibliotecas externas ao projeto C# que são necessárias para funcionalidades específicas, como a conexão com o MySQL.
Exemplo no código: A instalação do pacote MySql.Data foi fundamental para usar as classes e métodos de conexão com o MySQL.

2. Criação da Classe `Conexao`

Definição: A classe Conexao foi criada para gerenciar a conexão entre a aplicação e o banco de dados MySQL, facilitando a abertura e o fechamento de conexões de forma organizada e segura.
Exemplo no código: A classe Conexao encapsula a lógica de conexão com o banco de dados, utilizando o objeto MySqlConnection para abrir e fechar a conexão sempre que necessário, garantindo que a comunicação com o banco seja feita de forma eficiente e evitando problemas de conexão persistente.

3. Padrão DAO (Data Access Object)

Definição: O Padrão DAO é um padrão de design que separa a lógica de acesso ao banco de dados das regras de negócio, organizando as operações de CRUD (Create, Read, Update, Delete) em classes específicas.
Exemplo no código: No projeto, foi implementada uma classe DAO para gerenciar as operações de inserção, deleção, atualização e listagem de usuários. Isso inclui métodos como InserirUsuario(), DeletarUsuario(), AtualizarUsuario() e ListarUsuarios(), que interagem diretamente com o banco de dados, mantendo o código limpo e modular.

4. Uso do MySQL Workbench

Definição: O MySQL Workbench é uma ferramenta gráfica de modelagem, gerenciamento e administração de bancos de dados MySQL. Além de criar e modificar esquemas de banco de dados, ele também permite executar consultas SQL e visualizar resultados de maneira interativa.
Exemplo no código: Utilizamos o MySQL Workbench para criar o banco de dados BancoDeDadosAlunos e a tabela Alunos, que são fundamentais para o funcionamento do sistema de gerenciamento de usuários.

5. Conexão com MySQL

Definição: Estabelecer uma conexão entre a aplicação C# e o banco de dados MySQL, permitindo a execução de comandos SQL e manipulação de dados.
Exemplo no código: O uso da classe MySqlConnection para conectar ao banco de dados e MySqlCommand para executar uma consulta SQL que lista todos os alunos cadastrados.

6. Manipulação de Dados com MySQL em C#

Definição: A execução de comandos SQL diretamente a partir do código C#, permitindo que a aplicação interaja com o banco de dados para criar, ler, atualizar e deletar dados.
Exemplo no código: O método ListarUsuarios() no DAO executa o comando SQL SELECT * FROM Usuarios para recuperar todos os registros da tabela Usuarios e exibi-los na aplicação.

Voltar para o início ↺

👤 Autor

_{Júlio Cézar | Juletopi}

_{LinkedIn - Júlio Cézar P. Camargo}
_{Email - juliocezarpvh@hotmail.com}
_{Whatsapp - +55 (69) 9 9360-6894}
_{Instagram - @juletopi}

Voltar para o início ↺

Feito com 💜 por Juletopi.

Name		Name	Last commit message	Last commit date
Latest commit History 57 Commits
Assets		Assets
Banco_de_Dados_(POO)		Banco_de_Dados_(POO)
Cadastro_de_Alunos_(POO)		Cadastro_de_Alunos_(POO)
Conexao_com_SQL_(POO)		Conexao_com_SQL_(POO)
Exercicio_01		Exercicio_01
Exercicio_02		Exercicio_02
Exercicio_03		Exercicio_03
Exercicio_04		Exercicio_04
Exercicio_05		Exercicio_05
Prova_de_Nivelamento_(POO)		Prova_de_Nivelamento_(POO)
RevisaoPOO		RevisaoPOO
RevisaoPOO2		RevisaoPOO2
RevisaoPOO3		RevisaoPOO3
RevisaoPOO4		RevisaoPOO4
Software_de_Gerenciamento_(POO)		Software_de_Gerenciamento_(POO)
LICENSE		LICENSE
README.md		README.md

License

juletopi/POO_Programacao_Orientada_a_Objetos

Folders and files

Latest commit

History

Repository files navigation

Programação Orientada a Objetos 🧩

Sumário 🧾

👨‍🏫 Professor:

🌟 Programação Orientada a Objetos (P.O.O)

❓ O que é isso?

📋 Principais Conceitos

📚 Conceitos Aprendidos:

1. Classes, Objetos e Métodos

2. Listas e Classes

⚠️ AVISO

3. Revisão de P.O.O 1

1. Classes

2. Objetos

3. Atributos

4. Métodos

5. Métodos Construtores

6. Encapsulamento (Get e Set)

4. Revisão de P.O.O 2

1. Listas

2. LINQ (Language Integrated Query)

3. Entrada e Saída de Dados

5. Revisão de P.O.O 3

1. Herança

2. Polimorfismo

3. Métodos Virtuais e Override

6. Revisão de P.O.O 4

1. Exceções

2. DivideByZeroException

3. FormatException

➕ EXTRA

7. Conexão com MySQL em P.O.O

Instalação do Pacote NuGet

Passos para instalar o pacote MySql.Data no Visual Studio

Uso do MySQL Workbench

Passos para instalar o MySQL Workbench

Criando um banco de dados com o MySQL Workbench

Passos para criar um banco de dados no MySQL Workbench:

Criando o banco de dados em SQL

Criando o algoritmo de banco de dados em CSharp

1. Instalação do Pacote NuGet

2. Criação da Classe Conexao

3. Padrão DAO (Data Access Object)

4. Uso do MySQL Workbench

5. Conexão com MySQL

6. Manipulação de Dados com MySQL em C#

👤 Autor

About

Topics

Resources

License

Stars

Watchers

Forks

Languages

2. Criação da Classe `Conexao`