class

La palabra clave class en PHP

La palabra clave class define una clase — un plano que describe los datos (propiedades) y el comportamiento (métodos) compartidos por un grupo de objetos. A continuación, creas objetos individuales (también llamados instancias) a partir de ese plano con el operador new. Las clases son la base de la programación orientada a objetos (POO) en PHP: te permiten agrupar el estado y la lógica relacionados en una unidad única y reutilizable en lugar de dispersar variables y funciones sueltas.

Esta página explica cómo declarar una clase, agregar propiedades y métodos, inicializar objetos con un constructor, controlar el acceso con modificadores de visibilidad, compartir datos con constantes y miembros estáticos, y reutilizar comportamiento mediante herencia.

Sintaxis

Una declaración de clase comienza con la palabra clave class, seguida de un nombre y un cuerpo encerrado entre llaves:

<?php

class MyClass {
  // Properties and methods go here
}

Por convención, los nombres de clase usan PascalCase (MyClass, BankAccount). Un nombre de clase no puede ser una palabra reservada de PHP, y el cuerpo — incluso uno vacío — debe usar llaves. Definir una clase no hace nada por sí solo; solo se vuelve útil una vez que creas un objeto a partir de ella.

Propiedades y métodos

Una propiedad es una variable que pertenece a un objeto. Un método es una función que pertenece a una clase. Dentro de un método, la variable especial $this hace referencia al objeto actual, por lo que $this->name lee (o escribe) la propiedad name de ese objeto:

<?php

class User {
  public string $name;          // a property

  public function greet(): string {   // a method
    return "Hi, I'm {$this->name}";
  }
}

$u = new User();
$u->name = "Ada";               // set the property on this object
echo $u->greet();               // Hi, I'm Ada

Observa la flecha -> (no .) para acceder a los miembros, y que escribes $this->name, nunca $this->$name.

El constructor

Establecer cada propiedad manualmente es verboso y propenso a errores. El método __construct() se ejecuta automáticamente cuando se crea un objeto, permitiéndote requerir y asignar valores iniciales en un solo paso. Los argumentos que pasas a new se reenvían al constructor:

<?php

class Car
{
  public $make;
  public $model;
  public $year;

  public function __construct($make, $model, $year)
  {
    $this->make = $make;
    $this->model = $model;
    $this->year = $year;
  }

  public function describe(): string
  {
    return "{$this->year} {$this->make} {$this->model}";
  }
}

$myCar = new Car("Ford", "Mustang", 2022);
echo $myCar->describe();   // 2022 Ford Mustang

Consulta constructor de PHP para más información, incluida la promoción de propiedades en el constructor.

Visibilidad

Cada propiedad y método tiene una visibilidad que controla desde dónde puede accederse:

• public — accesible desde cualquier lugar (el valor predeterminado si lo omites).
• protected — accesible solo dentro de la clase y sus subclases.
• private — accesible solo dentro de la clase que lo declara.

Ocultar el estado interno detrás de private y exponerlo a través de métodos se llama encapsulación:

<?php

class BankAccount
{
  private float $balance = 0;     // cannot be touched directly from outside

  public function deposit(float $amount): void
  {
    $this->balance += $amount;
  }

  public function getBalance(): float
  {
    return $this->balance;
  }
}

$acc = new BankAccount();
$acc->deposit(100);
echo $acc->getBalance();   // 100

Más detalles en modificadores de acceso de PHP.

Constantes y miembros estáticos

Usa la palabra clave const para valores que nunca cambian y la palabra clave static para datos y métodos que pertenecen a la clase en sí en lugar de a un objeto en particular. A ambos se accede con el operador de resolución de ámbito :::

<?php

class Circle
{
  const PI = 3.14159;          // class constant
  public static int $count = 0; // shared across all instances

  public function __construct()
  {
    self::$count++;            // increment the shared counter
  }
}

new Circle();
new Circle();

echo Circle::PI;        // 3.14159
echo PHP_EOL;
echo Circle::$count;    // 2

Consulta constantes de clase en PHP y métodos estáticos de PHP.

Herencia

Una clase puede usar extends para reutilizar y especializar el comportamiento de otra. El hijo hereda las propiedades y métodos del padre, y puede sobreescribirlos:

<?php

class Animal
{
  public function speak(): string
  {
    return "The animal makes a sound.";
  }
}

class Dog extends Animal
{
  public function speak(): string   // overrides the parent method
  {
    return "The dog barks.";
  }
}

echo (new Animal())->speak();   // The animal makes a sound.
echo PHP_EOL;
echo (new Dog())->speak();      // The dog barks.

Para una cobertura más profunda, consulta herencia en PHP, y para clases que definen un contrato sin implementación, clases abstractas e interfaces.

Ejemplo completo

El siguiente ejemplo ejecutable combina un constructor con métodos getter y demuestra la herencia con sobreescritura de métodos:

<?php

// Example 1
class Car
{
  public $make;
  public $model;
  public $year;

  public function __construct($make, $model, $year)
  {
    $this->make = $make;
    $this->model = $model;
    $this->year = $year;
  }

  public function getMake()
  {
    return $this->make;
  }

  public function getModel()
  {
    return $this->model;
  }

  public function getYear()
  {
    return $this->year;
  }
}

$myCar = new Car("Ford", "Mustang", 2022);
echo "Make: " . $myCar->getMake() . PHP_EOL;
echo "Model: " . $myCar->getModel() . PHP_EOL;
echo "Year: " . $myCar->getYear() . PHP_EOL;

// Output:
// Make: Ford
// Model: Mustang
// Year: 2022

// Example 2
class Animal
{
  public function speak()
  {
    echo "The animal speaks.";
  }
}

class Dog extends Animal
{
  public function speak()
  {
    echo "The dog barks.";
  }
}

$myAnimal = new Animal();
$myDog = new Dog();
$myAnimal->speak();
$myDog->speak();

// Output:
// The animal speaks.
// The dog barks.

El Ejemplo 1 construye objetos con un constructor y lee su estado a través de getters; el Ejemplo 2 muestra una subclase Dog que sobreescribe el método speak() que hereda de Animal.

Resumen

• La palabra clave class define un plano; el operador new crea objetos a partir de él.
• Las propiedades almacenan los datos de un objeto, los métodos definen su comportamiento, y $this hace referencia al objeto actual dentro de un método.
• __construct() inicializa un objeto cuando se crea.
• public, protected y private controlan desde dónde se puede acceder a los miembros.
• const y static pertenecen a la clase en sí; accede a ellos con ::.
• extends permite que una clase herede y sobreescriba el comportamiento de otra.

Para una visión más amplia de cómo encajan estas piezas, consulta clases y objetos de PHP.

Práctica