• 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.
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 | AutorElias 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)
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.
-
🧩 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.
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();
}
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();
}
A partir deste ponto em diante, devido a greve das universidades federais em 2024, o conteúdo da disciplina será reestudado. |
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:
- 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 chamadaAluno
.
- 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 classeAluno
.
- Definição: Variáveis dentro de uma classe que armazenam dados.
- Exemplo no código:
public string nome;
,public DateTime dataNasc;
epublic int idade;
são atributos da classeAluno
.
- Definição: Funções dentro de uma classe que definem comportamentos dos objetos.
- Exemplo no código:
public void ExibirInformacoes()
é um método na classeAluno
.
- 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 classeAluno
.
- 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
eset
, mas a lógica de encapsulamento foi seguida com os atributos e métodos. - Exemplo no código:
public string nome;
,public DateTime dataNasc;
epublic int idade;
são acessados e modificados diretamente. Em um design mais robusto, você poderia usar propriedades para encapsular esses campos.
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:
- 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 classeAlunos
. Métodos comoAdd
,Find
,Where
,OrderBy
,Max
, eToList
são usados para manipular a lista, como adicionar elementos, buscar, filtrar, ordenar e encontrar o valor máximo.
- 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'.
- 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.
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:
- 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
epublic class ClientePF : Cliente
. Aqui,ClientePJ
eClientePF
herdam propriedades e métodos da classeCliente
, comoID
,Nome
,Email
, eTelefone
.
- 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
eExibirInformacoes
são sobrescritos (override
) emClientePJ
eClientePF
para fornecer funcionalidades específicas para cada tipo de cliente. Por exemplo,Cadastrar
emClientePJ
inclui a solicitação deCNPJ
, enquanto emClientePF
incluiCPF
.
- 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 classeCliente
é um método virtual que é sobrescrito (override
) nas classesClientePJ
eClientePF
com suas próprias implementações específicas.
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:
- 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, comoDivideByZeroException
eFormatException
, para lidar com erros de divisão por zero e de formato de entrada inválido, respectivamente.
- 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.
- 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.
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. |
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
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.
-
Abrir o Gerenciador de Soluções:
- No menu superior do Visual Studio, clique em
Exibir > Gerenciador de Soluções
.
- No menu superior do Visual Studio, clique em
-
Acessar os Pacotes NuGet:
- Clique com o botão direito sobre o nome do seu projeto e selecione
Gerenciar Pacotes do NuGet
.
- Clique com o botão direito sobre o nome do seu projeto e selecione
-
Buscar o Pacote MySql.Data:
- Na aba
Procurar
, digiteMySql.Data
na barra de busca.
- Na aba
-
Selecionar e Instalar o Pacote:
- Escolha a versão desejada do pacote e clique em
Instalar
.
- Escolha a versão desejada do pacote e clique em
-
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.
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.
-
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.
Com o MySQL Workbench instalado e configurado, podemos agora criar o nosso banco de dados.
-
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 selecioneCreate New Database...
. - Defina um nome para o banco de dados e clique em
Apply
.
- Na barra de menus, vá para
-
Criar tabelas e definir colunas:
- Na aba
Schemas
, clique com o botão direito no banco de dados recém-criado e selecioneCreate Table...
. - Adicione as colunas, defina os tipos de dados, e configure restrições.
- Clique em
Apply
para salvar as alterações.
- Na aba
-- 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;
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:
- 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.
- 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 objetoMySqlConnection
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.
- 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()
eListarUsuarios()
, que interagem diretamente com o banco de dados, mantendo o código limpo e modular.
- 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 tabelaAlunos
, que são fundamentais para o funcionamento do sistema de gerenciamento de usuários.
- 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 eMySqlCommand
para executar uma consulta SQL que lista todos os alunos cadastrados.
- 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 SQLSELECT * FROM Usuarios
para recuperar todos os registros da tabelaUsuarios
e exibi-los na aplicação.
|