class
A class is a collection of variables and functions working with
these variables. Variables are defined by var and
functions by function. A class is defined using the
following syntax:
This defines a class named Cart that consists of an associative
array of articles in the cart and two functions to add and remove
items from this cart.
Warning
You can NOT break up a class definition into
multiple files. You also can NOT break a class
definition into multiple PHP blocks, unless the break is within a method
declaration. The following will not work:
However, the following is allowed:
The following cautionary notes are valid for PHP 4.
Caution
The name stdClass is used internally by
Zend and is reserved. You cannot have a class named
stdClass in PHP.
Caution
The function names __sleep and
__wakeup are magical in PHP classes. You
cannot have functions with these names in any of your
classes unless you want the magic functionality associated
with them. See below for more information.
Caution
PHP reserves all function names starting with __ as magical.
It is recommended that you do not use function names with
__ in PHP unless you want some documented magic functionality.
In PHP 4, only constant initializers for var
variables are allowed. To initialize variables with non-constant
values, you need an initialization function which is called
automatically when an object is being constructed from the
class. Such a function is called a constructor (see below).
Classes are types, that is, they are blueprints for actual
variables. You have to create a variable of the desired type with
the new operator.
This creates the objects $cart and
$another_cart, both of the class Cart. The function
add_item() of the $cart object is being called to add 1
item of article number 10 to the $cart. 3 items of
article number 0815 are being added to $another_cart.
Both, $cart and $another_cart, have
functions add_item(), remove_item() and a variable items. These are
distinct functions and variables. You can think of the objects as
something similar to directories in a filesystem. In a filesystem you can
have two different files README.TXT, as long as they
are in different directories. Just like with directories where you'll have
to type the full pathname in order to reach each file from the toplevel
directory, you have to specify the complete name of the function you want to
call: in PHP terms, the toplevel directory would be the global namespace,
and the pathname separator would be ->. Thus, the
names $cart->items and
$another_cart->items name two different variables.
Note that the variable is named $cart->items, not
$cart->$items, that is, a variable name in PHP has
only a single dollar sign.
Within a class definition, you do not know under which name the object
will be accessible in your program: at the time the Cart class was
written, it was unknown whether the object would be named
$cart, $another_cart, or something
else later. Thus,
you cannot write $cart->items within the Cart class
itself. Instead, in order to be able to access its own functions and
variables from within a class, one can use the pseudo-variable
$this which can be read as 'my own' or 'current
object'. Thus, '$this->items[$artnr] +=
$num' can be read as 'add $num to
the $artnr counter of my own items array' or 'add
$num to the $artnr counter of the
items array within the current object'.
Note:
The $this pseudo-variable is not usually defined if
the method in which it is hosted is called statically. This is not,
however, a strict rule: $this is defined if a method is
called statically from within another object. In this case, the value of
$this is that of the calling object. This is
illustrated in the following example:
Note:
There are some nice functions to handle classes and objects. You might want
to take a look at the Class/Object
Functions.