https://github.com/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.
https://github.com/juletopi/poo_programacao_orientada_a_objetos
abstraction back-end backend classes csharp encapsulation inheritance methods object-oriented-programming objects polymorphism programacao-orientada-objetos visual-studio
Last synced: about 1 year ago
JSON representation
🧩 • 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.
- Host: GitHub
- URL: https://github.com/juletopi/poo_programacao_orientada_a_objetos
- Owner: juletopi
- License: mit
- Created: 2024-02-08T23:32:42.000Z (over 2 years ago)
- Default Branch: main
- Last Pushed: 2024-09-04T22:35:24.000Z (almost 2 years ago)
- Last Synced: 2025-05-17T16:14:59.365Z (about 1 year ago)
- Topics: abstraction, back-end, backend, classes, csharp, encapsulation, inheritance, methods, object-oriented-programming, objects, polymorphism, programacao-orientada-objetos, visual-studio
- Language: C#
- Homepage: https://github.com/Elias-abreu
- Size: 7.57 MB
- Stars: 2
- Watchers: 1
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
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**](https://www.linkedin.com/in/elias-de-abreu-domingos-da-silva-843748262/), 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
[![Readme Quotes](https://quotes-github-readme.vercel.app/api?type=horizontal&theme=dracula"e=Programa%C3%A7%C3%A3o%20Orientada%20a%20Objetos%20%C3%A9%20como%20uma%20caixa%20de%20ferramentas%2C%20onde%20cada%20objeto%20%C3%A9%20uma%20ferramenta%20especializada%2C%20pronta%20para%20ser%20usada%20na%20constru%C3%A7%C3%A3o%20de%20um%20grande%20projeto.&author=Autor%20Desconhecido)](https://github.com/piyushsuthar/github-readme-quotes)
## 👨🏫 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á**](https://portal.ifro.edu.br/ji-parana) • Atuando desde Dezembro de 2017 \
Linguagens & Tecnologias: `Visual Studio` • `MySQL` • `C#` • `PHP` • `Java` • `E outros...` \
Contato: **[Elias de Abreu (LinkedIn)](https://www.linkedin.com/in/elias-de-abreu-domingos-da-silva-843748262/)**
## 🌟 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.
## 📚 Conceitos Aprendidos:
### 1. Classes, Objetos e Métodos
> [!NOTE]\
> *Retirado da aula de "[Software_de_Gerenciamento_(POO)](https://github.com/juletopi/POO_Programacao_Orientada_a_Objetos/blob/main/Software_de_Gerenciamento_(POO)/Program.cs)"*
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
```c#
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();
}
```
### 2. Listas e Classes
> [!NOTE]\
> *Retirado da aula de "[Cadastro_de_Alunos_(POO)](https://github.com/juletopi/POO_Programacao_Orientada_a_Objetos/blob/main/Cadastro_de_Alunos_(POO)/Program.cs)"*
Nesta aula foram aprendidos:
- Implementação de listas simples na criação de classes, objetos e atributos
```c#
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 alunos = new List(); // <-- 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();
}
```
| ⚠️ 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](https://github.com/juletopi/POO_Programacao_Orientada_a_Objetos/tree/main/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)
```c#
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.
### 4. Revisão de P.O.O 2
> [!NOTE]\
> *Retirado da aula de "[RevisaoPOO2](https://github.com/juletopi/POO_Programacao_Orientada_a_Objetos/tree/main/RevisaoPOO2)"*
- Nesta aula foram revisionados "Listas":
- Criação de listas
- Manipulação de listas
- Exibição dos resultados destas listas
```c#
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 listAlunos = new List();
// 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 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 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 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 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 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.
### 5. Revisão de P.O.O 3
> [!NOTE]\
> *Retirado da aula de "[RevisaoPOO3](https://github.com/juletopi/POO_Programacao_Orientada_a_Objetos/tree/main/RevisaoPOO3)"*
- Nesta aula foram revisionados "Heranças":
- Criação de heranças (Classes "pai" e classes "filho")
- Polimorfismo
- Métodos Virtuais e Override
```c#
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.
### 6. Revisão de P.O.O 4
> [!NOTE]\
> *Retirado da aula de "[RevisaoPOO4](https://github.com/juletopi/POO_Programacao_Orientada_a_Objetos/tree/main/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
```c#
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.
| ➕ 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)](https://github.com/juletopi/POO_Programacao_Orientada_a_Objetos/tree/main/Conexao_com_SQL_(POO))"* \
> *Link do conteúdo sobre Conexão com MySQL em PDF: [Conexao_com_MySql.pdf](https://drive.google.com/file/d/1aLVD5gR8ZK7RJbayshn9ENLBc25Z1Spt/view?usp=sharing)*
- 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**
1. **Abrir o Gerenciador de Soluções**:
- No menu superior do Visual Studio, clique em `Exibir > Gerenciador de Soluções`.
2. **Acessar os Pacotes NuGet**:
- Clique com o botão direito sobre o nome do seu projeto e selecione `Gerenciar Pacotes do NuGet`.
3. **Buscar o Pacote MySql.Data**:
- Na aba `Procurar`, digite `MySql.Data` na barra de busca.
4. **Selecionar e Instalar o Pacote**:
- Escolha a versão desejada do pacote e clique em `Instalar`.
5. **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**
1. **Baixar o MySQL Workbench**:
- Acesse a página oficial de downloads do MySQL: [Download MySQL Workbench](https://dev.mysql.com/downloads/workbench/).
- Selecione a versão adequada para o seu sistema operacional (Windows, macOS, Linux).
2. **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.
3. **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](https://www.youtube.com/watch?v=IEUgVwjXF0o) 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**:
1. **Abrir o MySQL Workbench**.
3. **Conectar-se ao servidor MySQL**:
- Use as credenciais configuradas (nome de usuário e senha) para acessar o servidor.
4. **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`.
5. **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**
```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**
```c#
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 List()
{
List alunos = new List(); // <-- 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.
## 👤 Autor
-
LinkedIn - Júlio Cézar P. Camargo
-
Email - juliocezarpvh@hotmail.com
-
Whatsapp - +55 (69) 9 9360-6894
-
Instagram - @juletopi
----
