Ver índice
Clases y objetos (II)

        Ocultar índice  

   Índice de contenidos
   Instalación en Windows
   Instalación en Ubuntu
   Servidores seguros
   Páginas dinámicas
   Sintaxis básica
   Operaciones
   Arrays
   Formatos de presentación
   Operadores
   Bucles
   Extraer y ord. información
   Funciones
   Ficheros externos
   Imágenes dinámicas
   Gestión de directorios
   Cookies y sesiones
   Clases y objetos
   Ficheros en formato PDF
   Bases de datos MySQL
   PHP y XML
   PDO - Bases SQLite / MySQL
   MySQL a traves de misqli
   Algo de JavaScript y AJAX


Constantes. Variables y métodos estáticos

En la página anterior sólo hemos visto una parte de las opciones de definición y uso de clases y objetos. Intentaremos ampliar un poco más aquellos conceptos.

Constantes

Uno de los elementos no imprescindibles que puede contener una clase son las constantes. Para definirlas debemos escribir:

const nombre = valor

dónde const es una palabra reservada que establece la condición de constante, nombre es el nombre de la propia constante (no va precedido de $) y valor el número o cadena alfanumérica asignada a esa constante.

Variables estáticas y métodos estáticos

Las propiedades que hemos estudiado en la página anterior son conocidas como propiedades y también como variables de objeto. Sin embargo pueden definirse otro tipo de variables conocidas como variables de clase, variables estáticas o simplemente estáticas.

Se caracterizan por ser inherentes a la propia clase pudiendo existir y ser utilizadas sin necesidad de instanciar ningún objeto. Es decir, no forman parte de los objetos. A modo de ejemplo podríamos decir que entre las propiedades de una perforada puede estar la de hacer funciones de cascanueces y que para hacer uso de esta propiedad (partir una nuez) no se requiere de ninguno de los objetos específicos (hojas de papel o cualquier otro objeto susceptible de ser perforado) para los que fué diseñada la perforada (la clase).

Son ese tipo de propiedades inherentes a la propia clase y que no requieren de un objeto para ser utilizadas las conocidas como estáticas. Para definirlas basta anteponer al nombre de la propiedad la palabra reservada static.

La sintaxis podría ser así:

static nombre = valor

La condición de estática de una propiedad no es incompatible con la gestión de su visibilidad. Es perfectamente factible utilizar variables definidas como: public static, private static ó reserved static. Por una cuestión de compatibilidad con PHP4 en los casos en los que solo se indique static tendrá la consideración de public static. Aquí tienes algunos ejemplos de definiciones válidas:

public static $pepe="Jose"
static $lola="Dolores"
private static $rosa="Rosa"

Por lo que respecta a métodos estáticos (tampoco requieren definir un objeto para poder utilizarlos) la sintaxis es similar a la anterior.

Acceso a constantes y a variables y métodos estáticos

Las variables estáticas, las constantes y los métodos definidos como estáticos tienen la peculiaridad de que pueden ser utilizados sin necesidad de haber creado o instanciado ningún objeto. Para acceder a ellos se usa, en vez del tradicional ->, el operador :: conocido como doble dos puntos, operador de resolución de ámbito o Paamayim Nekudotayim

Para acceder a este tipo de variables y/o constantes sin instanciar un objeto debemos utilizar la siguiente sintaxis:

$variable1= nombreClase::constante

recoge en $variable1 el valor de la constante establecida en la clase nombreClase. Los caracteres (::) son obligatorios y reservados.

$variable2= nombreClase::$variable_estatica

recoge en $variable2 el valor de la $variable_estatica correspondiente a la clase nombreClase. Los caracteres (::) son obligatorios y reservados. El nombre de la variable, a diferencia de lo que ocurre con variables no estáticas, debe ir precedido del carácter $.

$variable3= nombreClase::metodo_estatico()

recoge en $variable3 el resultado de la ejecución del netodo_estatico() correspondiente a la clase nombreClase. Los caracteres (::) son obligatorios y reservados. El paréntesis puede incluir eventuales valores de los argumentos de la función.

Si lo que pretendemos es acceder a la variables o métodos estáticos a partir de una instancia de objeto perteneciente a su clase utilizaremos la sintaxis:

$objeto :: constante , $objeto :: variable_estatica o $objeto :: metodo_estatico()

y en el caso de ejercer esta opción desde un método de la propia clase lo haríamos con la misma sintaxis pero sustituyendo $objeto por el pseudobjeto $this.

Cuando el acceso a constantes, variables o métodos estáticos se produce desde un método de la propia clase puede sustituirse nombreClase por la palabra reservada self (yo mismo). Obsérvalo en los ejemplos. Este primero gestiona únicamente constantes y elementos estáticos.

 <?php
  class MiClase {
    /* definimos constantes */
    const cadena1="Soy una cadena";
    const cadena2=1.234;
    /* aqui usamos sintaxis de documento incrustado */
    const cadena3=<<<'cde'
    Soy una cadena incluida dentro de una constante
    mediante la sintaxis de documento incrustado.
    Esta sintaxis funciona siempre que la versión
    de PHP sea superior a 5.3
cde;
    /* definimos una variable estática */
    public static $estatica=<<<'fdg'
    Soy una variable estática y soy pública. Tanto yo como las constantes
    podemos ser visualizadas sin necesidad de crear un objeto.
    Utilizando  :: puede vérseme sin problemas.
fdg;

/* incluyamos dos funciones definidas como estáticas */

   public static function mi_estatica($a,$b){
        return pow($a, $b)*self::cadena2- MiClase::otra_estatica($a,$b);
   }

   public static function otra_estatica($a=3,$b=2){
        return pow($b, $a) + MiClase::cadena2;
   }

}
/* he escrito la clase pero no voy a crear ningún objeto.
   Visualizo los elementos y ejecutaré los métodos estáticos */
print MiClase::cadena1."<br />";
print MiClase::cadena2."<br />";
print MiClase::cadena3."<br />";
print MiClase::$estatica."<br />";
print MiClase::mi_estatica(6,5)."<br />";
print MiClase::otra_estatica()."<br />";
?>
ejemplo306.php

  ¡Cuidado!  

La sintaxis de documento inscrutado no funciona en versiones de PHP inferiores a la 5.3.
Ocurre lo mismo con $objeto :: constante , $objeto :: variable_estatica o $objeto :: metodo_estatico() que en versiones inferiores han de ser sutituidos por: Nombre_de_la_Clase::constante , Nombre_de_la_Clase::variable_estatica o Nombre_de_la_Clase::metodo_estatico()

En este otro ejemplo estamos mezclando llamadas a variables y métodos estáticos junto con otros que lo no son. Todos tienen en común la condición de visibilidad pública.

 <?php
/* definimos una clase */
class MiPagina { 
  /* establecemos los valores de las constantes y las variables
    cuidando que todas estas sean publica */
  const cabeza1="<html><head><title>";
  static $titulo="Probando clases y objetos";
  const cabeza2="</title></head><body bgcolor='";
  public $color='yellow';
  const cabeza3="'>"; 
  public $cuerpo=<<<'CUERPO'
    Las clases en PHP permiten la sintaxis
    de <b>documento incrustado</b> solo a partir de la
    versión 5.3.<br /> En esta página utilizamos constantes
    y propiedades de tipo <b>public</b> (las estáticas siempre lo son).
Por esa razón son accesibles desde cualquier lugar.<br /> Modificaremos el <i>color de fondo</i> y el <i>título</i>. CUERPO;
public $pie="</body></html>"; /* en este caso la clase no incluye ningún método */ } /* creamos un nuevo objeto instanciando esta clase */ $MiObjeto= new MiPagina; /* modificamos el color y el título. Observa la diferente forma en que tratamos las variables estáticas */ $MiObjeto->color='Coral'; /* cambiamos el valor de la variable estática $titulo; MiPagina::$titulo='Ha cambiado el titulo de esta pagina'; /* visualizamos los diferentes elementos (constantes, variables y variables estáticas aplicando la sintaxis adecaduada a cada caso) */ print $MiObjeto::cabeza1; print $MiObjeto::$titulo; print $MiObjeto::cabeza2; print $MiObjeto->color; print $MiObjeto::cabeza3; print $MiObjeto->cuerpo; print $MiObjeto->pie; ?>
ejemplo307.php

Aquí tienes un tercer ejemplo en el se utilizan distintos tipos de visibilidades

ejemplo308.php Ver código fuente

Métodos y/o propiedades con el mismo nombre en clases extendidas

Cuando una clase incluye un método o propiedad cuyo nombre coincide con el de otro método o propiedad de una de sus clases extendidas los objetos utilizarán los métodos o propiedades de la clase que ha sido instanciada para crearlos. Esta situación, conocida bajo el nombre de polimorfismo (varias formas de un mismo método) es algo muy habitual en la programación orientada a objetos.

Hay que tener en cuenta que cuando se trata de constantes, variables estáticas o métodos estáticos que no requieren un objeto puede accederse indistintamente a los de una u otra clase por medio de la siguiente sintaxis:

nombre_de_clase:: constante, variable o método

pudiendo también reemplazarse el nombre_de_clase por un objeto de esa misma clase.

La cuestión es: ¿puede accederse desde un objeto de una clase extendida a un método de la clase padre cuano se da una coincidencia de nombres?. La respuesta es sí. Una posibilidad es utilizar esta sintaxis:

nombre_de_la_clase_padre :: nombre_del_metodo()

dónde se ejecutaría el método nombre_del_metodo() de la forma en que está definido en la clase nombre_de_la_clase_padre. Otra forma de hacerlo sería dotar a la clase extendida de un método similar a este:

function intermediaria () {
        return parent::metodo();
}

de esta forma la función intermediaria devolverá (return) el resultado de ejecutar el método de la clase padre (parent). Observa en el ejemplo los resultados las diferentes opciones.

<?php
/* creamos las clases A, B extendida de A */
class A {
  /* habrá en la clase extendida otra constante con el mismo nombre CONSTANTE*/
  const CONSTANTE=3.141592;
  /* Hay otra variable estática con el mismo nombre (estatica) en la clase B */
   public static $estatica="Soy la variable publica estática de la clase A";
   /* Hay otra variable publica con el mismo nombre (variable) en la clase B */
   public $variable=" Soy publica y de la clase A";
   /* incluimos un contructor en la clase padre */
   function __construct(){
          print "<br><b>Se instanció un objeto de la clase A.</b> <br>";
     }
   /* Hay otro metodo estático con el mismo nombre (estatico )en la clase B */
   public static function estatico(){
          return "Me envía el método estático de la clase A (padre)";
   }
   /* Hay otro metodo con el mismo nombre (metodo)en la clase B */
   public static function metodo(){
          return "Me llamo método y soy de la clase A (padre)";
   }
}

class B extends A{
   /* Hay otra constante con el mismo nombre CONSTANTE en la clase A (padre)*/
   const CONSTANTE=6.28;
   /* Hay otra variable estática con el mismo nombre (estatica) en la clase A (padre)*/
   public static $estatica="Soy una variable publica estática de la clase B";
    /* Hay otra variable publica con el mismo nombre (variable) en la clase A (padre) */
   public $variable=" Soy publica y de la clase B";
   /* incluimos un contructor en la clase extendida */
    function __construct(){
          print "<br><b>Se instanció un objeto de la clase B</b><br>";
     }
     /* Hay otro metodo estático con el mismo nombre (estatico )en la clase A (padre) */
     public static function estatico(){
          return "He surgido del método estático de la clase B";
     }
     /* Hay otro metodo con el mismo nombre (metodo)en la clase A padre */
   public static function metodo(){
          return "Me llamo método y soy de la clase B";
   }
     /* Creo una funcion puente para poder acceder a métodos de la clase padre
        que tienen un nombre coincidente con uno de de la extendida */
   public static function puente(){
          return parent::metodo();
   }
}
/* creamos un objeto instanciando la clase A */
$objeto_clase_A= new A();
/* creamos un objeto instanciando la clase B */
$objeto_clase_B= new B();

print "<br><br>LECTURA DE CONSTANTES<br>";
print "<br>\$objeto_clase_A::CONSTANTE= ".$objeto_clase_A::CONSTANTE;
print "<br>\$objeto_clase_B::CONSTANTE= ".$objeto_clase_B::CONSTANTE;
print "<br>A::CONSTANTE= ".A::CONSTANTE;
print "<br>B::CONSTANTE= ".B::CONSTANTE;

print "<br><br>LECTURA DE VARIABLES ESTÁTICAS<br>";
print "<br>\$objeto_clase_A::\$estatica= ".$objeto_clase_A::$estatica;
print "<br>\$objeto_clase_B::\$estatica= ".$objeto_clase_B::$estatica;
print "<br>A::\$estatica= ".A::$estatica;
print "<br>B::\$estatica= ".B::$estatica;

print "<br><br>LECTURA DE VARIABLES PUBLICAS<br>";
print "<br>\$objeto_clase_A->variable= ".$objeto_clase_A->variable;
print "<br>\$objeto_clase_B->variable= ".$objeto_clase_B->variable;

print "<br><br>EJECUCIÓN DE METODOS ESTATICOS<br>";
print "<br>\$objeto_clase_A::estatico()= ".$objeto_clase_A::estatico();
print "<br>\$objeto_clase_B::estatico()= ".$objeto_clase_B::estatico();
print "<br>A::estatico()= ".A::estatico();
print "<br>B::estatico()= ".B::estatico();


print "<br><br>EJECUCIÓN DE METODOS <br>";
print "<br>\$objeto_clase_A->metodo()= ".$objeto_clase_A->metodo();
print "<br>\$objeto_clase_B->metodo()= ".$objeto_clase_B->metodo();
print "<br>A::metodo()= ".A::metodo();
print "<br>También podemos recurrir a la función puente para ejecutar el método de la clase padre";
print "<br>\$objeto_clase_B->puente()= ".$objeto_clase_B->puente();
?>
ejemplo310.php

Funciones con clases y objetos

Existen también algunas funciones que pueden resultarte útiles a la hora de depurar los scripts en los que manejes clases y objetos. Son las siguientes:

method_exists(objeto, nombre_funcion)

Comprueba si está definida la función nombre_funcion (entenderemos función y método como sinónimos) en el objeto $objeto. Devuelve un valor booleano. Cierto (true) en el caso de que exista esa función o falso (false) en el caso de que no exista.

get_class_vars(nombre_de_la_clase)

Crea un array asociativo cuyos índices son los nombres de las propiedades de la clase nombre_de_la_clase y cuyos valores coinciden con los valores preasignados a cada una de esas propiedades. En este array solo se recogen las variables que han sido inicializadas asignándoles un valor.

get_class_methods(clase)

Devuelve un array conteniendo los valores de todos los métodos (funciones) definidas en la clase.

get_object_vars(objeto)

Devuelve las variables visibles (y sus valores) contenidas en el objeto.

Incluyendo clases desde ficheros externos

A lo largo de nuestros ejemplos hemos guardado muchas de las clases en ficheros independientes y posteriormente las hemos incluido en los script mediante las funciones include o require_once. No habría restricción en cuanto al nombre a utilizar, sin embargo, resulta muy aconsejable fijar una metodologia simple y cómoda para hacerlo. Si establecemos la pauta de guardar siempre los ficheros que contienen una clase con el nombre de la propia clase (exactamente el nombre de la misma) seguido de una extensión que también vamos a mantener fija y que podría ser, por ejemplo, .class.php podemos hacer uso de una comodísima función (__autoload) que intentaremos concretar con el ejemplo y que comentamos en él.

Hemos duplicado el fichero ejemplo299.php de la página anterior (aquí está su código fuente) y lo hemos guardado como MiClase.class.php porque MiClase es precisamente el nombre de la clase que contiene.

 <?php
 function __autoload($nombre_de_clase){
                include $nombre_de_clase .'.class.php';
      }
/* esta funcion se encarga de que cada vez que sea instanciada una clase
se cargue mediante include el fichero cuyo nombre coincide con el de la clase
y cuya extensión es .class.php. De este modo ya podemos despreocuparnos
de incluir clases. */

$objeto= new MiClase;
/* se cargaría la clase MiClase.class.php y se crearía el objeto
A partir de aquí comprobaremos los resultados de las diferentes funciones
informativas visualizando sus resultados mediante print_r con lo cual
estaremos en condiciones de visualizar de forma cómoda nombres de variables
y/o métodos y sus valores */
print "<br />Resultados de var_dump<br /><br /><pre>";
var_dump($objeto);
print "</pre><br /><br />Resultados de print_r<br /><br /><pre>";
print_r($objeto);
print "</pre><br /><br />Resultados de var_export<br /><br /><pre>";
var_export($objeto);
print "</pre><br /><br />Resultados de get_object_vars<br /><br /><pre>";
print_r(get_object_vars($objeto));
print "</pre><br /><br />Resultados de get_class_methods<br /><br /><pre>";
print_r(get_class_methods($objeto));
print "</pre><br /><br />Resultados de get_class_vars<br /><br /><pre>";
print_r(get_class_vars('MiClase'));
method_exists('MiClase','lee') ? print "<br>Existe el método"  : print "<br>No existe el método";
method_exists('MiClase', 'calcula')? print "<br>Existe el método"  : print "<br>No existe el método";
print "</pre>";
?>
 
ejemplo309.php

Objetos únicos

La utilización de clases está íntimamente ligada a la creación de objetos (en plural). Si pensamos en un centro de enseñanza veremos que varias son las aulas, los profesores o los alumnos. Pero puede que nos planteemos que el centro como tal sea un objeto único. Para aquellos casos en los que queramos impedir la creación de más de un objeto podría ser aplicable el procedimiento descrito en este ejemplo.

<?php
/* escribiremos una clase cuyos único objeto sea un centro educativo.
Para poder utilizar la función __autoload el fichero tendrá como nombre
Centro.class.php que coincide con el nombre de la clase */
class Centro{
      /* establecemos las propiedades con condición de protegidas*/
  protected $nombre="I.E.S. «Las Pruebas y los Objetos»";  //nombre del centro
  protected $identificador="Q337777777x"; //podría ser el N.I.F.
  protected $localidad="Fuentes de Narcea (Degaña)"
  protected $aulas=array(); // será un array destinado a contener  aulas (objetos de otra clase)
  /* insertamos un costructor con visibilidad protegida.
     Así evitamos que pueda ser invocado desde fuera de la clase o de sus extendidas */
  protected function __construct(){
    print "Objeto creado satisfactoriamente<br>";
  }
  /* Agregamos una variable privada y estatica con valor nulo que solo será visible
    desde la propia clase y no requerirá  un objeto para ser instanciada */
  protected static $instancia;
  /* Incluimos un método público y estático con nombre Unico() que:
       – Comprueba si la propiedad $instancia tiene valor.
       – En caso de tenerlo nos da un mensaje de advertencia.
       – Si no lo tiene crea un nuevo objeto de la clase actual. */
  public static function Unico(){
            if (!isset(self::$instancia)) {
                $objeto =__CLASS__; // __CLASS__ contiene el nombre de la clase actual
                self::$instancia = new $objeto;
             }else{
               print "Ya existe un objeto Centro y ha de ser único";
             }
             return self::$instancia; //devuelve el objeto recien creado
  }
}
?>
<?php
/* la funcion autoload nos permitirá cargar la clase Centro que es la que se instanciará
   para crear el objeto */
function __autoload($clase){
  include $clase.'.class.php';
 }
 /* la sintaxis habitual \$objeto=mew Centro daría un mensaje de error ya que
    el método __construct tiene el carácter de protected con lo cual se impide
    que puede ejecutarse desde esta opción */

 /* Lo único visible de la clase Centro es el método  Unico. Dado que
    es un método estático habrá que invocarlo con la sintaxis adecuada a su condición */

Centro::Unico();
/* Al ser invocado por primera el método Unico crea el objeto. */
Centro::Unico();
/* Cuando se invoca por segunda vez el método Unico ya no puede crea el objeto y da el mensaje
   de advertencia. */
?>
ejemplo311.php

Objetos múltiples

Aquí puedes ver el código fuente de algunas clases que hemos creado y que utilizaremos para la creación del múltiples objetos tal como puede verse en el ejemplo que hay a continuación

Ver clase Centro Ver clase Aula Ver clase Alumnos Ver clase Profesores

<?php
/* la funcion autoload nos evita problemas a la hora de incluir los ficheros
   que contienen las clases requeridas */
function __autoload($clase){
  include $clase.'.class.php';
 }
/* creamos el objeto miCentro tal como se describe en los ejemplos anteriores */
$miCentro=Centro::Unico();

/* comprobemos el contenido del objeto */
print "<br>Estas son las propiedades del objeto miCentro<br>";
print "<pre>";
print var_dump($miCentro);
print "</pre>";

/* vamos a crear el objetos de la clase Aula
  si miras el código fuente de la clase Aula.class.php verás que el contructor
  agrega el valor correspondiente al identificador de cada objeto
  por esa razón cuando instanciemos objetos Aula vamos a incluir como argumento
  el valor de ese identificador */
/* un array nos puede ser util para crear masivamente las aulas */
$nombre_aulas=array('1º A','2º C','4º F','3º B','1B A');
/* Leeremos este array e iremos creando nuevos objetos de la clase Aula
   incluyendo el identificador que requiere el constructor */
for ($i=0;$i<sizeof($nombre_aulas);$i++){
  /* Haremos que los nuevos objetos sean elementos de un array escalar
     Para ello solo tenemos que agregar [] a misAulas y cada objeto creado
     pasará a ser un elemento de ese array */
  $misAulas[]=new Aula($nombre_aulas[$i]);
}
/* comprobemos el contenido de los objetos  */
print "<br>Comprobación de los objetos misAulas<br>";
print "<pre>";
print var_dump($misAulas);
print "</pre>";

/* con una estrategia similar podremos crear los objetos de la clase Alumnos
Ahora al instanciar cada objeto incliremos su nombre y apellido */

/* estos son los datos para los objetos alumnos */
$nombre_alumnos=array('Ana','Benito','Carla','Dionisio','Esther',
                                 'Fernando','Guiomar','Herminio','Isabel','Jenaro');
$apellidos_alumnos=array('Jiménez','Iglesias','Husillos','Gómez','Fernández',
                               'Escapa','Díaz','Casado','Blázquez','Alonso');
for ($i=0;$i<sizeof($nombre_alumnos);$i++){
  $misAlumnos[]=new Alumnos($nombre_alumnos[$i],$apellidos_alumnos[$i]);
  }
  /* comprobemos el contenido de los nuevos objetos */
  print "<br>Comprobación de los objetos misAlumnos<br>";
  print "<pre>";
print var_dump($misAlumnos);
print "</pre>";

?>
ejemplo313.php

La ejecución de este script nos permite comprobar que efectivamente se han creado los objetos pretendidos pero tiene un par de deficiencias manifiestas. Los diferentes tipos de objetos carecen de relación. Hemos creado un centro, aulas y alumnos pero no tienen relación alguna. Sus clases son independientes entre sí. Los alumnos podrían ser de ese u otro centro y lo mismo podría ocurrir con las aulas.

Un segundo problema es que una vez que finaliza la ejecución del script los objetos se destruyen y se pierde toda la información relativa a ellos. Vamos a tratar de ver a continuación como evitar esa pérdida.

Serialización de objetos

Toda la información relativa a un objeto puede se transformada en una cadena mediante la función:

serialize(nombre_del_objeto)

donde nombre_del_objeto indica el objeto que pretendemos serializar. Los resultados de la serialización son susceptibles de ser guardados en un fichero. De esta forma (puedes verlo en el ejemplo) los objetos pueden estar disponibles para su uso posterior.

<?php
/* para evitar reescribir incluimos el ejemplo anterior. Se ejecutará integramente */
include('ejemplo313.php');
/* visualizamos la serializacion de cada objeto */
print "<brEsta es la serialización de misAlumnos<br>";
print serialize($misAlumnos);

print "<brEsta es la serialización de misAulas<br>";
print serialize($misAulas);

print "<brEsta es la serialización de misAulas<br>";
print serialize($miCentro);

/* también podemos guardar cada objeto en una variable o en un array tal como
 hacemos en las instrucciones siguientes */
$serializado[] = serialize($misAlumnos);
$serializado[] = serialize($misAulas);
$serializado[] = serialize($miCentro);
/* vamos a hacer una segunda serialización. Serializaremos y guardaremos en una variable
los contenidos del array resultante de la serialización anterior */
$todo=serialize($serializado);
/*guardaremos en un fichero (le ponemos como nombre Almacenado)la serialización resultante */
file_put_contents('Almacenado', $todo);
?>
ejemplo314.php

Recuperación de objetos serializados

Los objetos contenidos de las cadenas (o ficheros) que contienen el resultado de una o varias serializaciones pueden ser recuperados por medio de la función:

$objeto_recuperado= unserialize($cadena_serializada)

donde $objeto_recuperado es el nombre que pretendemos asignar al objeto recuperado (no tiene por qué coincidir que el que tenía en el momento de ser serializado) y $cadena_serializada una variable que contiene el resultado de la serialización previa.

Es necesario que estén disponibles las clases a las que pertenecen los objetos que pretendemos recuperar.

<?php
/* la funcion autoload no va a incluir los ficheros con las clases necesarias */
function __autoload($clase){
  include $clase.'.class.php';
 }
 /* leemeos el fichero y recogemos su contenido en una variable */
 $serializado = file_get_contents('Almacenado');
 /* recuperamos la serialización y visualizmos el contenido */
  $todo_junto = unserialize($serializado);
print "<pre>";var_dump($todo_junto);print "</pre>";
print "<br>Podemos leer el array mediante un bucle<br>";
for($i=0;$i<sizeof($todo_junto);$i++){
    print "<pre>";
    var_dump(unserialize($todo_junto[$i]));
    print "</pre>";
}
?>
ejemplo315.php

Objetos que contienen objetos

Las propiedades (variables) de los objetos pueden contener valores alfanuméricos o numéricos, arrays, objetos y también arrays cuyos elementos sean objetos. La forma de asignar valores a las propiedades puede tener alguna de las formas siguientes:

$objeto -> propiedad=valor

es la forma más sencilla. Se asigna un nuevo valor (numérico o alfanumérico) a la propiedad del $objeto. Como es lógico requiere la preexistencia del objeto.

$objeto -> propiedad [ ] = valor

Se asigna un nuevo valor (numérico o alfanumérico) a la propiedad [] del $objeto . Como es lógico la propiedad habrá sido definida como array escalar en su clase y el resultado sería un nuevo elemento cuyo índice se conformaría de forma automática sumando una unidad al del último existente.

$objeto -> propiedad = $otro_objeto

se asigna $otro_objeto (objeto preexistente de otra clase) como valor de la propiedad del $objeto .

$objeto -> propiedad [ ] = $otro_objeto

se asigna $otro_objeto (objeto preexistente de otra clase) como valor de la propiedad del $objeto . El hecho de la propiedad tenga forma de array significa que $otro_objeto será el valor asignado a un nuevo elementos del array.

$objeto -> propiedad[] =new clase_del_objeto_a_incluir()

también en este caso se asigna un objeto como valor de la propiedad del $objeto . La diferencia estriba en que el objeto añadido no existe previamente. Por esa razón se crea en el momento de la inclusión mediante new seguido de clase_del_objeto_a_incluir() con los eventuales argumentos que pudiera requerir el constructor de la nueva clase.

$objeto -> propiedad [ ] =new clase_del_objeto_a_incluir()

su única diferencia con el caso anterior es que ahora el nuevo objeto será almacenado en un array.

En estos enlaces puedes ver el código fuente de las clases utilizadas en el ejemplo que se incluye a continuación de ellos.

Ver clase Centro Ver clase Aula Ver clase Alumnos Ver clase Profesores

<?php
/* la funcion autoload nos evita problemas a la hora de incluir los ficheros
   que contienen las clases requeridas */
function __autoload($clase){
  include $clase.'.class.php';
}
/*creamos un nuevo objeto asignándole valor al identificador al instanciar de la clase Aula
Puedes visualizar el constructor desde enlace que hay aqui encima */
$miAula=new Aula('Primero B');
/* la propiedad profesor va a contener un objeto de la clase Profesores
   que crearemos incluyendo los argumentos que utiliza su constructor */
$miAula->profesor=new Profesores('Juan','López','Matemáticas');
/* agregamos un nuevo elemento al array materiales */
$miAula->materiales[]="Pizarra digital";
/* modificamos el número de puestos ecolares del aula */
$miAula->puestos=45;
/* haremos una inclusión masiva de objetos de la clase Alumnos
(también puedes ver en el enlace el código fuente de esta clase)
utilizamos como valores los nombres y apellidos contenidos en los array */
$nombre_alumnos=array('Ana','Benito','Carla','Dionisio','Esther','Fernando','Guiomar');
$apellidos_alumnos=array('Jiménez','Iglesias','Husillos','Gómez','Fernández','Escapa','Díaz');
for ($i=0;$i<sizeof($nombre_alumnos);$i++){
  /* la propiedad alumnos de la clase Aula es un array de ahi que incluyamos
     los nuevos objetos (Alumnos) en alumnos[] */
  $miAula->alumnos[]=new Alumnos($nombre_alumnos[$i],$apellidos_alumnos[$i]);
  }
/* Visualizamos el contenido de el objeto Aula que incluye otros objetos en sus propiedades */
print "<pre>";
print var_dump($miAula);
print "</pre>";
?>
ejemplo316.php

Manipulación de objetos contenidos en objetos

En los ejemplos que incluimos a continuación puedes ver, comentados, algos casos de manipulación de objetos contenidos en otros objetos.

<?php
class AulaExtendida extends Aula {
      function lista_profes(){
             print $this->profesor->nombre;
             print $this->profesor->apellidos;
      }

     function lista_profes1(){
             print $this->profesor->nombre;
             print $this->profesor->apellidos;
             print $this->profesor->materia;
      }

     function lista_alumnos(){
         foreach ($this->alumnos as $indice=>$contenido){
             print $contenido->nombre." ".$contenido->apellidos." ".$contenido->ruta."<br>";
         }
     }


     function modifica_alumnos($nom_act='',$ap_act='',$nom_nue='',$ap_nue='', $ruta_nue=''){
        foreach ($this->alumnos as $ind=>$cont){
          if($this->alumnos[$ind]->nombre==$nom_act && $this->alumnos[$ind]->apellidos==$ap_act){
                 if ($nom_nue !='')$this->alumnos[$ind]->nombre=$nom_nue;
                 if ($ap_nue !='')$this->alumnos[$ind]->apellidos=$ap_nue;
                 if ($ruta_nue !='')$this->alumnos[$ind]->ruta=$ruta_nue;
          }
        }
     }

     function borra_alumnos($nom_act='',$ap_act=''){
        foreach ($this->alumnos as $ind=>$cont){
          if($this->alumnos[$ind]->nombre==$nom_act && $this->alumnos[$ind]->apellidos==$ap_act){
                 unset($this->alumnos[$ind]);
          }
        }
        $this->alumnos=array_values($this->alumnos);
     }
}

/****** comienza una porción de código idéntica a la del ejemplo anterior ******/

function __autoload($clase){
  include $clase.'.class.php';
}
$miAula=new AulaExtendida('Primero B');  //instanciamos la clase extendida para usar sus metodos
$miAula->profesor=new Profesores('Juan','López','Matemáticas');
$miAula->materiales[]="Pizarra digital";
$miAula->puestos=45;
$nombre_alumnos=array('Ana','Benito','Carla','Dionisio','Esther','Fernando','Guiomar');
$apellidos_alumnos=array('Jiménez','Iglesias','Husillos','Gómez','Fernández','Escapa','Díaz');
for ($i=0;$i<sizeof($nombre_alumnos);$i++){
   $miAula->alumnos[]=new Alumnos($nombre_alumnos[$i],$apellidos_alumnos[$i]);
  }

/**** acaba el código idéntica a la del ejemplo anterior ****/

$miAula->lista_profes();
print "<br /><br />";
/* lista alumnos */
$miAula->lista_alumnos();
print "<br />";
/* modifica alumnos sin busqueda*/
$miAula->alumnos[2]->nombre="Heliodoro";
$miAula->alumnos[3]->apellidos="de los Ríos";
/* modifica alumnos con busqueda*/
$miAula->modifica_alumnos('Ana','Jiménez','María Gertrudis','Cucalón',48);
/* borra alumnos con búsqueda*/
$miAula->borra_alumnos('Benito','Iglesias');
$miAula->lista_alumnos();
print "<br />";
print "<pre>";
print var_dump($miAula);
print "</pre>";
print "<br><br>";

foreach ($miAula->alumnos[1] as $propiedad=>$valor){
  print $propiedad."....".$valor."<br>";
}
print "<br><br>";
foreach ($miAula->alumnos as $indice=>$objeto){
    foreach ($objeto as $propiedad=>$valor){
        print $indice."...".$propiedad."....".$valor."<br>";
    }
}

$miAula->lista_profes1();
?>
ejemplo317.php

<?php
function __autoload($clase){
  include $clase.'.class.php';
 } 
 /* crearemos un objeto de la clase Aula */
$aula=new Aula('Aula Magna');
print "<br><i>El identificador del aula recien creada es</i>: ".$aula->identificador;
/* creamos tres objetos de la clase Alumnos */
$alumno[0]=new Alumnos ('Juan Carlos', 'Rodriguez');
$alumno[1]=new Alumnos ('Feliciano','Perez');
$alumno[2]=new Alumnos ('Luisindo','Orcasitas');
print "<br /><br /><i>Los objetos del array alumnos son estos</i>: ";
/* El primer bucle nos permite leer los elementos del array (objetos) y el segundo
   extrae el nombre de la propiedad y su valor */
   foreach ($alumno as $indice=>$objeto){
        print "<br>".$indice."  ";
            foreach ($objeto as $propiedad=>$valor){
                print "<i>".$propiedad."</i>: ".$valor."; ";
            }
   }
/* añadimos algunos objetos Alumnos a la propiedad alumnos de la clase Aula */
$aula->alumnos[]=$alumno[0];
$aula->alumnos[]=$alumno[1];
/* incluimos un nuevo objeto en el array alumnos de la clase Aula */
$aula->alumnos[]=new Alumnos ('Sindulfo','Yebra');
/* copiamos el objeto recien creado en un nuevo objeto */
$alumno[3]=$aula->alumnos[2];
print "<br /><br /><i>Los objetos de la propiedad alumnos de la clase Aula son estos</i>: ";
   foreach ($aula->alumnos as $indice=>$objeto){
        print "<br>".$indice."  ";
            foreach ($objeto as $propiedad=>$valor){
                print "<i>".$propiedad."</i>: ".$valor."; ";
            }
   }
/* modificamos nombres de alumnos tanto en el array alumnos como en los objetos aula->alumnos */
$aula->alumnos[0]->nombre="Tácito Petronio";
$alumno[1]->nombre="Francisca Maria";
$alumno[3]->nombre="Iñigo Francisco";

print "<br><br><br>La modificación se produce en ambos lugares<br><br>";
print "<br /><br /><i>Los objetos del array alumnos después de los cambios son</i>: ";
     foreach ($alumno as $indice=>$objeto){
        print "<br>".$indice."  ";
            foreach ($objeto as $propiedad=>$valor){
                print "<i>".$propiedad."</i>: ".$valor."; ";
            }
   }

print "<br><br><i>En la clase Aula vemos esto después de los cambios:</i>: ";
   foreach ($aula->alumnos as $indice=>$objeto){
        print "<br>".$indice."  ";
            foreach ($objeto as $propiedad=>$valor){
                print "<i>".$propiedad."</i>: ".$valor."; ";
            }
   }
/* eliminaremos algunos objetos. En un caso lo haremos en los de clase Aula
    y en otros en el array alumno */
unset($aula->alumnos[0]);
unset($alumno[1]);
unset($aula->alumnos[2]);
print "<br><br><br>Después de destruir objetos.<br>";
                  print "<br>Tácito e Iñigo en el objeto de la Clase Aula";
                  print "<br>Francisca en el objeto alumnos";

print "<br><br><i>Los objetos del array alumno después de eliminar  son</i>: ";
     foreach ($alumno as $indice=>$objeto){
        print "<br>".$indice."  ";
            foreach ($objeto as $propiedad=>$valor){
                print "<i>".$propiedad."</i>: ".$valor."; ";
            }
   }

print "<br /><br /><i>Los objetos de la clase Aula después de eliminar son estos</i>: ";
      foreach ($aula->alumnos as $indice=>$objeto){
        print "<br>".$indice."  ";
            foreach ($objeto as $propiedad=>$valor){
                print "<i>".$propiedad."</i>: ".$valor."; ";
            }
   }

?>
ejemplo318.php