Introdução
Há algum tempo utilizo PHP para desenvolver aplicações web based, porém nunca utilizando orientação a objeto (OO). Um tanto por não ter muito interesse nisso (pois isso é para mim um hobby), mas muito é porque os artigos sobre o tema são um tanto confusos para mim.
Por isso este ano decidi realmente aprender a orientação a objetos no PHP. Fruto desse aprendizado é este primeiro artigo sobre o tema e que tem por objetivo apenas apresentar de forma sucinta, clara, objetiva e de fácil compreensão pelos iniciantes do que é a orientação a objeto, seus principais conceitos e como fazer isso funcionar na prática.
Quando falamos em orientação a objetos (OO), em PHP, estamos falando basicamente de classes, métodos e propriedades.
Classe, no PHP, é um bloco de código escrito na forma abaixo:
Basicamente é o nome da classe, precedido da palavra reservada class e seguida de um par de colchetes {} o qual delimitará o código da classe.
Cada classe, no PHP, é um objeto, ou seja, uma coleção de métodos e propriedades.
Mas o que são métodos e propriedades?
Se você sabe o que é uma variável no PHP, sabe o que é propriedade, pois propriedades nada mais são do que as variáveis internas de uma classe, ou seja, são variáveis que você coloca dentro dos colchetes {} da classe.
Métodos são as funções internas das classes, ou seja, as funções que você coloca entre os colchetes {} da classe.
Abaixo um exemplo de classe, com métodos e variáveis.
Muito bem, agora que sabemos estes três conceitos, vamos à prática, ou seja, vamos fazer uma classe, com seus métodos e variáveis, e ver como tudo funciona.
Criando uma classe
Agora é o momento de colocarmos em prática os conceitos de classe, métodos e propriedades. Para isso vamos construir uma classe de interação com o MySQL.
Essa classe deverá fazer algumas coisas:
- Conectar ao servidor MySQL e selecionar o banco de dados desejado;
- Configurar as variáveis (propriedades) dinamicamente;
- Executar consultas ao banco de dados, retornando o resultado;
- Retornar a string SQL usada na consulta.
Abaixo está o código completo da classe (mas não se preocupe, abaixo do código vamos explicá-lo passo a passo):
host,$this->user,$this->pass) or die($this->erro(mysql_error()));
return $con;
}
function selecionarDB(){
/*
* Função para seleção do banco de dados a ser usado
* @author Everton da Rosa (Everton3x)
* @return Boolean Retorna true (verdadeiro) ou false (falso)
*/
$sel = mysql_select_db($this->db) or die($this->erro(mysql_error()));
if($sel){
return true;
}else{
return false;
}
}
function query(){
/*
* Função para execução da consulta ao banco de dados
* @author Everton da Rosa (Everton3x)
* @return Object $qry Retorna o resultado da consulta como um objeto
*/
$qry = mysql_query($this->sql) or die ($this->erro(mysql_error()));
return $qry;
}
function set($prop,$value){
/*
* Função para atribuir valores às propriedades da classe
* @author Everton da Rosa (Everton3x)
* @param String $prop Nome da propriedade que terá seu valor atribuído
* @param String, Array, Object Valor a ser atribuído
* @return void Não dá nenhum retorno
*/
$this->$prop = $value;
}
function getSQL(){
/*
* Função para retornar a string SQL
* @author Everton da Rosa (Everton3x)
* @return String String SQL
*/
return $this->sql;
}
function erro($erro){
/*
* Função para exibir os error
* @author Everton da Rosa (Everton3x)
* @param String $erro Erro a ser exibido
* @return void Não dá nenhum retorno
*/
echo $erro;
}
}
?>
Inicialmente, indicamos a classe com a palavra-chave class e damos um nome a ela (TutoDB).
class TutoDB {
Em seguida, definiremos as propriedades da classe, que nada mais são do que variáveis que podem ou não receber valores desde já. No nosso casso, apenas definiremos as variáveis. Caso quiséssemos atribuir-lhes valor, faríamos $host = ‘localhost’; por exemplo.
/* * Declaração das variáveis (propriedades) da classe */ $host; // Host (Servidor) que executa o banco de dados $user; // Usuário que se conecta ao servidor de banco de dados $pass; // Senha do usuário para conexão ao banco de dados $db; // Nome do banco de dados a ser utilizado $sql; // String da consulta SQL a ser executada
Aqueles que já trabalham com classes sentirão falta das palavras public, private ou protected. Como disse inicialmente, este é um artigo básico. A questão sobre visibilidade fica para um próximo.
As propriedades que foram definidas servem para armazenar o host MySQL, o usuário, a senha e o banco de dados, além da string de consulta SQL ($host, $user, $pass, $db e $sql, respectivamente).
Depois disso, iniciaremos com os códigos do nossos métodos.
Temos seis métodos na nossa classe:
- conectar() serve para estabelecer uma conexão ao servidor MySQL (o host);
- selecionarDB() serve para selecionar o banco de dados desejado;
- query() executa a consulta ao banco de dados;
- set() é o método que atribui os valores ás nossas propriedades;
- getSQL() retorna a String SQL atribuída à propriedade $sql;
- erro() exibe mensagens de erro;
É importante salientar que não serão explicados o que cada método faz, pois isso fugiria do escopo do artigo. O importante é que se entenda que propriedades são objetos que são armazenados dentro da classe e que são utilizados geralmente pelos métodos e que métodos são partes da classe que fazem alguma coisa, geralmente baseados nas propriedades.
Na próxima parte do artigo veremos como utilizar esta classe e aprenderemos mais sobre a interação entre propriedades e métodos.
Utilizando a classe
Agora que temos a nossa classe pronta, vamos ver o que ela faz e entender um pouco mais sobre métodos e propriedades e a interação entre eles.
Primeiramente devemos instanciar a classe, ou seja, criar um objeto na memória que irá representar a classe TutoDB.
Isso nós conseguimos da seguinte maneira:
$obj = new TutoDB;
Com isso estamos dizendo ao PHP para armazenar na variável $obj uma nova instância da classe TutoDB.
Depois vamos atribuir valores às nossas propriedades da seguinte forma:
$obj->set('db','information_schema');
$obj->set('host','localhost');
$obj->set('user','root');
$obj->set('pass','');
$obj->set('sql','select * from COLLATIONS');
Com isso dizemos ao PHP para utilizar o método set() do objeto armazenado em $obj (a classe TutoDB) para atribuir à propriedade passada pelo primeiro argumento o valor do segundo argumento.
Argumentos são os valores passados entre os parênteses das funções ou métodos. No caso da primeira linha, estamos dizendo para que seja colocado o valor information_schema na propriedade $db.
Poderíamos fazer isso de outra forma, sem utilizar um método, mas atribuindo diretamente um valor para a propriedade assim:
$obj->db = 'information_schema'
Por que então utilizamos um método para fazer isso?
Vamos supor que quiséssemos que a propriedade $user armazene apenas os valores ‘root’ ou ‘admin’. Se deixássemos para atribuir valores em $user da forma $obj->user, qualquer valor poderia ser atribuído, mas se utilizamos um método para isso (no nosso caso, set()), podemos, dentro do método, colocar um código que verifique se o valor passado para ser armazenado na propriedade $user seja apenas root ou admin.
Vamos aproveitar e ver o método set():
function set($prop,$value){
/*
* Função para atribuir valores às propriedades da classe
* @author Everton da Rosa (Everton3x)
* @param String $prop Nome da propriedade que terá seu valor atribuído
* @param String, Array, Object Valor a ser atribuído
* @return void Não dá nenhum retorno
*/
$this->$prop = $value;
}
Veja que a atribuição de valor à propriedade é feita no seguinte esquema:
$this->$prop = $value;
Onde:
$this referencia a própria classe.
Precisamos fazer referência à classe pois se colocássemos apenas $prop = $value, estaríamos dizendo ao PHP para atribuir $value a uma variável chamada $prop, que poderia estar até mesmo fora da nossa classe.
Note também que o que o método faz é apenas $this->nomedapropriedade = valor a ser atribuído.
Seguindo…
Vamos conectar com o servidor MySQL com o método conectar() da seguinte forma:
$obj->conectar(); // Realiza a conexão
function conectar(){
/*
* Função para conexão ao banco de dados
* @author Everton da Rosa (Everton3x)
* @return Object Retorna o objeto da conexão
*/
$con = mysql_connect($this->host,$this->user,$this->pass) or die($this->erro(mysql_error()));
return $con;
}
Vejam que o método pega os valores das propriedades $host, $user e $pass para conectar ao servidor MySQL (mysql_connect($this->host,$this->user,$this->pass)), ou se der erro, para o script e chama o método erro() passando-lhe o parâmetro mysql_error() ( or die($this->erro(mysql_error()))).
Depois disso selecionamos o banco de dados desejado (que foi informado na propriedade $db):
$obj->selecionarDB(); // Seleciona o banco de dados
Em seguida realizamos a consulta ao banco de dados:
$rs = $obj->query();
Todos os três métodos seguem um mesmo padrão: usam os valores armazenados nas propriedades para realizar alguma coisa.
Ainda falta pegarmos a string SQL com o seguinte código:
$sql = $obj->getSQL(); // Pega o valor da propriedade $sql
Observe que o método getSQL() apenas retorna o valor armazenado na propriedade $sql. Poderíamos fazer isso também da seguinte forma:
$obj->sql;
Por fim, vamos escrever algo para mostrar que nossa classe funciona:
echo 'O número de linhas encontrado para a consulta '.$sql.' é de '.mysql_num_rows($rs); // Exibe o número de linhas do resultado
Se tudo funcionar, no navegador deve aparecer uma mensagem do tipo:
O número de linhas encontrado para a consulta select * from COLLATIONS é de 127.
Agora temos o código completo para usarmos nossa classe:
/*
* Testando a classe
*/
$obj = new TutoDB; // Instanciando a classe
// Atribuindo valores às propriedades da classe
$obj->set('db','information_schema');
$obj->set('host','localhost');
$obj->set('user','root');
$obj->set('pass','');
$obj->set('sql','select * from COLLATIONS');
$obj->conectar(); // Realiza a conexão
$obj->selecionarDB(); // Seleciona o banco de dados
$rs = $obj->query();
$sql = $obj->getSQL(); // Pega o valor da propriedade $sql
echo 'O número de linhas encontrado para a consulta '.$sql.' é de '.mysql_num_rows($rs); // Exibe o número de linhas do resultado
Agora que sabemos o básico cobre classes, propriedades e métodos, vamos na conclusão abordar os principais conceitos do artigo.
Resumo final
Para finalizar o artigo, faremos um apanhados dos principais conceitos nele abordados:
Classes são blocos de código, geralmente tratando de operações relacionadas (banco de dados, arquivos etc) e que devem ser instanciadas (colocadas na memória) para serem usadas. Isso se faz da seguinte forma:
$variavel = new NomeDaClasse;
Propriedades são variáveis internas da classe que servem para armazenar dados que serão utilizados por métodos.
Para atribuir diretamente dados às propriedades fazemos:
$variavel->nome_da_propriedade = dados a serem atribuídos;
Para “ver” o que está armazenado na propriedade, fazemos o seguinte:
$variavel->nome_da_propriedade;
Métodos são funções internas das classes que realizam alguma coisa, geralmente tomando por base os dados armazenados nas propriedades.
Para executar um método, fazemos o seguinte:
$variavel->metodo();
Dentro dos métodos, as propriedades e outros métodos internos da classe são referenciados utilizando $this:
$this->nome_da_propriedade; $this->nomeDoMetodo();
Espero que o leitor, principalmente o iniciante, tenha aprendido um pouco mais sobre classes, item básico para a compreensão do que é programação orientada a objetos no PHP.
