Constructor

Es un método especial de una clase , que es llamado siempre que se inicializa un objeto. Es decir cuando instanciamos una clase se ejecuta ese método automáticamente, se utiliza para cualquier inicialización que el objeto pueda necesitar antes de ser usado.
La sintaxis básica es: void __construct ( [mixed args [, ...]] ), dado que esta forma solo esta soportada a partir de PHP5, también se puede declarar un constructor usando el mismo nombre que la clase a la cual pertenece (Para otorgar compatibilidad con PHP4), es decir si al instanciar no encuentra el método __construct(), PHP buscara un método que se llame igual que la clase.

Si una clase que hereda (sub-clase o clase hija), tiene definido su propio constructor, entonces al crear el objeto de esta, solo se ejecutara el constructor propio de la clase hija y no el de la clase superior o padre. Si necesitamos que la clase padre ejecute su constructor entonces debemos realizar una llamada explicita al método padre de la siguiente manera parent::__construct().

10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

<?php
class BaseClase
{
    function __construct()
    {
        print "Constructor de Clase Base<br />\n";
    }
}
 
class SubClase extends BaseClase
{
    function __construct()
    {
        parent::__construct();   // llamamos al constructor de la clase padre.
        print "Constructor en clase Hija<br />\n";
    }
}
 
$obj = new BaseClase();
// salida : Constructor de Clase Base
$obj = new SubClase();
// salida: Constructor de Clase Base
//          Constructor en clase Hija
?>

Destructor

PHP 5 introduce un concepto de destructor similar a aquellos de otros lenguajes de programación orientada a objetos, tal como C++. El método destructor será llamado tan pronto como todas las referencias a un objeto en particular sean removidas o cuando el objeto sea explícitamente destruido. En definitiva es otro método especial de una clase que se ejecuta antes de que un objeto de esa clase sea eliminado físicamente de la memoria. El destructor se utiliza para realizar las acciones finales, como borrar viejos archivos o liberar recursos.

Como sucede en los constructores, los destructores de la clase padre no serán llamados explícitamente por el compilador. Para ejecutar un destructor padre, se debe tener una llamada explícita a parent::__destruct() en el cuerpo del destructor.
El destructor es llamado durante la finalización del script, de tal manera que los headers ya han sido enviados.
Si se intenta arrojar una excepción desde un destructor produce un error fatal.

25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

<?php
class MyDestructableClass
{
    function __construct()
    {
        print "In constructor\n";
        $this->name = "MyDestructableClass";
   }
 
    function __destruct()
    {
        print "Destroying " . $this->name . "\n";
    }
}
 
$obj = new MyDestructableClass();
?>

Auto-Carga de Clases

Muchos desarrolladores que escriben aplicaciones con programación orientada a objetos crean un archivo fuente PHP por cada definición de clase. Una de las molestias más grandes es tener que escribir una larga lista de includes necesarios al principio de cada script (uno para cada clase).

En PHP 5, esto ya no es necesario. Puede definir una función __autoload la cual es llamada automáticamente en caso de que intente usar una clase que no ha sido definida aún. Al llamar esta función la ejecución del script da una última oportunidad de cargar la clase antes de que PHP falle con un error.

Las excepciones arrojadas en la función __autoload no pueden ser capturadas en el bloque catch y resultan en el despliegue de un error fatal.

52
53
54
55
56
57
58
59
60

<?php
function __autoload($nombreDeClase)
{
	require_once $nombreDeClase . '.php';
}
 
$obj  = new MyClass1();
$obj2 = new MyClass2();
?>

La pequeña rutina intenta levantar la clase MyClass1, al fallar y tener el método mágico __autoload, pasa el nombre de la clase a dicha función quien realiza el include para poder lograr la instancia.

Sobrecarga de Metodos

La interpretacion de PHP para la sobrecarga de métodos, es diferente a la mayoria de los lenguajes orientados a objetos. La sobrecarga tradicional proporciona la capacidad de tener multiples métodos con el mismo nombre, pero con diferente número y/o tipo de parámetros (a esto se le llama firma del metodo), dependiendo de ellos se ejecutará una función u otra.

En JAVA la sobrecarga seria así:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

class Pruebas
{
    public void Pruebas()
   {
        System.out.println("Hola Pruebas");
    }
 
    public void Pruebas(String name)
    {
        System.out.println("Hola " + name);
    }
 
    public void Pruebas(String firstName, String lastName)
    {
        System.out.println("Hola " + firstName + " " + lastName);
    }
}

En este caso declaramos 3 constructores (Metodos que inicializan el objeto pruebas), que reciben diferente cantidad de parametros. De esta forma segun el numero de parametros que pasemos se ejecuta uno u otro metodo.
Como logramos esto en PHP, si no soporta la sobrecarga de metodos en esa forma. Para ello se recurre a un metodo magico que es el método __call().

Metodo __call()

Se trata de un método “mágico” que permite capturar la invocación de métodos no existentes. Esté método puede ser redefinido para cubrir las necesidades del proyecto o como en este caso, proporcionar sobrecarga a nuestros scripts. Aprovechando está funcionalidad podemos controlar la función a la que estamos llamando y redirigir a la función concreta a la que hacemos referencia.

1
2
3
4
5

mixed __call ( string $nombre, array $argumentos );
/** La función _call() recibe dos parámetros:
 * $nombre -> El nombre del método
 * $argumentos -> Los argumentos pasados a la función.
*/

Una forma de implementarlo con este metodo es la siguiente…

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

<?php
class SobreCarga
{	
	public function __call($metodo, $parametros)
	{	if (method_exists($this, $metodo.sizeof($parametros))) return call_user_func_array(array($this, $metodo.sizeof($parametros)), $parametros);
                // Si la Funcion no Existe
                throw new Exception('Metodo Desconocido: '.get_class($this).'::'.$metodo);
        }
 
        function Param2($a, $b) {
                echo "<br />Param2($a,$b)\n";
        }
 
        function Param3($a, $b, $c) {
                echo "<br />Param3($a,$b,$c)\n";
        }
}
 
$o = new SobreCarga();
$o->Param(4,5);
$o->Param(4,5,6);
$o->ParamX(4,5,6,7);
?>
// La salida de este script seria:
Param2(4,5)
Param3(4,5,6)
Fatal error: Uncaught exception 'Exception' with message 'Metodo Desconocido: SobreCarga::ParamX' in C:\AppServ\www\clasesPHP\sobrecarga.php:7 Stack trace: #0 [internal function]: SobreCarga->__call('ParamX', Array) #1 C:\AppServ\www\clasesPHP\sobrecarga.php(22): SobreCarga->ParamX(4, 5, 6, 7) #2 {main} thrown in C:\AppServ\www\clasesPHP\sobrecarga.php on line 7

la funcion method_exists() comprueba que el metodo de clase existe y requiere 2 parametros un objeto donde se buscara el método y el nombre del método a buscar. La misma retorna un booleano, true si existe el metodo en la clase o false en caso contrario.
bool method_exists ( object object, nombreDeMetodo )
Es lo que hace la consulta de la linea 7. En caso de ser verdadera es decir existe el método utiliza la funcion call_user_func_array () que lo que realiza es Llamar una función definida por el usuario dada por funcion, con los parámetros establecidos.
mixed call_user_func_array ( callback funcion, array matriz_parametros );
callback funcion contiene una estructura de array donde debera constar el objeto y el metodo a llamar por ejemplo array(’MiClase’, ‘miMetodoDeRetorno’). Por lo cual la llamada de tipo array($this, $metodo.sizeof($parametros)) le indica que retorne de esta misma clase($this) el metodo que se llama $metodo.sizeof($parametros) donde sizeof es el numero de parametros pasados.

Como se puede ver no existe en PHP la sobrecarga tradicional, pero se puede llegar a simular con un poco de trabajo.
Fuente: Anieto, php.net

Sobre-Escritura de Métodos

Es un mecanismo por el cual una clase que hereda puede redefinir los métodos que está heredando. Es decir que podemos crear un método con el mismo nombre que el método de la clase padre. Ahora cuando creamos un objeto de la subclase, el método que se llamará es el de dicha subclase.
Lo más conveniente es sobreescribir métodos para completar el algoritmo del método de la clase padre. No es bueno sobreescribir un método y cambiar completamente su comportamiento.
Un ejemplo sencillo.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

<?php 
class Saludo
{	public function saludar()
	{	
		echo '<br />Hola';
	}
 
	public function despedida()
	{	
		echo '<br />Chau';
	}
}
 
class BuenosDias extends Saludo
{
	public function saludar()
	{
		echo '<br />Buenos Dias';
	}
}
$instancia	= new BuenosDias();
$instancia->saludar();
$instancia->despedida();
// El resultado seria:
Buenos Dias 
Chau
?>

En el resultado se ve claro que ejecuta el metodo de la clase hija.
la palabra extends indica que hereda los metodos y propiedades de la clase padre Saludo.