Interfaces em PHP 5
As interfaces são um sistema bastante comum, utilizado em programação orientada a objetos. São algo assim como declarações de funcionalidades que têm que cobrir as classes que implementam as interfaces.
Em uma interface se definem habitualmente um jogo de funções que devem codificar as classes que implementam tal interface. De modo que, quando uma classe implementa uma interface, poderemos estar seguros de que em seu código estão definidas as funções que incluía essa interface.
À hora de programar um sistema, podemos contar com objetos que são muito diferentes e que, portanto, não pertencem à mesma hierarquia de herança, mas que devem realizar algumas ações comuns. Por exemplo, todos os objetos com os que comercializam algumas grandes cadeias de lojas devem contar com a funcionalidade de serem vendidos. Uma mesa tem pouco em comum com um ventilador ou com uns tênis, porém todos os produtos disponíveis devem implementar uma função para poder serem vendidos.
Outro exemplo. Uma lâmpada, um carro e um computador são classes muito diferentes que não pertencem ao mesmo sistema de herança, mas todas podem ser ligadas e desligadas. Neste caso, poderíamos construir uma interface chamada “ligável”, que incluiria as funcionalidades de ligar e desligar. Neste caso, a interface conteria duas funções ou métodos, um ligar() e outro desligar().
Quando se define uma interface, se declaram uma série de métodos ou funções sem especificar nenhum código fonte associado. A seguir, as classes que implementem essa interface serão as encarregadas de proporcionar um código aos métodos que essa interface contem. Isto é certo: se uma classe implementa uma interface, deveria declarar todos os métodos da interface. Se não temos código fonte para algum desses métodos, pelo menos devemos declará-los como abstratos e, portanto, a classe também terá que ser declarada como abstrata, porque tem métodos abstratos.
Código para definir uma interface
Vejamos o código para realizar uma interface. Em concreto veremos o código da interface ligável, que tem que implementar todas as classes cujos objetos se possam ligar e desligar.
interface ligavel{
}
Vemos que para definir uma interface se utiliza a palavra chave interface, public function ligar(); public function desligar(); seguida pelo nome da interface e, entre chaves, a listagem de métodos que terá. Os métodos não devem ser codificados, unicamente declarados.
Implementação de interfaces
Agora vejamos o código para implementar uma interface em uma classe.
class lampada implements ligavel{
se fez…”;
public function ligar(){ echo “<br>e a luz }
echo “<br>Estamos às escuras…”;
public function desligar(){
}
Para implementar uma interface, na declaração da classe, deve-se utilizar a palavra implements, seguida do nome da interface que se vai implementar. Poderiam ser implementadas várias interfaces na mesma classe, e nesse caso se indicariam todos os nomes das interfaces separadas por vírgulas.
No código da classe somos obrigados a declarar e codificar todos os métodos da interface.
| Nota: em concreto, PHP 5 entende que se uma classe implementa uma interface, os métodos dessa interface estarão sempre na classe, embora não se declarem. De modo que se não os declaramos explicitamente, PHP 5 o fará por nós. Esses métodos da interface serão abstratos, assim que a classe terá que ser definida como abstrata. Pode-se encontrar mais informação sobre a abstração no artigo Métodos e classes abstratos em PHP 5. |
}
Agora vejamos o código da classe carro, que também implementa a interface ligável. Complicamos este código um pouco mais.
class carro implements ligavel{
private $gasolina; private $bateria; private $estado = “desligado”;
function __construct(){ $this->gasolina = 0; $this->bateria = 10; }
== “desligado”){
if ($this->bateria > 0){
&n bsp; if ($this->gasolina > 0){
&n bsp; $this- >estado = “ligado”;
&n bsp; $this- >bateria –;
&n bsp; echo “<br><b>Ligo…</b> estou ligado!”;
public function ligar(){ if ($this->estado &n bsp; }else{
&n bsp; echo “<br>Não tenho gasolina”;
&n bsp; }
}else{
&n bsp; echo “<br>Não tenho bateria”;
}
echo “<br>Já estava ligado”;
}else{ }
}
== “ligado”){
$this->estado = “desligado”;
echo “<br><b>Desligo…</b> estou desligado!”;
echo “<br>Já estava desligado”;
public function desligar(){ if ($this->estado }else{ } }
$litros;
echo “<br>Carregados $litros litros”;
}
Vendo o código anterior, pode-se comprovar que não há muito em comum entre as classes lâmpada e carro. O código para ligar uma lâmpada era muito simples, mas para colocar em marcha um carro temos que realizar outras tarefas. Antes, temos que ver se o carro estava ligado previamente, se tem gasolina e se tem bateria. Por sua parte, o método desligar faz uma única comprovação para ver se o carro estava ou não desligado previamente.
Também incorporamos um construtor que inicializa os atributos do objeto. Quando se constrói um carro, a bateria está cheia, mas o depósito de gasolina está vazio. Para encher o depósito deve-se utilizar simplesmente o método colocar_gasolina().
Chamadas polimórficas passando objetos que implementam uma public function colocar_gasolina($litros){ $this->gasolina += } interface
As interfaces permitem o tratamento de objetos sem necessidade de conhecer as características internas desse objeto e sem importar de que tipo são… só temos que saber que o objeto implementa uma interface.
Por exemplo, tanto os carros quanto as lâmpadas podem ser ligados e desligados. Assim, podemos chamar o método ligar() ou desligar(), sem nos importarmos se é um carro ou uma lâmpada o que há que colocar em funcionamento ou parar.
Na declaração de uma função podemos especificar que o parâmetro definido implementa uma interface, de modo que dentro da função se podem realizar ações tendo em conta que o parâmetro recebido implementa um jogo determinado de funções.
Por exemplo, poderíamos definir uma função que recebe algo por parâmetro e o liga. Especificaremos que esse algo que recebe deve implementar a interface ligável, assim poderemos chamar seus métodos liga() ou desliga() com a certeza de saber que existem.
function liga_algo (ligável $algo){
} $algo->ligar();
$minhalampada = new lampada();
$meucarro = new carro();
liga_algo($minhalampada);
liga_algo($meucarro);
Se tivéssemos uma classe que não implementara a interface ligável, a chamada a esta função provocaria um erro. Por exemplo, um CD-Rom não se pode ligar nem desligar.
class cd{
} public $espaço;
$meucd = new cd();
liga_algo($meucd); //da um erro. cd não implementa a interface ligável
Isto nos daria um erro como este: Fatal error: Argument 1 must implement interface ligável in c:wwwejphp5funcion_encender.php on line 6. Fica muito claro que deveríamos implementar a interface ligável na classe cd para que a chamada à função fosse executada corretamente.