Overrides in child are called when calling a function from the parent
<?PHP
class Par
{
var $test;
function __construct($in)
{
$this->test = $in;
}
function getTest()
{
return $this->test;
}
function runTest()
{
return $this->getTest();
}
}
class Chi extends Par
{
var $i;
function __construct($in)
{
$this->i = $in;
parent::__construct($in."X");
}
function getTest()
{
return $this->i;
}
function runParentTestA()
{
return parent::runTest();
}
function runParentTestB()
{
return parent::getTest();
}
}
$p = new Par("par");
$c = new Chi("chi");
echo $p->runTest()." == par";
echo $c->runTest()." == chi";
echo $c->runParentTestA()." == chi";
echo $c->runParentTestB()." == chiX";
?>
class
Uma classe é uma coleção de variáveis e funções que trabalham com estas variáveis. As variáveis são definidas com a palavra chave var e funções com a palavra chave function. Uma classe é declarada 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 deve 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 prefixo __ em PHP, a não ser que você queira utilizer as funcionalidades mágicas documentadas.
No PHP 4, apenas são permitidos inicializadores constantes de variáveis através da palavra-chave var. Para inicializar variáveis com algum valor não constante, você precisa de uma função de inicialização que é automaticamente executado na inicialização de um novo objeto da classe. Esse tipo de função é chamada de construtor (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 1 item do artigo de número 10 ao carrinho $cart. 3 itens 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 arquivos diferentes 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 do PHP, 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 diferentes variáveis. 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óprioarray' ou 'adicione $num ao contador $artnr do array items do objeto corrente'.
Nota:
A pseudo-variável $this geralmente não é definida em um método que seja chamado estaticamente. Isto não é, no entanto, uma regra estrita: $this é definida caso um método é chamado estáticamente por meio de outro objeto. Nesta situação o valor de $this será o objeto que está efetuando a chamada. Isso é ilustrado no 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
User Contributed Notes 5 notes
ender911t at gmail dot com ¶
8 years ago
anthonymccuen at yahoo dot com ¶
11 years 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;
}
?>
masonswolf at gmail dot com ¶
11 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.
pov at fingerprint.fr ¶
12 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...
boukeversteegh at gmail dot com ¶
13 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)();
?>
