|
Classes e Objetos (PHP5) - Visibilidade, Construtores e Destrutores
por John Marques
Neste artigo ensino o que é e como funciona a visibilidade, os construtores e destrutores dentro de promação orientada à objetos no PHP5.
|
Nesse artigo falarei sobre Visibilidade, Construtores e Destrutores, tambem falarei sobre outras coisas relacionadas, usarei um único código como exemplo e tentarei detalhar o máximo possível.
Primeiro irei falar sobre os conceitos..
Visibilidade
O PHP5 podemos determinar a visibilidade dos Membros ou dos Métodos, simplesmente prefixando com as palavras-chave:
public:
Os items declarados como public podem ser acesso por qualquer um, podendo ser acessado pela própria classe, pela classe de herança e pelo objeto.
protected:
Esta determina que o item será acesso apenas pela classe que criou o item e pela classe que recebe a herança.
private:
Esta palavra-chave permite que somente a classe criadora do item possa acessa-lá.
Nota:
"O uso da declaração de variável com a palavra-chave "var" não é mais válida para objetos do PHP 5. Para compatibilidade, presumirá-se que uma variável declarada no php tenha visibilidade public, e um aviso E_STRICT será mostrado na tela." (manual do PHP)
Construtores
Ele é usado quando se inicializa um objeto, até antes do PHP5, o construtor era um método com o mesmo nome da classe, no PHP5 é usado o método __construct, mas o interessante é o seguinte, vamos supor que a classe que a pessoa criou não exista o método __construct, ai então o php faz como no PHP4, irá procurar um método com o mesmo nome da classe.
O construtor serve para inicializar comandos que o programador deseje, mais abaixo ficará claro no código.
Destrutores
Este método foi inserido no PHP5, vem com um conceito similar à outras linguagens orientadas a objetos, como o java.
"Os destrutores são funções que se encarregam de realizar as tarefas que se necessita executar quando um objeto deixa de existir. Quando um objeto já não está referenciado por nenhuma variável, deixa de ter sentido que esteja armazenado na memória, portanto, o objeto deve ser destruído para liberar seu espaço. No momento de sua destruição, a função se chama destrutor, que pode realizar as tarefas que o programador estime oportuno realizar.
A criação do destrutor é opcional. Somente devemos criá-lo, se desejarmos fazer alguma coisa quando um objeto se elimine da memória." (CriaWeb)
Então tá agora que sabemos dos conceitos vamos para o código.
<?php
class operacoes
{
// Membros
// aqui declaramos os tipos dos membros
public $v1;
public $v2;
protected $res;
/*
Construtor:
Nele setamos os valores dos membros de $v1 e $v2
*/
function __construct()
{
$this->setV1(10);
$this->setV2(3);
}
//Destrutor
function __destruct()
{
echo "eu sou um destrutor";
}
//Um método
public function soma()
{
return $this->res = $this->v1 + $this->v2;
}
/*
Observe que na função subtração eu não uso a palavra-chave
public, pois o PHP5 entende que qualquer método que não
seja setado sua visibilidade terá como visão total ou seja
será "public", então tanto faz colocarmos public ou não
colocar nada na frente de um método que vai dar na mesma,
ja no caso do protected e private é necessário que seja setado.
*/
function subtracao()
{
return $this->res = $this->v1 - $this->v2;
}
protected function multiplicacao()
{
return $this->res = $this->v1 * $this->v2;
}
protected function divisao()
{
return $this->res = $this->v1 / $this->v2;
}
// Privamos o método para o uso somente da classe operacoes.
private function modulo()
{
return $this->res = $this->v1 % $this->v2;
}
public function ret_modulo()
{
return $this->modulo();
}
public function setV1($valor)
{
$this->v1 = $valor;
}
public function setV2($valor)
{
$this->v2 = $valor;
}
public function getV1()
{
return $this->v1;
}
public function getV2()
{
return $this->v2;
}
}
?>
|
Crie duas classes para explicar a visibilidade dos métodos pois se fosse somente explicado a visiblidade dos membros, era necessário somente a classe operacoes.
<?php
class exec_op extends operacoes
{
//determino o membro como privado
private $r;
function __construct()
{
//o comando abaixo determina que o construtor da classe
//pai deve ser usado
parent::__construct();
}
function __destruct()
{
//Da mesma forma que no construtor desta classe..
//o destrutor do pai deve ser usado
parent::__destruct();
}
public function print_soma($v1 = "", $v2 = "")
{
if ($v1 != "") {
$this->setV1($v1);
}
if ($v2 != "") {
$this->setV2($v2);
}
$this->r = $this->soma();
$this->imp();
}
public function print_modulo($v1 = "", $v2 = "")
{
if ($v1 != "") {
$this->setV1($v1);
}
if ($v2 != "") {
$this->setV2($v2);
}
$this->r = $this->ret_modulo();
$this->imp();
}
public function imp()
{
echo $this->r."<br>";
}
}
$exec = new exec_op();
// Retornará 13
$exec->print_soma();
//Retornará 1
$exec->print_modulo();
// Gera um erro "Fatal error: Call to private method
// operacoes::modulo() from context '' in operacoes.php on line xx"
echo $exec->modulo();
// Gera um erro "Fatal error: Call to protected method
// operacoes::divisao() from context '' in operacoes.class.php on line xx"
echo $exec->divisao();
// Retornará 7
echo $exec->subtracao();
// Gera um erro "Fatal error: Call to protected method
// operacoes::multiplicacao() from context '' in operacoes.class.php on line 122
echo $exec->multiplicacao();
?>
|
Galera muito obrigado. Tomara que eu tenha ajudado, eu acredito que este artigo serve para ajudar aqueles que estão iniciando em OOP no PHP5.
Abraço a todos,
John Marques
|
|
|
