Clases en PHP — Manual

En PHP, una clase es un molde que define propiedades (datos) y métodos (comportamientos). A partir de una clase se crean objetos (instancias).

Índice

• Sintaxis básica
• Modificadores de acceso
• Constructor y destructor
• Getters y Setters
• Estáticos y constantes
• Herencia
• Clases abstractas
• Interfaces
• Traits
• Tipado y tipos de retorno
• Namespaces y autoload
• Buenas prácticas

Sintaxis básica

<?php
class Persona {
  // Propiedades
  public string $nombre;
  public int $edad;

  // Método
  public function saludar(): string {
    return "Hola, soy " . $this->nombre;
  }
}

// Instanciar (crear objeto)
$p = new Persona();
$p->nombre = "Pablo";
$p->edad = 30;

echo $p->saludar(); // Hola, soy Pablo
?>

Modificadores de acceso

Constructor y destructor

<?php
class Persona {
  public function __construct(
    public string $nombre,  // promoción de propiedades (PHP 8+)
    public int $edad
  ) {}

  public function __destruct() {
    // Limpieza al destruir el objeto (rara vez necesario)
  }
}

$p = new Persona("Ana", 25);
?>

Getters y Setters

<?php
class Usuario {
  private string $email;

  public function setEmail(string $email): void {
    if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
      throw new InvalidArgumentException("Email inválido");
    }
    $this->email = $email;
  }

  public function getEmail(): string {
    return $this->email;
  }
}

$u = new Usuario();
$u->setEmail("ana@mail.com");
echo $u->getEmail();
?>

Estáticos y constantes

<?php
class Matematica {
  public const PI = 3.14159;

  public static function sumar(int|float $a, int|float $b): int|float {
    return $a + $b;
  }
}

echo Matematica::PI;
echo Matematica::sumar(2, 3);
?>

Herencia

<?php
class Persona {
  public function __construct(public string $nombre) {}
  public function saludar(): string { return "Hola, soy $this->nombre"; }
}

class Estudiante extends Persona {
  public function __construct(string $nombre, public string $curso) {
    parent::__construct($nombre);
  }
  public function info(): string {
    return $this->saludar() . " y estudio $this->curso";
  }
}

$e = new Estudiante("Luis", "Programación");
echo $e->info();
?>

Clases abstractas

Definen una plantilla con métodos que las hijas deben implementar.

<?php
abstract class Forma {
  abstract public function area(): float;
}

class Rectangulo extends Forma {
  public function __construct(private float $ancho, private float $alto) {}
  public function area(): float { return $this->ancho * $this->alto; }
}
?>

Interfaces

Contratos: definen qué métodos deben existir, sin implementación.

<?php
interface Exportable {
  public function export(): string;
}

class Reporte implements Exportable {
  public function export(): string { return "CSV..."; }
}
?>

Traits

Reutilización horizontal de métodos entre clases no relacionadas.

<?php
trait Loggable {
  public function log(string $msg): void { echo "[LOG] $msg\n"; }
}

class Servicio {
  use Loggable;
}

$s = new Servicio();
$s->log("Listo");
?>

Tipado y tipos de retorno

<?php
class Calculadora {
  public function sumar(int $a, int $b): int {
    return $a + $b;
  }

  public function buscar(?string $q): array { // acepta null, retorna array
    return $q ? ["resultado"] : [];
  }
}
?>

Namespaces y autoload

<?php
namespace App\Model;

class Usuario { /* ... */ }

// composer.json (PSR-4)
// "autoload": { "psr-4": { "App\\\": "src/" } }
// $ composer dump-autoload
// require 'vendor/autoload.php'; // carga automática
?>

Buenas prácticas

• Encapsular: propiedades private/protected, exponer getters/setters cuando haga falta.
• Single Responsibility: cada clase con una responsabilidad clara.
• Tipado estricto cuando sea posible (declare(strict_types=1); al inicio).
• Interfaces para contratos; dependencias contra interfaces, no implementaciones (DIP).
• Usar Composer y PSR-4 para organizar y cargar clases.
• Preferir composición sobre herencia cuando sea razonable.