En este posteo explicaré unos de los temas más importantes que tienen que ver con las clases en PHP.

Como hemos visto hasta ahora las clases nos sirven como modelos con un fin: crear objetos. Las clases tienen métodos y estos pueden invocarse desde el objeto que ha sido creado. Sin embargo, las clases no se limitan solamente a eso, servir de modelo para la creación de un objeto.

Dentro de las clases nosotros podemos definir métodos llamados métodos estáticos con la palabra reservada static antes del nombre del método:

class NombreDeLaClase {
    public static function nombreDelMetodo(){
       //
    }
}

Los métodos estáticos a diferencia de los otros se invocan sin crear un objeto, osea desde la misma clase a la que pertenece. De una forma similar a ésta:

NombreDeLaClase::nombreDelMetodo();

Como verán primero se llama a la clase, luego se utliza los dos puntos (::) y finalmente se invoca al método estático creado. Todo esto sin la necesidad de tener que instanciar un objeto basado en esa clase.

Crearé un ejemplo de una clase llamada Date_f, que tendrá dos métodos. Uno que nos devolverá la fecha del día, y otra que nos devolverá la hora.

<?php
 class Date_f {
    public static function getFecha(){
       $anio = date('Y');
       $mes = date('m');
       $dia = date('d');
       return $dia . '/' . $mes . '/' . $anio;
    } 
    public static function getHora(){
       $hora = date('H');
       $minutos = date('i');
       $segundos = date('s');
       return $hora . ':' . $minutos . ':' . $segundos;
    } 
 } 
?>

Y para probarla crearemos un script donde incluiremos la clase y llamaremos a ambos métodos desde la misma. Primero probaremos con el método que devuelve la fecha:

<?php 
 require_once 'clases/Date_f.php';
 echo 'La fecha de hoy es: ' . Date_f::getFecha();
?>

Luego probaremos el método que devuelve la hora:

<?php 
 require_once 'clases/Date_f.php';
 echo 'Son las: ' . Date_f::getHora();
?>

A su vez dentro de un método estático puede llamarse a otro método, siempre y cuando comparte la misma característica: sea estático.

Por ejemplo yo podría crear otro método estático que devuelve la fecha y la hora juntas invocando a los otros dos:

<?php
 class Date_f {
    public static function getFecha(){
       $anio = date('Y');
       $mes = date('m');
       $dia = date('d');
       return $dia . '/' . $mes . '/' . $anio;
    } 
    public static function getHora(){
       $hora = date('H');
       $minutos = date('i');
       $segundos = date('s');
       return $hora . ':' . $minutos . ':' . $segundos;
    }
    public static function getFechaHora(){
       $fecha = self::getFecha();
       $hora = self::getHora();
       return $fecha . ' | ' . $hora;
    }
 } 
?>

Y luego probarlo con:

<?php 
 require_once 'clases/Date_f.php';
 echo 'Fecha y hora: ' . Date_f::getFechaHora();
?>

Para invocar métodos estáticos dentro de la clase no se usa $this->metodo(), sino que lo hago con self::metodo(). Esto se debe a que $this sirve para hacer llamadas a propiedades y métodos que están dentro del objeto (no estáticos), y yo acá no tengo que crear ningún objeto. En realidad self es una palabra reservada que hace referencia al nombre de la clase donde estoy parado, como lo dije anteriormente en mi antiguo posteo, de la misma forma en que se llama a una constante: Php orientado a objetos, parte 5: Constantes.

Osea que hacer:

$fecha = self::getFecha();
$hora = self::getHora();

Es lo mismo que hacer:

$fecha = Date_f::getFecha();
$hora = Date_f::getHora();

Sólo que self es más recomendable por si más adelante decidimos cambiarle de nombre a la clase.

Para llamar a propiedades estáticas también debería hacerse con self. Para eso crearemos una propiedad estática con los días de la semana y un método que los muestre:

<?php
 class Date_f {
    private static $dias_de_la_semana = array('Lunes', 'Martes', 'Miércoles', 'Jueves', 'Viernes', 'Sábado', 'Domingo');
    public static function getFecha(){
       $anio = date('Y');
       $mes = date('m');
       $dia = date('d');
       return $dia . '/' . $mes . '/' . $anio;
    } 
    public static function getHora(){
       $hora = date('H');
       $minutos = date('i');
       $segundos = date('s');
       return $hora . ':' . $minutos . ':' . $segundos;
    }
    public static function getFechaHora(){
       $fecha = Date_f::getFecha();
       $hora = Date_f::getHora();
       return $fecha . ' | ' . $hora;
    }
    public static function mostrarDíasDeLaSemana(){
       $cadena_con_dias = implode(', ', self::$dias_de_la_semana);
       return $cadena_con_dias;
    }
 } 
?>

Cómo ven creamos un nuevo método que devolverá una cadena con los días de la semana y los recupera llamando a la propiedad estática $dias_de_la_semana:

<?php 
 require_once 'clases/Date_f.php';
 echo 'Los días de la semana son: ' . Date_f::mostrarDíasDeLaSemana();
?>

Otra cosa que vale aclarar es que dentro de un método estático no se puede invocar un método que no lo es, ya que estos sólo están disponibles en el momento en que se crea un objeto. Sí en cambio podemos retornar desde un método estático un objeto basado en la clase. Por ejemplo nosotros podemos tener una clase con este aspecto:

<?php 
 class Persona { 
    private $nombre;
    private $apellido;
    private $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 '; 
    }
    public static function getUsuarioPorDefecto(){
       return new self('Fernando', 'Gaitan', 26);
    }
 }
?>

Pero en lugar de utilizar el constructor para crear el objeto, creamos instancia con un método estático de esta forma:

<?php 
 require_once 'clases/Persona.php';
 $persona = Persona::getUsuarioPorDefecto();
 echo $persona->saludar();
?>

Al trabajar en forma independiente de un objeto los métodos estáticos se caracterizan por ser similares a las funciones, pero la ventaja que tiene sobre ésta es que cada método estáticos está encapsulada en una clase. Esto nos permite trabajar en forma más ordenada que la programación estructurada, en donde a medida que el proyecto iba haciéndose más grande y terminábamos teniendo millones de funciones esperando ser invocadas.

Anterior: Php orientado a objetos, parte 7: Clases abstractas y finales

Siguiente: Php orientado a objetos, parte 9: Excepciones