Clases y Objetos (PHP 4)
Table of Contents
- extends
- Constructores
- Operador de Resolución de Contexto (::)
- parent
- Seriación de objetos, objetos en sesiones
- Las funciones mágicas __sleep y __wakeup
- Las referencias al interior del constructor
- Comparación de objetos
class
Una clase es una colección de variables y funciones que trabajan con estas variables. Las variables son definidas con var y las funciones con function. Una clase es definida usando la siguiente sintaxis:
<?php
class Carrito {
var $items; // Ítems en nuestro carrito de compras
// Agregar $num artículos de $artnr al carrito
function agregar_item($artnr, $num) {
$this->items[$artnr] += $num;
}
// Tomar $num artículos de $artnr del carrito
function retirar_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;
}
}
}
?>
Esto define una clase llamada Carrito que consiste de una matriz asociativa de artículos en el carrito y dos funciones para agregar y eliminar elementos del carrito.
NO es posible separar la definición de una clase en varios archivos. Asimismo NO es posible separar la definición de una clase en bloques PHP diferentes, a menos que la separación sea al interior de una declaración de método. Lo siguiente no funciona:
<?php
class prueba {
?>
<?php
function prueba() {
print 'Bien';
}
}
?>
Sin embargo, lo siguiente es permitido:
<?php
class prueba {
function prueba() {
?>
<?php
print 'Bien';
}
}
?>
Las siguientes notas de precaución son válidas para PHP 4.
El nombre stdClass es usado internamente por Zend y es reservado. No puede tener una clase con el nombre stdClass en PHP.
Los nombres de función __sleep y __wakeup son mágicos en las clases PHP. No puede tener funciones con estos nombres en cualquiera de sus clases a menos que desee usar la funcionalidad mágica asociada con ellas. Vea más información a continuación.
PHP reserva todos los nombres de función que comienzan con __ como mágicos. Se recomienda que no use nombres de función con __ en PHP a menos que desee usar alguna funcionalidad mágica documentada.
En PHP 4, sólo se permiten inicializadores constantes para variables var. Para inicializar variables con valores no-constantes, necesita una función de inicialización que sea llamada automáticamente cuando un objeto es construido a partir de la clase. Tal función es llamada constructora (vea más información a continuación).
<?php
class Carrito {
/* Ninguna de estas expresiones funciona en PHP 4. */
var $fecha_hoy = date("Y-m-d");
var $nombre = $primer_nombre;
var $duenyo = 'Fred ' . 'Jones';
/* Aunque, las matrices que contienen valores constantes funcionan */
var $items = array("VCR", "TV");
}
/* Así es como debe declararse. */
class Carrito {
var $fecha_hoy;
var $nombre;
var $duenyo;
var $items = array("VCR", "TV");
function Carrito() {
$this->fecha_hoy = date("Y-m-d");
$this->nombre = $GLOBALS['primer_nombre'];
/* etc. . . */
}
}
?>
Las clases son tipos, es decir, son planos usados para variables reales. Necesita crear una variable del tipo deseado con el operador new.
<?php
$carrito = new Carrito;
$carrito->agregar_item("10", 1);
$otro_carrito = new Carrito;
$otro_carrito->agregar_item("0815", 3);
?>
Esto crea los objetos $carrito y $otro_carrito, ambos de la clase Carrito. La función agregar_item() del objeto $carrito es llamada para agregar 1 item del artículo número 10 al $carrito. Se agregan 3 items del artículo número 0815 al $otro_carrito.
Ambos, $carrito y $otro_carrito, tienen funciones agregar_item(), retirar_item() y una variable items. Estas son variables y funciones diferentes. Puede pensar sobre los objetos como algo similar a las directorios en un sistema de archivos. En un sistema de archivos es posible tener dos archivos LEAME.TXT diferentes, siempre y cuando estén en directorios diferentes. Tal y como con los directorios, en donde es necesario escribir las rutas de nombres completas para llegar a cada archivo a partir del directorio del nivel superior, es necesario especificar el nombre completo de la función que desea llamar: en términos de PHP, el directorio de nivel superior sería el espacio de nombres global, y el separador de ruta sería ->. De tal modo que los nombres $carrito->items y $otro_carrito->items hacen referencia a dos variables diferentes. Note que la variable se llama $carrito->items, no $carrito->$items, es decir, un nombre de variable en PHP solo tiene un único signo de dólar.
<?php
// correcto, un solo $
$carrito->items = array("10" => 1);
// inválido, ya que $carrito->$items se convierte en $carrito->""
$carrito->$items = array("10" => 1);
// correcto, pero puede o no ser lo que se busca:
// $carrito->$mivar se convierte en $carrito->items
$mivar = 'items';
$carrito->$mivar = array("10" => 1);
?>
Al interior de una definición de clase, no se conoce el nombre bajo el que el objeto será accesible en su programa: en el momento en que la clase Carrito fue escrita, no se conocía si el objeto se llamaría $carrito, $otro_carrito, o algo diferente más adelante. Por lo tanto, no es posible escribir $carrito->items al interior de la clase Carrito. En su lugar, para poder acceder a sus propias funciones y variables desde el interior de una clase, es posible usar la pseudo-variable $this, la cual puede leerse como 'mi propio' o 'el objeto actual'. Por lo tanto, '$this->items[$num_art] += $num' puede leerse como 'agregar $num al contador $num_art de mi propia matriz de items', o 'agregar $num al contador $num_art de la matriz de items al interior del objeto actual'.
Note: Usualmente, la pseudo-variable $this no es definida si el método en el que se encuentra es llamado estáticamente. Sin embargo, esta no es una regla estricta: $this se define si un método es llamado estáticamente desde el interior de otro objeto. En este caso, el valor de $this es aquél del objeto que hace la llamada. Esto se ilustra en el siguiente ejemplo:
<?php
class A
{
function foo()
{
if (isset($this)) {
echo '$this se define (';
echo get_class($this);
echo ")\n";
} else {
echo "\$this no se define.\n";
}
}
}
class B
{
function bar()
{
A::foo();
}
}
$a = new A();
$a->foo();
A::foo();
$b = new B();
$b->bar();
B::bar();
?>El resultado del ejemplo seria:
$this se define (a) $this no se define. $this se define (b) $this no se define.
Note: Existen algunas funciones interesantes que manejan clases y objetos. Puede que quiera echar un vistazo a las Funciones de Clase/Objeto.