Fala galera,
tudo beleza?
Vou começar uma serie de artigos de dicas basicas para desenvolvedores com conceitos simples e uteis de Arquitetura com .net (Mesmo que você consiga aplicar para sua linguagem :) ).
Hoje vamos falar de Métodos Virtuais ! Bora!
Por mais que alguns escrevam artigos dizendo o contrario, a arquitetura de software desempenha um papel fundamental no desenvolvimento de aplicativos eficientes e escaláveis.
Uma das abordagens mais poderosas é a utilização de métodos virtuais. Essa técnica oferece uma série de benefícios que vão desde a extensibilidade até a facilidade de manutenção do código.
O que são métodos virtuais?
Um método virtual é aquele que pode ser sobrescrito em uma classe derivada, permitindo que seu comportamento seja modificado para atender às necessidades específicas dessa classe. Essa flexibilidade é alcançada através do uso da palavra-chave virtual na declaração do método na classe base e da palavra-chave override na declaração do método na classe derivada.
E Quais as vantagens?
- Extensibilidade: Ao utilizar métodos virtuais, é possível estender a funcionalidade de uma classe base através da criação de classes derivadas que substituem o comportamento dos métodos virtuais. Isso permite adicionar novos recursos ou personalizar o comportamento existente sem modificar a classe base, mantendo assim a integridade do código.
- Polimorfismo: O polimorfismo é um dos princípios fundamentais da programação orientada a objetos, e os métodos virtuais são uma ferramenta essencial para sua implementação. Com métodos virtuais, é possível tratar objetos derivados como objetos da classe base, facilitando o uso de herança e permitindo que diferentes implementações de um método sejam invocadas com base no tipo de objeto em tempo de execução.
- Manutenção simplificada: As modificações em um método na classe base refletem-se automaticamente em todas as classes derivadas que o sobrescrevem. Isso simplifica a manutenção do código, uma vez que as alterações são centralizadas e propagadas para todas as partes relevantes do sistema.
Vamos ver um exemplo bem facil para isso :
public class Pessoa
{
public virtual void MeuCabelo()
{
Console.WriteLine("Meu Cabelo Esta grande");
}
}
public class Bertuzzi : Pessoa
{
}
public class Andre : Pessoa
{
public override void MeuCabelo()
{
Console.WriteLine("Meu Cabelo Esta Sumindo.");
}
}
public class Ewerton : Pessoa
{
public override void MeuCabelo()
{
Console.WriteLine("Meu Cabelo Sumiu.");
}
}
class Program
{
static void Main(string[] args)
{
var bertuzzi = new Bertuzzi();
var andre = new Andre();
var ewerton = new Ewerton();
bertuzzi.MeuCabelo(); // Saída: "Meu Cabelo Esta grande."
andre.MeuCabelo(); // Saída: "Meu Cabelo Esta Sumindo."
ewerton.MeuCabelo(); // Saída: "Meu Cabelo Sumiu."
}
}
Neste exemplo, a classe base Pessoal possui um método virtual MeuCabelo() que exibe uma frase genérico. As classes derivadas Andre e Ewerton substituem esse método para exibir suas proprias fases genericas. Ao instanciar os objetos e chamar o método MeuCabelo(), o comportamento apropriado é invocado com base no tipo de objeto em tempo de execução.
Como a classe Bertuzzi não sobrescreve o método, a mesma possui o comportamento do método Virtual.
Simples não? Com essa implementação simples muitos softwares que as vezes precisam de comportamentos especificos podem ser implementados de maneira facil ;).
Caso queira saber mais sobre o assunto abordado no principio de OCP (Open-Closed Principle). Vou deixar esses dois links que eu recomendo muito :
1 - DEVSHOW #22 – SOLID (OCP)
2 - SOLID: OCP - Open/Closed Principle (Princípio do Aberto/Fechado)
Espero ter ajudado!
Aquele abraço!
Top comments (0)