Php orientado a objetos, parte 2: Método constructor y destructor

Bueno, en mi anterior posteo publiqué una introducción en donde mostraba como crear una clase y luego un objeto en base a la misma, Php orientado a objetos, parte 1: Clases, propiedades y métodos.

Ahora bien, en aquella ocasión yo tenía una clase Persona con este aspecto:

<?php 
 class Persona { 
    public $nombre;
    public $apellido;
    public $edad;
    public function saludar(){
       return 'Hola, soy ' . $this->nombre . ' ' . $this->apellido . ' y tengo ' . $this->edad . ' años '; 
    }
 }

Luego, creaba un objeto Persona:

$persona = new Persona();

A su vez este objeto tenía un método saludar(), que era invocado por el objeto persona de esta forma:

$persona->saludar();

Ahora bien, en la programación  orientada a objetos nosotros tenemos la posibilidad de crear un método llamado constructor, que a diferencia de los otros métodos no es invocado, sino que se dispara en el preciso momento en que nosotros creamos el objeto. Osea cuando hacemos:

$objeto = new Clase();

Esto es muy útil ya que permitirá en dicho método constructor definir todas aquellas características que tiene un objeto al ser creado.

Para ello haremos lo siguiente. Iremos a nuestro archivo Persona.php, donde tenemos nuestra clase y le haremos algunos cambios.

Probemos cómo funciona el método constructor de la siguiente forma:

<?php 
 class Persona { 
    public function __construct() {
       echo 'Se acaba de crear el objeto persona';
    }
 }
?>

Y ahora probemos su funcionamiento de la siguiente manera:

<?php
 require_once 'clases/Persona.php';
 $persona = new Persona();
?>

Ejecutá tu archivo test.php y comprobá su funcionamiento. Seguramente habrás notado que el objeto al ser creado llama al método __construct(), pero sin ser invocado con la flecha ->.

El método constructor en PHP se escribe como un método mágico, por tanto nosotros no podremos ponerle cualquier nombre al método, sino que tendrá que ser __construct().

Volvamos a modificar la clase Persona casi cómo estaba antes, pero con el método constructor y en dicho método definiremos el valor de las propiedades de la clase $nombre, $apellido y $edad. Debería quedar así:

<?php 
 class Persona { 
    public $nombre;
    public $apellido;
    public $edad;
    public function __construct($nombre, $apellido, $edad) {
       $this->nombre = $nombre;
       $this->apellido = $apellido;
       $this->edad = $edad;
    }
    public function saludar(){
       return 'Hola, soy ' . $this->nombre . ' ' . $this->apellido . ' y tengo ' . $this->edad . ' años '; 
    }
 }
?>

Cómo verán, en el anterior posteo nosotros teníamos que, luego de crear nuestro objeto $persona, acceder desde el mismo para definir los valores de las propiedades $nombre, $apellido y $edad. En este caso el constructor será el encargado de definir los valores de estas propiedades, por tanto, nosotros al crear el objeto estamos obligados a setear los valores de estas propiedades.

Ahora bien, te preguntarás cómo definir los valores de las propiedades del objeto $persona, ya que están en el constructor, y el constructor no se invoca desde el objeto, sino que se llama automáticamente. Bueno, seguramente habrás notado que cuando nosotros creamos un objeto con new Clase(), se utiliza paréntesis, bueno esos paréntesis dentro pueden recibir parámetros, y esos parámetros son los mismos que el método constructor. Por tanto, para crear el objeto y definir el valor de las propiedades lo haremos de la siguiente manera:

<?php
 //Importamos la clase Persona.
 require_once 'clases/Persona.php';
 //Creamos el objeto con los valores que se definen en el constructor.
 $persona = new Persona('Fernando', 'Gaitan', 26);
?>

Ahora solamente nos queda invocar el método saludar() para mostrar por pantalla los valores que acabamos de setear. Así que haremos lo siguiente:

<?php
 //Importamos la clase Persona.
 require_once 'clases/Persona.php';
 //Creamos el objeto con los valores que se definen en el constructor.
 $persona = new Persona('Fernando', 'Gaitan', 26);
 //Mostramos por pantalla los valores.
 echo $persona->saludar();
?>

Ok. Ahora que sabemos de que se trata un método constructor podemos aprender a usar un método destructor. Los métodos destructores, son lo contrario a un constructor. Los constructores se disparan cuando el objeto se crea, mientras que los destructores se disparan en cuanto se borra de memoria. Si bien estos métodos no suelen utilizarse a menudo como sí pasa con los constructores, no está de más entender su funcionamiento.

Primero que nada para destruir un objeto tenemos que usar la función de PHP unset() que sirve para borrar cualquier tipo de variable de memoria, incluso un objeto. Esto puede resultar últil para liberar memoria en nuestro script.

Así que para destruir nuestro objeto agregaremos lo siguiente:

<?php
 //Importamos la clase Persona.
 require_once 'clases/Persona.php';
 //Creamos el objeto con los valores que se definen en el constructor.
 $persona = new Persona('Fernando', 'Gaitan', 26);
 //Mostramos por pantalla los valores.
 echo $persona->saludar();
 //Destruimos el objeto.
 unset($persona);
?>

Y para comprobar que el objeto ha sido destruido modificaremos nuestra clase Persona.php agregando otro método mágico __destruct():

<?php 
 class Persona { 
    public $nombre;
    public $apellido;
    public $edad;
    public function __construct($nombre, $apellido, $edad) {
       $this->nombre = $nombre;
       $this->apellido = $apellido;
       $this->edad = $edad;
    }
    public function __destruct() {
       echo 'Objeto destruido';
    }
    public function saludar(){
       return 'Hola, soy ' . $this->nombre . ' ' . $this->apellido . ' y tengo ' . $this->edad . ' años '; 
    }
 }
?>

Si comprueban su script verán que el método destructor se dispara en cuanto el objeto desparece de la memoria.

Bueno, hasta acá todo. Cualquier duda o sugerencia por acá la hacen.

Saludos!

Anterior: Php orientado a objetos, parte 1: Clases, propiedades y métodos

Siguiente: Php orientado a objetos, parte 3: Niveles de acceso


12 Respuestas a “Php orientado a objetos, parte 2: Método constructor y destructor”

    1. La verdad que estos conocimientos ya los tengo pero es muy practico y sencillo la forma en que lo explicas. gracias

  1. Al definir los valores de las propiedades con el método __construct usamos la forma:
    $this->nombre = $nombre;

    No sería como decir “$nombre = $nombre” ?
    Entiendo que el primer nombre es una propiedad y el segundo el valor de la propiedad pero los dos se llaman igual y se definen igual con $. Como sabe PHP cuando es variable, objeto, valor, etc.

    1. Porque a diferencia de Java, PHP solamente va a entender que una propiedad es una propiedad si vos dentro de la clase la llamás como:

      $this->mi_propiedad;

      Si vos de pronto ignorás el $this-> (en otros lenguajes podés hacerlo, como Java con el this.)

      Entoces va a buscar una variable, o si tiene un parámetro con ese nombre, el parámetro.

      Esto va a tirar error:

      class Miclase {
      private $mi_propiedad = 1;
      public function __construct() {
      echo $mi_propiedad;
      }
      }

      Saludos!