PHP 5.4.36 Released

class

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

<?php
class Cart {
    var $items;  // Itens no seu carrinho

    // Adiciona $num artigos com $artnr ao carrinho

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

    // Remove $num artigos de $artnr do seu 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 a classe chamada Cart que consiste em um array associativo de artigos no carrinho e duas funções para adicionar e remover itens deste carrinho.

Aviso

Você não pode quebrar uma definição de classe, em múltiplos arquivos. Você também não pode quebrar uma definição de classe em múltiplos blocos de PHP, exceto que esta quebra se dê dentro da declaração de um método. O código a seguir não irá funcionar:

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

Todavia, o código abaixo é permitido:

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

As seguintes notas de advertência são válidas para PHP 4.

Cuidado

O nome stdClass é utilizado internamente pelo motor Zend e é reservado. Você não pode criar uma classe chamada stdClass em PHP.

Cuidado

Os nomes de função __sleep e __wakeup são métodos mágicos no PHP. Você não pode ter métodos com estes nomes em nenhuma de suas classes a não ser que você queira se aproveitar da funcionalidade mágica associadada a eles. Veja abaixo mais informações.

Cuidado

O PHP reserva todos os nomes de funções iniciados com __ como mágicos. É recomendado que você não crie funções com __ em PHP não ser que você queira se aproveitar da funcionalidade mágica associadada a eles.

No PHP 4, não são permitidas inicializações de variáveis através da palavra-chave var com valores não constantes. Para inicializar variáveis com algum valor não constante, você precisa efetuar a atribuição de valores através do método construtor que é automaticamente executado na inicialização de um novo objeto. Veja o exemplo abaixo:

<?php
class Cart {
    
/* Estas inicializações NÃO funcionam no PHP 4. */
    
var $todays_date date("Y-m-d");
    var 
$name $firstname;
    var 
$owner 'Fred ' 'Jones';
    
/* Arrays contendo valores constantes funcionarão. */
    
var $items = array("VCR""TV");
}

/* Esta é a maneira como deve ser feito no PHP4. */
class Cart {
    var 
$todays_date;
    var 
$name;
    var 
$owner;
    var 
$items = array("VCR""TV");

    function 
Cart() {
        
$this->todays_date date("Y-m-d");
        
$this->name $GLOBALS['firstname'];
        
/* etc... */
    
}
}
?>

Classe são tipos, isto é, elas são modelos para objetos (variáveis). Para criar um objeto você deve atribuir a uma variável uma nova instância classe desejada utilizando o operador new.

<?php
$cart 
= new Cart;
$cart->add_item("10"1);

$another_cart = new Cart;
$another_cart->add_item("0815"3);
?>

O código acima cria os objetos $cart e $another_cart, ambos da classe Cart. A função add_item() do objeto$cart está sendo chamada para adicionar um item do artigo de número 10 ao carrinho. Três items do artigo de número 0815 são adicionados ao carrinho $another_cart.

Ambos, $cart e $another_cart, possuem as funções add_item(), remove_item() e a variável (propriedade) items. Estas são funções e variáveis distintas em cada objeto. Você pode pensar nos objetos como algo semelhante a diretórios em um sistema de arquivos. Em um sistema de arquivos você pode possuir dois (ou mais) diferentes arquivos chamados README.TXT, desde que estejam em diretórios diferentes. Assim como os diretórios onde você têm de utilizar o nome completo do caminho para encontrar cada arquivo na hierarquia do sistema, você deve especificar o nome completo da função que você deseja chamar: em termos de PHP 4, o diretório raiz será o namespace global e o separador de pastas será ->. Deste modo, os nomes $cart->items e $another_cart->items nomeiam suas variáveis diferentes. Note que a variável é chamada $cart->items, não $cart->$items, isto é a variável em PHP só possui um único dólar ($).

<?php
// correto, um único $
$cart->items = array("10" => 1); 

// inválido, porque $cart->$items se torna $cart->""
$cart->$items = array("10" => 1);

// correto, mas pode ou não ser a real intençaõ:
// $cart->$myvar se torna $cart->items
$myvar 'items';
$cart->$myvar = array("10" => 1);  
?>

Em uma definição de classe, você não sabe com qual nome seu objeto será instanciado em seu programa: quando a classe Cart foi escrita, não se sabia se o objeto iria se chamar $cart, $another_cart, ou qualquer outro nome. Desse modo você não pode escrever $cart->items no próprio código da classe Cart. Ao invés disso, para acessar as próprias funções e variáveis de uma classe de dentro da própria classe, você pode utilizar a pseudo-variável $this a qual pode ser lida como 'meu(minha) próprio(a)' ou 'objeto corrente'. Assim, '$this->items[$artnr] += $num' pode ser lido como 'adicione $num ao contador $artnr de itens do meu próprio array' ou 'adicione $num ao contador $artnr de items do array do objeto corrente'.

Nota:

A pseudo-variável $this geralmente não é definida se o método em questão é chamado estaticamente. Isto não é, no entanto, uma regra estrita pois caso a chamada estática seja feita por meio de outro objeto $this será definido como o objeto que está efetuando a chamada. Para ilustrar esta questão visualize o exemplo a seguir:

<?php
class A
{
    function 
foo()
    {
        if (isset(
$this)) {
            echo 
'$this foi definido (';
            echo 
get_class($this);
            echo 
")\n";
        } else {
            echo 
"\$this não foi definido.\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 foi definido (a)
$this não foi definido.
$this foi definido (b)
$this não foi definido.

Nota:

Existem algumas funções interessantes para manipular classes e objetos. Você pode querer dar uma olhada em Funções para Classes/Objetos.

add a note add a note

User Contributed Notes 4 notes

up
0
masonswolf at gmail dot com
2 years ago
You can invoke a class above its definitions in some cases, but there are very important exceptions to this behavior. If your class extends another class, and the interpreter doesn't see the extended class first, then it won't be added to the symbol table until the code has stepped through it in runtime. As a result, if you try to invoke it above the definition, you'll get a "class not found" fatal error.

And those suck.

So, to provide an example, the following will output a fatal error
<?php
Bar
::bar();
exit;

class
Bar extends Foo { } //will fatal because Foo not seen yet

class Foo {
    static function
bar() { echo 'yep, this is Foo::bar'; }
}
?>

However, THIS code will work just fine:
<?php
Bar
::bar();
exit;

class
Foo {
    static function
bar() { echo 'yep, this is Foo::bar'; }
}

class
Bar extends Foo { } //will work because Foo came first
?>

Notice that if you include a file containing the class you will extend, and then extend the class in the same file as its invocation, you can also get the class not found fatal. This happens even if the 'include' call happens before the child class's definition.

Eg. the following will also output a fatal error
<?php
include_once('file_with_foo.php');

Bar::bar();
exit;

class
Bar extends Foo { }
?>

Hope that clarifies things.
up
-1
anthonymccuen at yahoo dot com
1 year ago
You can also use "var" to declare multiple public instance variables like in C:

int main(int *argc, const char *argv[]) {
    int a, b, c, d, e, f;
   
    a = 50;
    // blah blah blah code here
    // ...
   
    return 0;
}

Same as PHP:

<?php
class MyClass {
    var
$myvar, $anotherVar, $something, $str;
}
?>
up
-3
boukeversteegh at gmail dot com
4 years ago
You can also instantiate objects using variables containing the name of the class:

<?php

$type
= 'Foo';
$foo   = new $type();

print_r( $foo );
/* Prints:
Foo Object
(
)
*/
?>

The following works as well:
<?php

$somefoo   
= new Foo();
$anotherfoo = new $somefoo();

# so you don't have to do:
$anotherfoo = new get_class( $somefoo)();
?>
up
-5
pov at fingerprint.fr
3 years ago
I just discovered a behaviour that has to be mentioned.

Let's consider the following file

<?php
Foo
::bar();
exit;

class
Foo {
  function
bar() { echo 'yep, this is Foo::bar'; }
}
?>

You may expect :
- an error on the Foo::bar call, because the class is not defined
- removing the code after the exit without side-effect

But it won't, and it will output the string !
It seems every class definition is executed at parse-time.

But without errors; if your file is
<?php
Foo
::bar();
exit;

class
Foo {
  function
bar() { echo 'yep, this is Foo::bar'; }
}
class
Foo {
  function
bar() { echo 'yep, this is another Foo::bar'; }
}
?>
it will still output the first string, not doing any "Already exiting class" error !

So if you intend preventing a double include by doing in an included file :
<?php
if (class_exists('Foo')) { return; }

class
Foo {
  static function
register() { ... }
}
Foo::register();
?>
the Foo::register method won't be called !

Very strange development choice; I suppose it is due to ascending compatibility.
Hope it can help...
To Top