Interfaces com métodos padrões se trata da capacidade de adicionar assinaturas de métodos em uma interface com um corpo definido (com um comportamento padrão ou mesmo um corpo vazio) fazendo com que as classes que implementam essa interface não tenham a obrigatoriedade de implementar esse novo método adicionado na interface.
Imagine o seguinte cenário genérico:
Temos uma interface IAnimal que contém métodos comuns que simulam comportamentos comuns de todos os animais.
public interface IAnimal
{
void MakeSound();
void Eat();
void Sleep();
}
Temos 3 classes que representam animais terrestres e que implementam a interface IAnimal.
public class Dog : IAnimal
{
public void Eat()
{
}
public void MakeSound()
{
}
public void Sleep()
{
}
}
public class Cat : IAnimal
{
public void Eat()
{
}
public void MakeSound()
{
}
public void Sleep()
{
}
}
public class Rabbit : IAnimal
{
public void Eat()
{
}
public void MakeSound()
{
}
public void Sleep()
{
}
}
E também temos uma outra classe de um animal voador, que também implementa a interface IAnimal.
public class Bird : IAnimal
{
public void Eat()
{
}
public void MakeSound()
{
}
public void Sleep()
{
}
public void Fly()
{
}
}
Agora, digamos que precisamos adicionar um novo método "Run" na nossa interface IAnimal, porém não queremos que ela tenha uma implementação concreta na classe do animal voador "Bird", somente nas classes dos animais terrestres.
Podemos fazer dessa forma, adicionando um corpo ao método dentro da interface:
public interface IAnimal
{
void MakeSound();
void Eat();
void Sleep();
public void Run()
{
}
}
Agora nossas classes que representam animais terrestres, podem implementar esse novo método.
public class Dog : IAnimal
{
public void Eat()
{
}
public void MakeSound()
{
}
public void Sleep()
{
}
public void Run()
{
Console.WriteLine("Running...");
}
}
public class Cat : IAnimal
{
public void Eat()
{
}
public void MakeSound()
{
}
public void Sleep()
{
}
public void Run()
{
Console.WriteLine("Running...");
}
}
public class Rabbit : IAnimal
{
public void Eat()
{
}
public void MakeSound()
{
}
public void Sleep()
{
}
public void Run()
{
Console.WriteLine("Running...");
}
}
Enquanto nossa classe que representa um animal voador "Bird" não precisará fazer essa implementação, então ela permanece assim:
public class Bird : IAnimal
{
public void Eat()
{
}
public void MakeSound()
{
}
public void Sleep()
{
}
public void Fly()
{
}
}
Como você viu, pode ser muito útil utilizar esse recurso, porém fique atento para acabar não poluindo a interface ou mesmo quebrando o princípio SRP (Single Responsability Principle) ao adicionar métodos demasiadamente ou métodos que não fazem parte do contexto da interface.
Top comments (1)
Muito bacana @guigovaski , não conhecia esse recurso para implementar em contratos de interface. Quando me deparava com essa situação eu criava uma nova interface somente com o método específico e tinha o retrabalho de implementar essa nova interface nas classes dependentes.