


BUSCARDOR

Clases y Objetos (PHP 4)

Manual de PHP
Anterior		Siguiente

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.

Anterior	Inicio	Siguiente
Funciones internas (incorporadas)	Subir	`extends`