Conceitos de POO em C#: Classes, Herança e Polimorfismo

Conceitos Fundamentais de Programação Orientada a Objetos em C#

A implementação define como algo é feito. O código é o conjunto de instruções que realiza essa tarefa.

O domínio é o espaço onde o problema reside.

Um objeto é uma construção de software que encapsula estado e comportamento.

Classes, Atributos e Comportamentos

Uma classe define os atributos e comportamentos comuns compartilhados por um tipo de objeto.

• Atributos são as características de uma classe.
• Comportamento é uma ação executada por um objeto.

Abstração

Abstração é o processo de simplificar um problema difícil. Para ser eficaz, ela deve tratar do caso geral e não de algo específico.

Encapsulamento

O objetivo do encapsulamento é que o programa não precise se preocupar com o funcionamento interno da classe, evitando assim a alteração direta de valores.

Sobrecarga de Métodos

A sobrecarga de métodos é útil quando você precisa executar a mesma ação em diferentes tipos de dados.

Atributos Estáticos

Um atributo estático permanece com um valor. Uma classe não precisa ser instanciada para utilizá-lo, e ela só pode conter membros estáticos.

Interfaces

Uma interface permite separar completamente o nome de um método da sua implementação. Ela não permite campos, nem mesmo estáticos, nem construtores.

public enum DificuldadeEnum { easy, normal, hard }

interface ICadastro
{
    void Salvar();
    void Incluir();
    void Excluir(bool geraLog);
    DataTable Consultar();
    void Alterar();
    double Soma(double v1, double v2);
}

Herança

A herança evita repetição de código em classes diferentes que possuem características comuns.

Exemplo: classe base Aluno e classe derivada AlunoPosGraduacao.

O modificador new public string nome apenas desativa o aviso quando alguma classe pai possui o mesmo atributo.

• virtual: quem herdar pode sobrescrever o método usando override.
• private: um método privado não pode ser virtual nem override.
• protected: pode ser acessado pela própria classe e por todas que a herdam.

Classes Abstratas

Uma classe abstrata não pode ser instanciada. Uma classe não abstrata que herde de uma abstrata deve implementar todos os seus métodos abstratos. Um método abstrato é, por natureza, um método virtual.

public abstract class Veiculo
{
    // Atributos
    public int QtdePortas { get; }   // somente leitura
    double capacidadeMaximaEmKg = 0;

    public virtual void Carregar(double peso) { }
    public virtual void Acelerar() { }
    public abstract double PagarPedagio();

    public override string ToString()
    {
        return "Descrição: " + descricao + Environment.NewLine +
               "Capacidade máxima: " + capacidadeMaximaEmKg + Environment.NewLine +
               "Capacidade carregada: " + capacidadeCarregadaemKg + Environment.NewLine +
               "Velocidade atual: " + velocidadeAtualEmKM + Environment.NewLine;
    }
}

class Moto : Veiculo
{
    public void Empinar()
    {
        Console.WriteLine("Empinando...");
    }

    public override string ToString()
    {
        return base.ToString() + Environment.NewLine +
               "Cilindradas: " + cilindradas;
    }

    public override double PagarPedagio()
    {
        return 2;
    }
}

public interface IDadosAdicionais
{
    int VelocidadeLimpador { get; set; }
    void AbrirPorta();
    void AcionarLimpador();
}

public class Carro : Veiculo, IDadosAdicionais
{
    public override string ToString()
    {
        return base.ToString() + Environment.NewLine +
               "Qtde de portas: " + QtdePortas + Environment.NewLine +
               "Utiliza Reboque: " + (UtilizaReboque == true ? "Sim" : "Não"); // if ternário
    }

    public void AbrirPorta()
    {
        Console.WriteLine(Descricao + ": RUEEEERR");
    }

    public void AcionarLimpador()
    {
        if (velocidadeLimpador == 1)
            Console.WriteLine(Descricao + ": TU.... TU.... TU....");
        else
            Console.WriteLine(Descricao + ": TU. TU. TU.");
    }

    private int velocidadeLimpador;
    public int VelocidadeLimpador
    {
        get { return velocidadeLimpador; }
        set { velocidadeLimpador = value; }
    }
}

Polimorfismo

Polimorfismo é a habilidade pela qual uma única operação ou nome de um atributo pode ser definido em mais de uma classe e assumir implementações diferentes em cada uma dessas classes.

Dynamic binding é a técnica em que a exata linha de código é determinada somente em tempo de execução (run-time).

• Overriding é a redefinição de um método definido em uma classe C em uma das suas subclasses.
• Overloading de um nome ou símbolo ocorre quando diversas operações definidas na mesma classe têm esse mesmo nome ou símbolo; dizemos então que o nome/símbolo está sobrecarregado.

Exceções Personalizadas

É possível criar exceções próprias herdando de Exception:

public class CapacidadeMaximaExcedidaException : Exception { }

// Lançando a exceção
throw new CapacidadeMaximaExcedidaException();
throw new CapacidadeMaximaExcedidaException(excedido);

Exemplo Prático: Classe Caminhão e Interface Gráfica

class Caminhao : Veiculo, IDadosAdicionais
{
    public override string ToString()
    {
        return base.ToString() + Environment.NewLine +
               "Quantidade de eixos: " + QuantidadeEixos;
    }
}

// Listagem de veículos conforme a opção selecionada
List<Veiculo> lista = new List<Veiculo>();
Veiculo pesquisado = null;

if (cbOpcoes.SelectedIndex == -1)
{
    MessageBox.Show("Selecione um tipo de visualização.");
    return;
}

txtOutput.Clear();
foreach (Veiculo v in lista)
{
    bool faz = false;

    if (cbOpcoes.SelectedIndex == 0)
        faz = true;
    else if (cbOpcoes.SelectedIndex == 1 && v is Carro)
        faz = true;
    else if (cbOpcoes.SelectedIndex == 2 && v is Moto)
        faz = true;
    else if (cbOpcoes.SelectedIndex == 3 && v is Caminhao)
        faz = true;

    if (faz)
        txtOutput.Text += v.ToString() + Environment.NewLine + Environment.NewLine;
}

// Pesquisa por descrição
pesquisado = null;
foreach (Veiculo v in lista)
{
    if (v.Descricao.Trim().Equals(txtPesqVeiculo.Text.Trim()))
    {
        pesquisado = v;
        break;
    }
}

if (pesquisado == null)
    MessageBox.Show("Não encontrado!");
else
{
    txtOutput.Clear();
    txtOutput.Text = pesquisado.ToString();
}

// Empinar (somente motos)
if (pesquisado == null)
    MessageBox.Show("Pesquise primeiro!");
else if (pesquisado is Moto)
    (pesquisado as Moto).Empinar();
else
    MessageBox.Show("Não é moto!");

// Descarregar (somente caminhões)
if (pesquisado == null)
    MessageBox.Show("Pesquise primeiro!");
else if (pesquisado is Caminhao)
    (pesquisado as Caminhao).Descarregar();
else
    MessageBox.Show("Não é caminhão!");

// Abrir porta de todos os veículos que implementam a interface
foreach (Veiculo v in lista)
{
    if (v is IDadosAdicionais) // se o veículo implementar a interface...
    {
        (v as IDadosAdicionais).AbrirPorta();
    }
}

// Acionar limpador de todos os veículos que implementam a interface
foreach (Veiculo v in lista)
{
    if (v is IDadosAdicionais) // se o veículo implementar a interface...
    {
        (v as IDadosAdicionais).AcionarLimpador();
    }
}