PHP Orientado a Objetos para quem está começando

imagem-topo-php-oo-iniciante

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:

<?php
class NomeDaClasse {
   // Algum código aqui
}
?>

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.

<?php
class NomeDaClasse {
   // As propriedades e ...
   $propriedade;
   $outra_propriedade = 'algum texto';

   // ... os métodos
   function meuMetodo(){
      // Algum código aqui
   }

   function outroMetodo($parametro){
      // Algum código aqui
   }
}
?>

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):

<?
/*
* Script para estudo sobre PHP e Orientação a Objetos
* @author Everton da Rosa (Everton3x)
* @copyright GPL
* @version 1.0 (21/04/2009)
*/

class TutoDB {
/*
   * Classe para interação com banco de dados
   * @author Everton da Rosa (Everton3x)
   * @version 1.0 (21/04/2009)
   */

   /*
   * Declaração das variáveis (propriedades) da classe
   */
   private $host; // Host (Servidor) que executa o banco de dados
   private $user; // Usuário que se conecta ao servidor de banco de dados
   private $pass; // Senha do usuário para conexão ao banco de dados
   private $db; // Nome do banco de dados a ser utilizado
   private $sql; // String da consulta SQL a ser executada

   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;
   }

   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;
   }
}

?>

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.

Fonte: Código Fonte UOL

Postagens Relacionadas