XOOPS Brasil

 

Classes e Objetos (PHP 4)

Índice

class

Uma classe é uma coleção de variáveis e funções trabalhando com essas variáveis. Variáveis são definidas por var e funções por function. Uma classe é definida usando a seguinte sintaxe:

<?php
class CarrinhoDeCompras {
    var 
$items;  // Itens do carrinho de compras

    // Acrescenta a quantidade $num do artigo $artnr no carrinho

    
function add_item($artnr$num) {
        
$this->items[$artnr] += $num;
    }

    
// Retira a quantidade $num de artigos $artnr do carrinho

    
function remove_item($artnr$num) {
        if (
$this->items[$artnr] > $num) {
            
$this->items[$artnr] -= $num;
            return 
true;
        } elseif (
$this->items[$artnr] == $num) {
            unset(
$this->items[$artnr]);
            return 
true;
        } else {
            return 
false;
        }
    }
}
?>

Isto define uma classe chamada CarrinhoDeCompras que consiste de uma matriz associativa de artigos no carrinho e duas funções para acrescentar e remover itens deste carrinho.

Aviso

Você NÃO pode quebrar uma definição de classe em múltiplos arquivos. Você NÃO pode também quebrar a definição de uma classe em múltiplos blocos PHP, a menos que a quebra esteja dentro de uma declaração de método. O seguinte não irá funcionar:

<?php
class test {
?>
<?php
    
function test() {
        print 
'OK';
    }
}
?>

Entretanto, o seguinte é permitido:

<?php
class test {
    function 
test() {
?>
<?php
        
print 'OK';
    }
}
?>

Os cuidados a seguir devem ser tomados a partir do PHP 4:

Cuidado

O nome stdClass é utilizado internamente pela Zend e é uma palavra reservada. Você não pode ter uma classe chamada stdClass no PHP.

Cuidado

O nome de função __sleep e __wakeup são especialmente para as classes mágicas do PHP. Você não pode ter esses nomes em nenhuma de suas classes a não ser que você deseje aplicar essa funcionalidade mágica com elas. Veja abaixo para mais detalhes.

Cuidado

O PHP reserva todos os nomes de funções começando com __ como mágicas. É recomendável que você não utilize nome de funções começando com __ no PHP a não ser que você precise dessas funcionalidades mágicas.

No PHP 4, somente inicializações com constantes são permitidas para variáveis com var. Para inicializar variáveis com valores não constantes, você precisará de uma função de inicialização chamada automaticamente quando o objeto for construído a partir da classe. Por isso, essa função é conhecida como construtor (veja baixo).

<?php
class CarrinhoDeCompras {
    
/* Nenhuma delas funcionarão com o PHP 4 */
    
var $data_de_hoje date("Y-m-d");
    var 
$nome $primeiro_nome;
    var 
$proprietario 'Fred ' 'Jones';
    
/* Mas array contendo valores constantes irao */
    
var $items = array("VCR""TV");
}

/* Esta é a forma como deve ser feito */
class CarrinhoDeCompras {
    var 
$data_de_hoje;
    var 
$nome;
    var 
$proprietario;
    var 
$items = array("VCR""TV");

    function 
CarrinhoDeCompras() {
        
$this->data_de_hoje date("Y-m-d");
        
$this->nome $GLOBALS['primeiro_nome'];
        
/* etc. . . */
    
}
}
?>

Classes são tipos, ou seja, são apenas um modelo das variáveis normais. Você pode criar uma variável (ou instância) do tipo desejado com o operador new.

<?php
$carrinho 
= new CarrinhoDeCompras;
$carrinho->add_item("10"1);

$outro_carrinho = new CarrinhoDeCompras;
$outro_carrinho->add_item("0815"3);
?>

Isto cria os objetos $carrinho e $outro_carrinho, ambos a partir da classe CarrinhoDeCompras. A função add_item() do objeto $carrinho foi chamada e acrescentou 1 item do artigo número 10 a $carrinho. 3 itens do artigo número 0815 foi acrescentado no $outro_carrinho.

Ambos, $carrinho e $outro_carrinho, tem as funções add_item(), remove_item() e a variável itens. Elas são funções e variáveis distintas entre si. Você pode pensar no objetos como os diretórios de um sistema de arquivos. Num disco você pode ter dois arquivos diferentes README.TXT, partindo de que eles estão em diretórios diferentes. Da mesma forma que você teria de especificar o caminho completo para acessar cada arquivo a partir do diretório principal, você também tem de especificar o nome completo do objeto e função que você quer chamar. No PHP o diretório principal pode ser o escopo global de nomes, e o separador de diretórios ->. Portanto, os nomes $carrinho->items e $outro_carrinho->items são duas variáveis diferentes. Note que a variável é chamada $carrinho->items, não $carrinho->$items, mesmo porque, um nome de variável em PHP tem apenas um único sinal de cifrão.

<?php
// correcto, apenas um $
$carrinho->items = array("10" => 1);

// inválido, porque $carrinho->$items se transforma em $carrinho->""
$carrinho->$items = array("10" => 1);

// correto, mas pode ou não ser o que você quer:
// $carrinho->$myvar se torna $carrinho->items
$myvar 'items';
$carrinho->$myvar = array("10" => 1);
?>

Quando definindo uma classe, você não pode saber com que nome os objetos serão acessados em seus programas: enquanto escrevia a classe CarrinhoDeCompras, é impossível saber se o objeto criado a partir dela será chamado $carrinho ou $outro_carrinho (ou ainda ambos). Assim, você não pode escrever $carrinho>items dentro da própria classe CarrinhoDeCompras. Entretanto, para poder acessar suas próprias funções e variáveis de dentro da classe, pode-se utilizar a pseudo-variável $this, que pode ser lida como 'eu mesmo' ou 'objeto atual'. Dessa forma, '$this->items[$artnr] += $num' pode ser lido como 'acrescente $num para o contador $artnr do meu array items' ou 'acrescente $num para o contador $artnr do array items do objeto atual'.

Nota: A pseudo-variável $this não é normalmente definida em um método que seja chamado estaticamente. Isto não é, entretanto, uma regra estrita: $this é definido se um método é chamado estaticamente a partir de outro objeto. Neste caso, o valor de $this será do objeto que o chamou. Isto é ilustrado no exemplo a seguir:

<?php
class A
{
    function 
foo()
    {
        if (isset(
$this)) {
            echo 
'$this is defined (';
            echo 
get_class($this);
            echo 
")\n";
        } else {
            echo 
"\$this is not defined.\n";
        }
    }
}

class 
B
{
    function 
bar()
    {
        
A::foo();
    }
}

$a = new A();
$a->foo();
A::foo();
$b = new B();
$b->bar();
B::bar();
?>

O exemplo acima irá imprimir:

$this is defined (a)
$this is not defined.
$this is defined (b)
$this is not defined.

Nota: Há funções muito boas para manipulação de classes e objetos. Dê uma olhada em Funções de Classes e Objetos