Manual do PHP
Anterior |  | Próxima

# Capítulo 18. Classes e Objetos(PHP 4)

# `class`

Uma classe é uma coleção de variáveis e funções trabalhando com essas variáveis. Uma classe é definida usando-se 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.

Atenção

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 mágicos para as classes 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

Anterior | Principal | Próxima
Funções internas (built-in) | Acima | `extends`