Clases y Objetos (PHP 4)
Manual de PHP
AnteriorSiguiente

Cap铆tulo 18. Clases y Objetos (PHP 4)

Tabla de contenidos
class
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 茅stas variables. Una clase es definida usando la siguiente sintaxis:

<?php
class Carrito {
    var $items;  // Items en nuestro carrito de compras

    // Agregar $num articulos de $artnr al carrito

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

    // Tomar $num articulos 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.

Aviso

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.

Atenci贸n

El nombre stdClass es usado internamente por Zend y es reservado. No puede tener una clase con el nombre stdClass en PHP.

Atenci贸n

Los nombres de funci贸n __sleep y __wakeup son m谩gicos en las clases PHP. No puede tener funciones con 茅stos 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.

Atenci贸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");
}

/* Asi 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);

// invalido, 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 que el objeto se llamar铆a $carrito u $otro_carrito 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'.

Nota: 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.

Nota: Existen algunas funciones interesantes que manejan clases y objetos. Puede que quiera echar un vistazo a las Funciones de Clase/Objeto.

AnteriorInicioSiguiente
Funciones internas (incorporadas)Subirextends