PHP Academy · Lección

Propiedades y métodos estáticos

Utilice miembros estáticos y comprenda cuándo llamarlos sin una instancia.

Propiedades y métodos estáticos es una lección gratuita de PHP Academy en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de PHP Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de PHP Academy incluye 4 lecciones en total.

Introducción: propiedades y métodos estáticos

Los miembros estáticos pertenecen a la propia clase, no a ninguna instancia. Acceda a ellos con ClassName::member o self:: dentro de la clase. Se comparten entre todas las instancias.

Conceptos fundamentales

Conceptos clave de las propiedades y los métodos estáticos:

Se declaran con la palabra clave static
Se accede a ellos con :: (operador de resolución de ámbito)
self:: dentro de la clase; ClassName:: desde fuera
Enlace estático tardío con static::

Propiedad estática

Ejemplo:

<?php
class AppConfig {
    private static array $settings = [];

    public static function set(string $key, mixed $val): void {
        self::$settings[$key] = $val;
    }

    public static function get(string $key, mixed $default = null): mixed {
        return self::$settings[$key] ?? $default;
    }
}

AppConfig::set('debug', true);
echo AppConfig::get('debug') ? 'debug on' : 'debug off';

Método estático

Continuación:

<?php
class MathHelper {
    public static function clamp(float $v, float $min, float $max): float {
        return max($min, min($max, $v));
    }

    public static function lerp(float $a, float $b, float $t): float {
        return $a + ($b - $a) * $t;
    }
}

echo MathHelper::clamp(150, 0, 100); // 100
echo MathHelper::lerp(0, 100, 0.5);  // 50

Patrón Singleton

Práctica:

<?php
class Database {
    private static ?Database $instance = null;

    private function __construct() {
        echo 'Connected to DB';
    }

    public static function getInstance(): self {
        if (self::$instance === null) {
            self::$instance = new self();
        }
        return self::$instance;
    }
}

$db1 = Database::getInstance();  // 'Connected to DB'
$db2 = Database::getInstance();  // no output — same instance
echo ($db1 === $db2) ? 'same' : 'different'; // same

Contador estático

En profundidad:

<?php
class EventEmitter {
    private static int $instanceCount = 0;

    public function __construct() {
        self::$instanceCount++;
    }

    public static function count(): int {
        return self::$instanceCount;
    }
}

new EventEmitter();
new EventEmitter();
new EventEmitter();
echo EventEmitter::count();  // 3

Enlace estático tardío

Uso avanzado:

<?php
class ParentClass {
    public static function create(): static {
        return new static();  // resolves to calling subclass
    }

    public function getClass(): string {
        return static::class;  // late static binding
    }
}

class ChildClass extends ParentClass {}

$obj = ChildClass::create();
echo $obj->getClass();  // ChildClass

Fábrica estática

Patrón del mundo real:

<?php
class Response {
    private function __construct(
        private int   $status,
        private mixed $body
    ) {}

    public static function ok(mixed $data): self {
        return new self(200, $data);
    }

    public static function notFound(): self {
        return new self(404, ['error' => 'Not Found']);
    }

    public function toJson(): string {
        return json_encode(['status' => $this->status, 'body' => $this->body]);
    }
}

echo Response::ok(['users' => []])->toJson();

Ventajas y desventajas de lo estático frente a las instancias

Prácticas recomendadas:

<?php
// Static: no object needed, but harder to test/mock
class Validator {
    public static function isEmail(string $s): bool {
        return (bool) filter_var($s, FILTER_VALIDATE_EMAIL);
    }
}

// Instance: injectable dependency, testable
class ValidatorService {
    public function isEmail(string $s): bool {
        return (bool) filter_var($s, FILTER_VALIDATE_EMAIL);
    }
}
// Prefer instance classes in larger applications

Patrón práctico

Aplicación conjunta de los conceptos mediante un patrón práctico para propiedades y métodos estáticos.

Errores comunes

Evite estos errores comunes al trabajar con propiedades y métodos estáticos:

Los miembros estáticos se comparten entre todas las instancias
Prefiera el enlace estático tardío (static::) a self:: en las clases que se pueden heredar
Los Singleton son un patrón común, aunque a veces se utiliza en exceso
Los métodos estáticos son más difíciles de simular en las pruebas unitarias

Comprobación rápida

¿Qué palabra clave permite acceder a una propiedad estática dentro de la clase respetando la herencia (enlace estático tardío)?

Repaso: propiedades y métodos estáticos

Ha estudiado las propiedades y los métodos estáticos. Estos son los puntos clave que debe recordar:

Los miembros estáticos se comparten entre todas las instancias
Prefiera el enlace estático tardío (static::) a self:: en las clases que se pueden heredar
Los Singleton son un patrón común, aunque a veces se utiliza en exceso
Los métodos estáticos son más difíciles de simular en las pruebas unitarias

Preguntas frecuentes

¿La lección «Propiedades y métodos estáticos» es gratis?

Sí — el texto completo de «Propiedades y métodos estáticos» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de PHP Academy, actualiza a CoddyKit PRO. El curso de PHP Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Propiedades y métodos estáticos»?

Utilice miembros estáticos y comprenda cuándo llamarlos sin una instancia. Practicas PHP Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar PHP Academy?

No se requiere experiencia previa. PHP Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «Propiedades y métodos estáticos»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de PHP Academy?

Sí. Cada lección de PHP Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a PHP Academy