Programação Orientada a Objetos: Entendendo Interfaces

Last updated Nov 21, 2022

Contente

Neste ponto, eu diria que os fundamentos da compreensão da programação orientada a objetos foram estabelecidos.

Especificamente, eu cobri:

E, sim, há algum debate sobre o que constitui os fundamentos (ou seja, alguns não jogam polimorfismo na mistura, embora eu o faça). Mas os quatro acima devem fornecer uma base sólida para continuar desenvolvendo suas habilidades de programação orientada a objetos.

Existem mais, mas não acho que sejam tão profundos, detalhados ou difíceis de entender quanto alguns dos conceitos mencionados acima. Então, novamente, coisas diferentes são mais fáceis para os outros.

De qualquer forma, os próximos dois tópicos que são importantes para entender são:

Interfaces
Abstração

Falarei sobre cada um separadamente, mas certifique-se de ler primeiro a série Fundamentos, pois os dois tópicos acima permitirão que você confie neles e tire proveito deles.

Vago, eu sei, mas deixe-me explicar e depois partir daí.

Entendendo as interfaces

De longe, a definição mais comum de interface que você provavelmente ouvirá é que é um contrato. Isso não é errado, mas acho que deixa muito a desejar.

Por exemplo, quando você pensa em contratos, provavelmente pensa em algo muito envolvente, muito jargão, um processo complicado de obter algo assinado, datado, pronto para funcionar e assim por diante.

Mas quando se trata de interfaces de programação, esse não é o caso. Na verdade, eu diria que definir interfaces pode tornar a programação mais fácil e alivia muito a burocracia porque torna as coisas muito pretas ou brancas quanto ao que algo deve implementar.

Uma palavra sobre “interfaces"

Nossa indústria usa a palavra “interface” para duas coisas:

Designers e usuários usam o termo interface para descrever o que veem e como interagem com o aplicativo. Isso inclui coisas como botões, listas suspensas e outros elementos que podemos “tocar”.
Os programadores usam o termo para se referir a quais funções uma subclasse deve implementar para aderir a uma interface. Isso é chamado de “programação para uma interface”.

Este último é o que será discutido neste artigo. E não, não vamos usar exemplos típicos como programação para uma interface Animal ou qualquer outra coisa. Em vez disso, veremos como fazer isso a partir de exemplos de código reais.

Programação para uma interface

Definimos “programação para uma interface” como uma forma de escrevermos código que implemente as assinaturas de funções definidas na referida interface.

Mas o que são assinaturas de métodos? Simplificando, as assinaturas de método incluem:

o nome do nome da função,
os argumentos necessários,
o modificador de visibilidade

No contexto de uma classe, você a verá assim:

<?php

class Cache 
{
  public function set($key, $value) 
  {
    // method implementation
  }
}

Fácil, certo?

No código acima, podemos ver que a função set aceita uma chave e um valor que será utilizado e a função é acessível por qualquer objeto que tenha referência à classe.

Mas as interfaces também podem incluir isso. Porém, há uma ressalva: as interfaces não têm implementação de método.

Então, ao invés de algo assim:

<?php

class Cache 
{
  public function set($key, $value) {
    set_transient($key, $value);
  }
}

Você verá isso:

<?php

interface iCache 
{
  public function set($key, $value);
  public function get($key);
  public function has($key);
}

Mas também há algumas sutilezas a serem observadas no código acima.

Este código não o define como uma classe. Em vez disso, ele o chama de interface.
O nome da classe é prefixado com um ‘i’ para indicar que é uma interface. Isso não é necessário; é uma convenção.
O método não tem implementação. Não tem nada além de uma assinatura.

Quando criamos uma interface, estamos dizendo, como mencionado acima, que qualquer classe que implemente a interface definirá os métodos que ela inclui.

Então, se tivéssemos que unir tudo o que vimos acima, a implementação final ficaria assim (embora idealmente mantivéssemos isso em arquivos separados):

<?php

interface iCache {
  public function set($key, $value);
  public function get($key);
  public function has($key);
}

public class SimpleCache implemnents iCache
{
  public function set($key, $value)
  {
    set_transient($key, $value, DAY_IN_SECONDS);
  }

  public function get($key)
  {
    if (!$this->has($key))
    {
      return false;
    }
    return get_transient($key);
  }

  public function has($key)
  {
    return false !== get_transient($key);
  }
}

E é assim que interfaces e classes se encaixam.

É isso?

Em termos simples, sim. Mas na minha experiência, descobri que há mais do que simplesmente definir os métodos e implementá-los.

Muitas vezes, é fácil definir classes, depois definir a interface e depois implementar a interface. Mas isso é completamente para trás. Em vez disso, precisamos pensar mais estrategicamente sobre nosso trabalho.

Em vez de recorrer a uma interface, o que anula completamente o propósito, precisamos começar de forma ampla para que nossas classes possam se especializar no que fazem ao mesmo tempo em que implementam funcionalidades comuns não apenas a essa classe, mas a outras classes que podem precisar da mesma funcionalidade.

Usando o exemplo acima, podemos ter um SimpleCache, um TransientCache ou algum outro tipo de cache. Independentemente do tipo de cache que implementamos, eles implementarão a interface e a funcionalidade será deixada para a classe que implementa a interface.

Assim, definimos como um cache pode parecer em alto nível, mas as classes de implementação definirão exatamente como eles funcionam.

Se você é um desenvolvedor WordPress e quer aprender a construir coisas em cima do aplicativo usando técnicas práticas e orientadas a objetos, então por que não entrar no site?

Fonte de gravação: tommcfarlin.com