Linguagem C# - Herança de Classes


Trataremos de um assunto muito utilizado no ambiente de Programação Orientado a Objetos, o uso de Herança de Classes. Este tipo de recurso é utilizado para descrever uma relação entre uma classe e outra permitindo reutilizar o código existente economizando tempo de programação. Devemos ter em mente um conceito importante no âmbito de herança de classes, todos os atributos e métodos também serão herdados, podendo também estender sua funcionalidade. A classe que cede os membros para a outra classe é chamada “superclasse” ou classe pai. Já a classe que herda os membros de outra classe é chamada de “subclasse” ou classe derivada. Para utilizarmos este recurso de herança de classes no C# é muito fácil, em seguida segue um modelo simples de como devemos utilizar este recurso. Ver Figura 01 para maiores detalhes.



Imagem 01. Herança entre Classes.




“SuperClasse”




public class Pai
{  
    //Construtor     

    //Destrutor da classe     //Atributos/Propriedades     //Métodos
 }



“SubClasse”




public class Filho: Pai
{
//Neste caso podemos programar atributos e métodos adicionais
}



A “SubClasse” Filho herda todas as propriedades e métodos da “SuperClasse” Pai. Neste caso é utilizado “:” (dois pontos) para implementar a herança de classes. Uma nota importante que devemos ressaltar é que na linguagem C# não podemos implementar a múltipla herança de Classes, ou seja, podemos herdar apenas de uma classe.

Operador “Overrive”


Entenda-se “Override” como a reescrita de métodos herdados da classe da qual deriva, possuindo o mesmo nome e com os mesmos parâmetros. Todos os métodos que podem ser sobrescritos devem obrigatoriamente possuir o operador “virtual”.  Podemos conferir a sintaxe em seguida.

“SuperClasse”




public class Pai
{  
      public virtual void ExecutarMétodo()
    {
        //Código referente à classe Pai
    }
}





“SubClasse”




public class Filho: Pai
{
    public override void ExecutarMétodo()
    {
        //Código referente à classe Filho
    }
}



Quando fazemos o “override” temos a escolha de reescrever o método por completo ou também podemos aproveitar rotinas da classe Pai. Para isto usaremos o operado “base”.


public override void ExecutarMétodo()
{
    //Código referente à classe Pai
    base.ExecutarMétodo();
   
    //Código referente à classe Filho
}



Criando um Exemplo prático


Crie uma aplicação “Windows Forms” e adicione um botão no formulário. A tela deverá ficar idêntica a Imagem 02.



Imagem 02. Formulário Padrão.


Para criação de classes seguimos as dicas contidas no mês anterior, clicando com o botão direito e escolhendo “Add/Add New Item.../Class”. Defina a classe como Pessoa e clique em Adicionar. Esta será a nossa “SuperClasse”. Para fins didáticos defino alguns atributos e métodos e o uso do operador “virtual” no Método “ExecutaMetodo”, o qual será sobrescrito posteriormente na “SubClasse”.


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows.Forms;

namespace WindowsFormsApplication1
{
    public class Pessoa
    {
   public Pessoa()
        {
            
        }
 
        ~Pessoa()
        {         }
       
        private string nome;
        private string cpf;
        private string rg;
     
        public string Nome
        {
            get { return nome;}
            set { nome = value;}
        }
       
        public string Cpf
        {
            get { return cpf; }
            set { cpf = value; }
        }         public string Rg
        {
            get { return rg; }
            set { rg = value; }
        }         public void CadastrarPessoa()
        {
            MessageBox.Show("Cadastrando Pessoa!");
        }         public virtual void ExecutarMétodo()
        {
MessageBox.Show("Executando o método da Classe Pessoa!");
        }
    }
}

Para criar a subclasse utilize os mesmos passos descritos acima. A subclasse será denominada “Funcionario”. Herdaremos todas as funcionalidades da superclasse Pessoa, ou seja, os atributos Nome, CPF e RG e os métodos CadastrarPessoa() e ExecutarMetodo().


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows.Forms;

namespace WindowsFormsApplication1
{
    public class Funcionario: Pessoa
    {  
        public Funcionario()
        {
            
        }         ~Funcionario()
        {         }         private int codigo;
        private string tipo;
             
        public int Codigo
        {
            get { return codigo;}
            set { codigo = value;}
        }
       
        public string Tipo
        {
            get { return tipo; }
            set { tipo = value; }
        }         public void TarefasFuncionario()
        {
            MessageBox.Show("Executando Tarefas!");
        }
      
        public override void ExecutarMétodo()
        {
            base.ExecutarMétodo();
  MessageBox.Show("Executando o Método da  Classe Funcionário!");         }
    }
}

Foram adicionados alguns atributos como Nome e Código e um método “TarefasFuncionario”. Estamos sobrescrevendo o método ExecutarMétodo(), como foi explicado anteriormente. O operador “base” servirá pra reutilizar o método ExecutarMétodo() da classe Pessoa. Principal trecho do código abordado: public class Funcionario: Pessoa Para executar o exemplo utilize o código:


private void button1_Click(object sender, EventArgs e)
{
      Funcionario func = new Funcionario();
      func.Nome = "Thiago Montebugnoli";
      func.Cpf = "998.899.999-899";
      func.Rg = "99.888.777-6";

      func.Codigo = 1000;
      func.Tipo = "Desenvolvedor";       func.CadastrarPessoa();
      func.TarefasFuncionario();
      func.ExecutarMétodo();
}

No código criado anteriormente primeiramente instancio a classe “Funcionario” e logo em seguida preenchemos os atributos Nome, Cpf e Rg. Percebam que estes atributos pertencem a classe “Pessoa”, a qual herdamos. Já os atributos Codigo e Tipo foram implementados na classe “Funcionario”. O método “CadastrarPessoa()” é originário da classe Base. O método “TarefasFuncionario()” foi implementado na própria classe “Funcionario”. Utilizamos o “Override” para o método ExecutarMetodo(). Ver Figura 03 e 04.


Imagem 03. Exemplo em “Run-Time”. (Método da classe Pessoa e da classe Funcionário)





Imagem 04. Exemplo em “Run-time”. (Override de Método)


Conclusão


Neste artigo abordei os principais itens em se tratando de herança de Classes na linguagem C#. Na realidade, POO envolve várias teorias e recursos que se torna muito maçante para tratar em um único artigo. Espero que esta seqüência de pequenos artigos proporcione um aprendizado e aprofundamento no assunto um tão quanto fácil para os senhores. Neste procurei abrir um leque de aprendizado em relação à Herança de Classes. Falado um pouco sobre “Override”, a Sobrescrita, que está diretamente ligado a este assunto.

Vou ficando por aqui, um forte abraço e até o mês que vem.


Sobre o Autor

Thiago Cavalheiro Montebugnoli adora aprender novas tecnologias. É tecnólogo, formado pela Faculdade de Tecnologia de Botucatu - SP (FATEC) foi consultor técnico do The Club, já desenvolveu softwares utilizando a plataforma .NET, Delphi junto com Banco de Dados SQL Server e Firebird. Atualmente trabalha no Centro de Processamento de Dados da Prefeitura Municipal de Itaí-SP e é colunista mensal da Revista The Club Megazine. Possui as seguintes certificações: MCP - Microsoft Certified Professional, MCTS - Microsoft Certified Technology Specialist, MCAD - Microsoft Certified Application Developer e MCSD - Microsoft Certified Solution Developer.

E-mail: thiago@theclub.com.br

The Club - O Maior Clube de programadores do Brasil