Olá pessoal, neste artigo veremos os principais conceitos sobre Interfaces.

Podemos definir como interface o contrato entre a classe e o mundo exterior. Quando uma classe implementa uma interface, se compromete a fornecer o comportamento publicado por esta interface.

As classes ajudam a definir um objeto e seu comportamento e as interfaces que auxiliam na definição dessas classes. As interfaces são formadas pela declaração de um ou mais métodos, os quais obrigatoriamente não possuem corpo.

As operações específicas para cada um desses métodos são realizadas pela classe que implementa. De um modo geral, podemos dizer que as interfaces definem certas funcionalidades, as quais dependem das classes que implementam as interfaces para que os métodos existam.

A implementação de interfaces também pode ser realizadas por meio de Structs.

Em uma mesma classe, podem ser implementadas uma ou mais interfaces, sendo que elas devem estar separadas por vírgulas. Se uma classe implementa uma determinada interface, todos os métodos declarados nessa interface implementada devem ser definidos na respectiva classe. Caso isso não ocorra, será gerado um erro de compilação.

Um objeto de um tipo definido por uma interface não pode ser instanciado de forma alguma.

Os membros declarados em uma interface são implicitamente públicos. Neste ponto, devemos considerar que não é permitido declarar variáveis em uma interface, isto em virtude desta ser uma implementação do atributo de um objeto.

Como exemplo da utilização de interfaces, podemos citar quando trabalhamos com componentes gráficos na tela do computador, em que utilizamos botões, janelas e outros itens. Neste caso, temos várias interfaces com diversos métodos para o tratamento de eventos que podem ocorrer nesses componentes.

Dentro esses eventos, podemos ter os seguintes: fechar a janela, abrir a janela, clicar sobre um botão, etc. Os métodos que capturam esses eventos estão definidos em interfaces específicas, mas a ação a ser executada quando um destes eventos ocorrer é de responsabilidade da classe que implementou a interface. É por isso que os métodos declarados na interface não possuem corpo.

Obs: É importante ressaltar que, por convenção, ao declararmos o seu nome, iniciamos com um I maiúsculo.

Exemplo prático

Agora veremos um exemplo prático com o uso de Interfaces.

Crie um projeto, do tipo Console Application, dando a ele o nome ExemploInterfaces. Agora vá à Solution Explorer e adicione uma classe ao projeto, dando a ela o nome Funcionario.

Nesta classe iremos crie uma interface e uma classe, como no código a seguir:

public class Funcionario
    {
        interface IReajuste
        {
            double Reajuste();
        }
 
        public class ReajusteFuncionario : IReajuste
        {
            //Propriedades públicas da minha classe
            public string nomeFuncionario;
            public double salarioFuncionario;
 
            //Implementação do método Reajuste, da interface IReajuste
            public double Reajuste()
            {
                salarioFuncionario = salarioFuncionario * 1.50;
 
                return salarioFuncionario;
            }
        }
    }

Percebam que minha interface tinha um método em seu escopo. Usei este método em minha classe, que herda dessa interface. Assim é estabelecido um “contrato” entre a interface, que definiu o método Reajuste() e a classe, que herdou sua implementação usando seu método criado anteriormente. Simples né?

Agora vá ao arquivo Program.cs e, dentro do método principal (Main), faça o seguinte código:

  static void Main(string[] args)
  {
            //Instancio a classe ReajusteFuncionario, que herda da interface IReajuste
            Funcionario.ReajusteFuncionario objReajusteFuncionario = 
              new Funcionario.ReajusteFuncionario();
 
            //Atribuo valores fictícios para o nome e salário
            objReajusteFuncionario.nomeFuncionario = "Felipe Souza";
            objReajusteFuncionario.salarioFuncionario = 2500.00;
 
            //Escrevo os dados em tela
            Console.WriteLine("Antes do Reajuste: ");
            Console.WriteLine("\nNome: " + objReajusteFuncionario.nomeFuncionario);
            Console.WriteLine("\nSalário: R$ " + objReajusteFuncionario.salarioFuncionario);
 
            //Chamo o método Reajuste, implementado em minha classe, 
            // criado em minha interface
            objReajusteFuncionario.Reajuste();
 
            Console.WriteLine("\nDepois do Reajuste: ");
            Console.WriteLine("\nNome: " + objReajusteFuncionario.nomeFuncionario);
            Console.WriteLine("\nSalário: R$ " + objReajusteFuncionario.salarioFuncionario);
 
            //Paro a execução até que alguma tecla seja pressionada
            Console.ReadKey();
  }

Aperte F5 para executar a aplicação e veja o resultado na Figura 1:

resultado do exemplo
Figura 1. Resultado do exemplo prático

Assim o método foi implementado, garantido pelo “contrato” entre a interface e a classe.