.jpg)
Seja muito bem-vindo à Academy Code Christ!
⚙️ TRILHA C Sharp Etapa 08
Avançando em POO: Propriedades, Construtores
%20-%20Copia.png)
.png)
💻 Pratique o que você aprende
.png)
Muitos desenvolvedores param apenas nos fundamentos da POO e acabam criando códigos “travados” ou mal aproveitados.
A partir deste ponto, vamos preparar
você para escrever código limpo, reaproveitável e eficiente — o tipo de código
que forma a base de qualquer aplicação profissional em C#.
Revisando a Base: Objeto = Dados + Comportamento
Cada objeto na POO tem:
● dados (atributos ou propriedades), que formam seu estado;
● comportamentos (métodos), que permitem interagir com esse estado.
Por exemplo:
class Conta
{
public string Titular { get; set; }
public double Saldo { get; private set; }
public void Depositar(double valor) => Saldo += valor;
public void Sacar(double valor)
{
if (valor <= Saldo)
Saldo -= valor;
else
Console.WriteLine("Saldo insuficiente!");
}
}
✳️ A propriedade Saldo é controlada, garantindo que apenas os métodos da classe possam alterá-la.
Propriedades Completas com Lógica Interna
As propriedades podem ter blocos de código nos get e set, permitindo incluir validação e comportamento automático.
class Produto
{
private double preco;
public double Preco
{
get { return preco; }
set
{
if (value < 0)
Console.WriteLine("Erro: preço inválido!");
else
preco = value;
}
}
}
Uso:
Produto p = new Produto();
p.Preco = -5; // mensagem de erro
p.Preco = 100; // valor aceito
Console.WriteLine("Preço definido: R$" + p.Preco);
💡 Boas práticas: sempre valide dados sensíveis através das propriedades.
Sobrecarga de Construtores (Construtores Múltiplos)
Em situações reais, você pode querer criar objetos de maneiras diferentes.
Por exemplo:
class Pessoa
{
public string Nome { get; set; }
public int Idade { get; set; }
// Construtor padrão
public Pessoa()
{
Nome = "Desconhecido";
Idade = 0;
}
// Construtor personalizado
public Pessoa(string nome)
{
Nome = nome;
Idade = 0;
}
// Construtor completo
public Pessoa(string nome, int idade)
{
Nome = nome;
Idade = idade;
}
public void Exibir()
{
Console.WriteLine($"{Nome}, {Idade} anos");
}
}
Uso:
Pessoa p1 = new Pessoa();
Pessoa p2 = new Pessoa("Ana");
Pessoa p3 = new Pessoa("Carlos", 30);
p1.Exibir();
p2.Exibir();
p3.Exibir();
🔹 O mesmo nome (Pessoa) com parâmetros diferentes é chamado de sobrecarga de construtores.
Encadeamento de Construtores (this)
Para evitar repetição de código nos construtores, podemos encadear um construtor ao outro usando a palavra this.
class Retangulo
{
public double Largura { get; set; }
public double Altura { get; set; }
public Retangulo() : this(1, 1) { } // padrão 1x1
public Retangulo(double largura, double altura)
{
Largura = largura;
Altura = altura;
}
public double CalcularArea() => Largura * Altura;
}
Uso:
Retangulo r1 = new Retangulo();
Retangulo r2 = new Retangulo(5, 10);
Console.WriteLine("Área 1: " + r1.CalcularArea());
Console.WriteLine("Área 2: " + r2.CalcularArea());
✨ Assim, Retangulo() reutiliza o código do outro construtor automaticamente.
Herança em Profundidade
Todas as classes em C# herdam, direta ou indiretamente, da classe object, a mãe de todas as classes.
Você pode estender heranças em vários níveis:
class Pessoa
{
public string Nome { get; set; }
public virtual void Apresentar()
{
Console.WriteLine($"Meu nome é {Nome}.");
}
}
class Aluno : Pessoa
{
public int Matricula { get; set; }
public override void Apresentar()
{
Console.WriteLine($"Sou o aluno {Nome}, matrícula {Matricula}.");
}
}
class Bolsista : Aluno
{
public double Desconto { get; set; }
public override void Apresentar()
{
Console.WriteLine($"Sou o bolsista {Nome}, desconto de {Desconto}%.");
}
}
Uso:
Pessoa p = new Pessoa { Nome = "João" };
Aluno a = new Aluno { Nome = "Ana", Matricula = 123 };
Bolsista b = new Bolsista { Nome = "Pedro", Matricula = 456, Desconto = 50 };
p.Apresentar();
a.Apresentar();
b.Apresentar();
🔹 Cada nível herda e personaliza o comportamento do anterior.
Chamando Construtores da Classe Base (base)
Ao herdar, podemos usar o base para chamar o construtor da classe-mãe.
class Pessoa
{
public string Nome { get; set; }
public Pessoa(string nome)
{
Nome = nome;
}
}
class Professor : Pessoa
{
public string Disciplina { get; set; }
public Professor(string nome, string disciplina) : base(nome)
{
Disciplina = disciplina;
}
public void Ensinar()
{
Console.WriteLine($"{Nome} está ensinando {Disciplina}.");
}
}
Uso:
Professor prof = new Professor("Marina", "Matemática");
prof.Ensinar();
📘 base(nome) garante que o construtor da classe Pessoa seja chamado primeiro.
Sobrescrita e Ocultação de Métodos
Em C#, podemos sobrescrever (comportamento diferente) ou ocultar (esconder método da classe base).
🔹 Sobrescrita (override)
Usa-se quando queremos modificar o comportamento de um método herdado.
class Animal
{
public virtual void Falar() => Console.WriteLine("Som genérico");
}
class Cachorro : Animal
{
public override void Falar() => Console.WriteLine("Au au!");
}
🔹 Ocultação (new)
Usada quando queremos criar um novo método com o mesmo nome, sem sobrescrever o anterior.
class Gato : Animal
{
public new void Falar() => Console.WriteLine("Miau!");
}
Diferença prática:
Animal animal = new Gato();
animal.Falar(); // "Som genérico" (pois escondido, não sobrescrito)
Gato gato = new Gato();
gato.Falar(); // "Miau!"
Classes Seladas (sealed)
Se você quiser impedir que uma classe seja herdada, use o modificador sealed.
sealed class Diretor
{
public void Coordenar()
{
Console.WriteLine("Coordenando todas as turmas.");
}
}
🚫 Qualquer tentativa de herdar Diretor resultará em erro de compilação.
Métodos e Classes Abstratas (em profundidade)
Classes abstratas não podem ser instanciadas diretamente
— elas servem como modelos-base.
Mas podem conter métodos concretos e
abstratos.
abstract class Veiculo
{
public virtual void LigarMotor() => Console.WriteLine("Motor ligado.");
public abstract void Mover(); // deve ser implementado nas classes-filhas
}
class Carro : Veiculo
{
public override void Mover()
{
Console.WriteLine("O carro está se movendo.");
}
}
class Bicicleta : Veiculo
{
public override void Mover()
{
Console.WriteLine("A bicicleta está pedalando.");
}
}
Uso:
Veiculo v1 = new Carro();
Veiculo v2 = new Bicicleta();
v1.LigarMotor();
v1.Mover();
v2.LigarMotor();
v2.Mover();
Interfaces Avançadas
Uma classe pode implementar várias interfaces ao mesmo tempo, algo que não é possível com herança de classes.
interface ICarregavel
{
void Carregar(int porcentagem);
}
interface IConectavel
{
void Conectar(string rede);
}
class Smartphone : ICarregavel, IConectavel
{
public void Carregar(int porcentagem)
{
Console.WriteLine($"Carregando... {porcentagem}%");
}
public void Conectar(string rede)
{
Console.WriteLine($"Conectado à rede: {rede}");
}
}
Uso:
Smartphone iphone = new Smartphone();
iphone.Carregar(80);
iphone.Conectar("Wi-Fi Casa");
✨ Interfaces fornecem flexibilidade máxima na programação de classes complexas.
Exercício Prático: Sistema de Funcionários (Abstração + Herança + Polimorfismo)
using System;
abstract class Funcionario
{
public string Nome { get; set; }
public abstract double CalcularSalarioMensal();
}
class Gerente : Funcionario
{
public double SalarioFixo { get; set; }
public double Bonus { get; set; }
public override double CalcularSalarioMensal() => SalarioFixo + Bonus;
}
class Vendedor : Funcionario
{
public double Vendas { get; set; }
public override double CalcularSalarioMensal() => 1200 + (Vendas * 0.05);
}
Uso:
Funcionario f1 = new Gerente { Nome = "Laura", SalarioFixo = 5000, Bonus = 1000 };
Funcionario f2 = new Vendedor { Nome = "Rafael", Vendas = 15000 };
Console.WriteLine($"{f1.Nome} - Salário: R${f1.CalcularSalarioMensal()}");
Console.WriteLine($"{f2.Nome} - Salário: R${f2.CalcularSalarioMensal()}");
🎯 Observe que, embora f1 e f2 tenham tipos diferentes, o método CalcularSalarioMensal() é chamado da forma específica de cada classe — isso é polimorfismo em ação.
Boas Práticas em POO Avançada
✔ Cada
classe deve ter um papel claro.
Não misture responsabilidades.
✔ Use o encapsulamento sempre para proteger os dados.
✔ Prefira interfaces quando quiser
flexibilidade.
✔ Use herança apenas quando
houver relação real entre as classes.
✔ Evite repetir código: use métodos
abstratos e sobrescrita.
✔ Documente: a clareza do
código é tão importante quanto sua execução.
Conclusão
Você acaba de dominar o nível avançado da POO — onde o C# mostra toda sua elegância e poder. 💎
Agora
você entende como:
✅ Usar propriedades completas
e protegidas
✅ Criar construtores sobrecarregados
e encadeados
✅ Aplicar herança em vários níveis
✅ Sobrescrever métodos com controle
total
✅ Criar sistemas polimórficos,
abstratos e flexíveis
Você está muito perto de construir sistemas reais, organizados e escaláveis.
.png)
.png)
Postar um comentário