Atenção: esse artigo tem um vídeo complementar. Clique e assista!

Desenvolvimento de softwares é uma tarefa árdua. Agradável sim, mas sempre árdua porque consiste em traduzir necessidades e solução de problemas do mundo real para que uma máquina possa ser usada para automatizar o processo de solução.

Usar máquinas para ajudar a resolver problemas faz parte da cultura humana. Quando usamos um telefone celular, um painel de informações de um carro, ou um site da internet nem pensamos no software que está por trás, graças à simplicidade e interface relativamente intuitiva que este foi feito.

No início, escrever software exigia que se entendesse o funcionamento interno da máquina, e o mais comum era escrever os programas em uma linguagem de baixo nível, que hoje chamamos de linguagem de máquina.

Muitas foram às etapas durante a história das linguagens de programação, mas, a mais importante delas sem dúvida foi o surgimento das linguagens orientadas a objeto.

Definindo modelos para resolver problemas

O mérito principal das linguagens OOP é fornecer uma abstração para o programador que permite representar elementos do mundo real através de código. Logo, qualquer coisa pode ser tratada dentro destas linguagens de programação.

Usando um exemplo clássico, considere um carro, suas principais características podem ser definidas assim:

1. Potência do motor

2. Modelo da carroceria

3. Número de assentos

4. Cor da carroceria

5. Tipo de combustível usado

E o que podemos fazer dentro deste carro, considerando somente funcionalidades básicas, vinculadas com o “hardware” pode ser resumido nas seguintes operações

1. Ligar

2. Desligar

3. Acelerar

4. Frear

5. Estacionar

Utilizando uma linguagem de programação orientada a objetos, tanto suas características como suas operações, podem ser representadas. Considere as características usando o C#. Cada uma pode se tornar uma propriedade:

public decimal PotenciaDoMotor { get; set; }
  public string ModeloDaCarroceria { get; set; }
  public int NumeroDeAssentos { get; set; }
  public string CorDaCarroceria [ get; set; }
  public string TipoDeCombustivel { get; set; }

As operações, por sua vez, podem ser representadas como métodos (aqui não foram consideradas as implementações destes).

public bool Ligar() { }
  public bool Desligar() { }
  public bool Acelerar() { } 
  public bool Frear() { } 
  public bool Estacionar() { }

Ou seja, a principal ideia destas linguagens é abstrair ao máximo, permitindo que o programador fique distante de complexidades representadas pelo hardware e mais próximo do problema no mundo real. Outra característica muito interessante, é a possibilidade de detalhar os componentes do software e montar este usando outros objetos.

Assim como um carro que é feito de peças independentes e que se interconectam usando interfaces e padrões, nas linguagens de programação é possível fazer com que vários objetos aparentemente sem relação nenhuma sejam conectados para construir o software.

Mas, para que seja possível garantir flexibilidade, estes objetos precisam de um modelo a ser seguido. Estes modelos, como os programadores C# sabem, são as classes que são usadas para estruturar e codificar o comportamento para o objeto.

Estas classes devem ser bem definidas e fazer apenas um trabalho – e bem feito. Para assegurar que as classes sigam um padrão de desenvolvimento, torna-se necessário também se estabelecer um modelo para as mesmas, denominado de interface nas linguagens OOP.

Interfaces como meta modelos

Como tudo trata de modelos, interfaces podem ser tratadas como “modelos para modelos”, ou apenas parar ilustrar, temos a seguinte cadeia de modelos, até chegar ao objeto propriamente dito:

Interfaces à Classes: modelo para à Objetos: modelo para elementos concretos.

Uma interface não implementa nenhuma lógica de programação, mas antes, estabelece quais os elementos essenciais que precisaram ser obrigatoriamente implementados, e por sua vez, alguns padrões que devem ser obedecidos.

Graças a estas e a capacidade do framework .NET de criar instâncias de objetos baseados em interfaces (em vez de classes), é possível para o programador criar um modelo para objetos, encarregar outro programador de implementar estas classes e outro para consumir estas usando apenas as definições feitas na interface, que irá estabelecer as propriedades e métodos que serão criados.

Uma interface por padrão começa com a letra “I” em maiúsculo no nome e deve ter o modificador de acesso “public”. Embora se possa usar qualquer nome, é recomendável usar este padrão de nomenclatura para facilitar a compreensão do código. As próprias interfaces do framework .NET seguem este padrão.

Um ponto essencial na criação da classe é que esta precisa ter o nível mais alto de abstração possível. Assim, usando o exemplo da representação de um automóvel, provavelmente não seria representado através de uma interface, mas antes optaríamos por descer um nível e representar vários veículos e não somente o automóvel. Usando este princípio, podemos pensar numa interface para descrever veículos da seguinte forma:

public interface IVeiculo
  {
      decimal PotenciaDoMotor { get; set; }
      string NumeroDoChassi { get; set; }
      string TipoDeCompustivel { get; set; }
      
      bool Ligar();
      bool Desligar();
      bool Acelerar();
      bool Desacelerar();
  }

Somente os elementos que poderão ser compartilhados entre várias classes devem ser mantidos.

Para descrever os atributos, que são os dados que a interface define, deve seguir-se o modelo que foi colocado usando getters e setters, ou seja, as propriedades. Campos privados ou públicos não podem ser definidos.

Note que não são definidas as acessibilidade dos elementos, não são colocados modificadores de acesso como public e private. Para os métodos também não se usa modificadores de acesso, e a assinatura do método define além do tipo de retorno, os parâmetros de entrada e de saída.

A regra básica para definição das interfaces é estabelecer de forma mais sucinta quais os elementos deverão ser implementados pela classe. Não defina elementos que poderão não ser implementados apenas para forçar o uso de interfaces.

Para implementar uma interface basta na declaração da classe, inserir o nome da interface que a classe é baseada após o sinal de dois pontos “:”.