Métodos Estáticos

Métodos estáticos

class MiClase {
	public static $contador = 0;
	public function __construct() {
		self::$contador++;
	}
	public static function obtenerContador() {
		return self::$contador;
	}
}
// Crear objetos
$objeto1 = new MiClase();
$objeto2 = new MiClase();
echo MiClase::obtenerContador(); // Imprime: 2

• Una variable estática puede ser devuelta por un método que no es estático. Es decir los métodos normales pueden devolver atributos estáticos y atributos normales y siempre con instancia. Los métodos estáticos solo pueden devolver variables estáticas.
• Un método estático no puede devolver un atributo que no sea estático (no se puede utilizar $this en un método estático)
• Si tenemos un objeto, podemos llamar a métodos estáticos usando el propio objeto, pero no podemos llamar a sus atributos estáticos desde el propio objeto.
• Usando el nombre de la clase podemos acceder tanto a métodos como atributos estáticos si el modificador nos lo permite.
• Si una propiedad o método en la clase padre es estático, si lo sobreescribimos en el hijo también deben ser estáticos.

class MiClase {
    public static $staticVar = 'S';
    public static function obtenerContador() {
        return "static";
    }
}
// Crear objetos
$objeto1 = new MiClase();

echo $objeto1->obtenerContador(); // static
echo $objeto1->staticVar; // error

Herencia de métodos estáticos

Los métodos o atributos estáticos del padre que sean protected se heredan por el hijo. Este tiene que crear métodos estáticos públicos donde se llamen a los métodos estáticos del padre para tener acceso desde fuera.

Los métodos públicos se pueden acceder con el nombre de la clase del padre, instancia del padre, clase del hijo o instancia del hijo. Vamos que es accesible desde cualquier lado

La palabra reservada “parent” solo se puede usar en métodos

class Padre {
    protected static $var = "hello"; 
}

class Hijo extends Padre {
    public $varr = parent::$var; // error

    public function devolverVar(){
        return parent::$var;
    }
}
$hijo = new Hijo();
echo $hijo->devolverVar();

self y static

En PHP, static:: se utiliza para acceder a miembros (métodos o propiedades) de una clase en el contexto de ejecución actual. La principal diferencia entre self:: y static:: radica en cómo manejan la herencia y el polimorfismo.

Cuando se utiliza self::, se hace referencia a la clase en la que se escribe el código, y no tiene en cuenta si la llamada proviene de una clase derivada (subclase). Esto significa que self:: siempre se resuelve en tiempo de compilación. En cambio, static:: se resuelve en tiempo de ejecución y se adapta al contexto de la clase que realmente está llamando al método. Esto es especialmente útil en situaciones de herencia, ya que permite que las llamadas a métodos estén vinculadas dinámicamente a la clase que realiza la llamada en lugar de la clase en la que se definió originalmente el método.

class Padre {
    public static function quienSoy() {
        echo "Padre";
    }

    public static function llamarMetodoEstatico() {
        static::quienSoy();
    }
}

class Hijo extends Padre {
    public static function quienSoy() {
        echo "Hijo";
    }
}

// Llamada al método desde la clase Padre
Padre::llamarMetodoEstatico();  // Salida: Padre

// Llamada al método desde la clase Hijo
Hijo::llamarMetodoEstatico();   // Salida: Hijo

class Padre {
    protected static $propiedad = "Propiedad en Padre";

    public static function obtenerPropiedad() {
        return self::$propiedad;
    }

    public static function obtenerPropiedadConStatic() {
        return static::$propiedad;
    }
}

class Hijo extends Padre {
    protected static $propiedad = "Propiedad en Hijo";
}

// Llamada desde la clase Padre
echo Padre::obtenerPropiedad();  // Salida: Propiedad en Padre
echo Padre::obtenerPropiedadConStatic();  // Salida: Propiedad en Padre

// Llamada desde la clase Hijo
echo Hijo::obtenerPropiedad();  // Salida: Propiedad en Padre
echo Hijo::obtenerPropiedadConStatic();  // Salida: Propiedad en Hijo

self

Se resuelve en tiempo de compilación, lo que significa que siempre se refiere a la clase donde se define el método. Útil para referirse a constantes y propiedades estáticas de la clase actual.

static

Se resuelve en tiempo de ejecución, lo que permite el polimorfismo y la resolución dinámica en el contexto de la herencia. Útil cuando quieres que la llamada al método sea polimórfica y que se adapte al contexto de la clase que realiza la llamada.

Constantes

Las constantes definidas en una clase es como si fueran estáticas dado que podemos acceder a ellas con el nombre de la clase

class Base {
   const PI = 3.1459;
}
echo Base::PI; // 3.1459