A Interface permite definir um “contrato” na qual as classes que vão implementá-las, terão que ter os métodos definidos pela interface.
Vamos a algo mais prático para melhor entender isso.
Você precisará desenvolver um projeto, o qual Gerenciador do Banco de Dados será o MySQL e no decorrer do projeto você é informado terá que usar o PostgreSQL. E a agora? Como garantir que o projeto trabalhará como PostgreSQL, sem precisar ir em todos os arquivos e efetuar contínuas mudanças?
Vamos definir uma interface, que terão os métodos que irão trabalhar com as operações do banco de dados.
<?php
interface DataBase
{
public function connect();
public function insert(array $data);
public function update(array $data, array $where);
public function select($columns='*', array $filters=null);
public function delete(array $where);
public function close();
public function setTableName($name);
}Criamos uma interface onde definimos as operações comuns com banco de dados, que é conectar, inserir, alterar, selecionar, excluir, fechar, e também definição do nome da tabela. Quem for utilizar essa interface precisará ter esses métodos, mas a forma q eles irão implementar, dependerá de cada classe que irá utilizar.
Agora podemos criar nossas classes que irão implementar. Vamos criar para o MySQL.
<?php
class MySQLDataBase implements DataBase
{
public function __construct($host, $user, $pass, $dbname)
{
}
public function connect()
{
//Implementa a conexão
}
public function insert(array $data)
{
//Implementação do Insert usando MySQL
}
public function update(array $data, array $where)
{
//Implementação do update usando MySQL
}
public function select($columns='*', array $filters=null)
{
//Implementação do SELECT usando MySQL
}
public function delete(array $where)
{
//Implementação do DELETE usando MySQL
}
public function close()
{
//Fecha a conexão
}
public function setTableName($name)
{
//define nome da tabela
}
}Repare que todos os métodos foram utilizados da interface, só que como a classe vai implementar isso, vai depender de cada banco de dados. Vamos fazer outro exemplo:
<?php
class PostgreSQLDataBase implements DataBase
{
public function __construct($host, $user, $pass, $dbname)
{
}
public function connect()
{
//Implementa a conexão
}
public function insert(array $data)
{
//Implementação do Insert usando PostgreSQL
}
public function update(array $data, array $where)
{
//Implementação do update usando PostgreSQL
}
public function select($colums='*', array $filters=null)
{
//Implementação do SELECT usando PostgreSQL
}
public function delete(array $where)
{
//Implementação do DELETE usando PostgreSQL
}
public function close()
{
//Fecha a Conexão
}
public function setTableName($name)
{
//define nome da tabela
}
}Veja que fiz a mesma coisa, mas a forma de implementar a instruções de conectar, inserir, etc, vai depender da classe, mas a única que coisa q sei mesmo q eles terão q ter esses métodos.
Agora criaremos uma nova classe, a qual trabalhará com essas classes, que vai abstrair pra gente:
<?php
class DataAccessObject implements DataBase
{
protected $adapter;
public function __construct(DataBase $object)
{
$this->adapter = $object;
$this->connect();
}
public function setTableName($name)
{
$this->adapter->setTableName($name);
}
public function connect()
{
$this->adapter->connect();
}
public function insert(array $data)
{
$this->adapter->insert($data);
}
public function update(array $data, array $where)
{
$this->adapter->update($data, $where);
}
public function delete(array $where)
{
$this->adapter->delete($where);
}
public function close()
{
$this->adapter->close();
}
}Veja que criei uma classe que também implementa a interface DataBase. Só que agora ela tem um atributo chamado adapter, que será responsável por guardar a instancia da classe do banco de dados q irei utilizar. Veja que no construtor é informado q objeto passado tem q ter implementado a interface DataBase, isso me garante que saberei q métodos irei utilizar. Mas veja que não falei se será MySQL,PostgreSQL etc, porque não precisa, o que preciso saber que ele tem a interface implementado, pra pode utilizar nessa classe.
<?php
//Inclui as classes
require_once "Db/DataBase.php";
require_once "Db/MySQLDataBase.php";
require_once "Db/DataAccessObject.php";
//Instancia classe que abstrairá as ações do MySQL
$database = new MySQLDataBase($host, $user, $pass, $dbname);
//Instancio a classe que fará as operações, dizendo que banco de dados irei utilizar
$dao = new DataAccessObject($database);
//Definir o nome da tabela
$dao->setTableName('produtos');
//faço uma operação
$dao->delete(['id' => 1]);Agora vamos dizer q precisamos usar o PostgreSQL. Simples, apenas instanciamos a classe do PostgreSQL, e passamos para classe DataAccessObject.
<?php
//Inclui as classes
require_once "Db/DataBase.php";
require_once "Db/PostgreSQLDataBase.php";
require_once "Db/DataAccessObject.php";
//Instancia classe que abstrairá as ações do PostgreSQL
$database = new PostgreSQLDataBase($host, $user, $pass, $dbname);
//Instancio a classe que fará as operações, dizendo que banco de dados irei utilizar
$dao = new DataAccessObject($database);
//Definir o nome da tabela
$dao->setTableName('produtos');
//faço uma operação
$dao->delete(['id' => 1]);Veja que operação no banco de dados, continuará a mesma, a lógica da aplicação não vai mudar, porque sei que as classes que vão trabalhar com banco de dados terão a interface com as operações que foram definidas.
Então a ideia da interface é definir uma forma de trabalhar, mas como você vai trabalhar, vai depender de cada classe. Definimos q iremos trabalhar com as operações no banco de dados, todas as classes que implementarem a Interface, terão que ter esses métodos, caso precise mudar de banco de dados, não terei perda no sistema, porque sei que irão trabalhar da mesma forma, só a implementação que será diferente.
Espero que tenha ajudado.
E até a próxima.
