Declaración de clases

En PHP, una clase se define utilizando la palabra clave class, seguida del nombre de la clase y un par de llaves {} que encierran el cuerpo de la clase. Las clases actúan como plantillas para crear objetos, que son instancias de esas clases.

La sintaxis básica para declarar una clase es la siguiente:

<?php
class MiClase
{
    // Propiedades y métodos de la clase
}

Es fundamental seguir las convenciones de nomenclatura, utilizando PascalCase para los nombres de las clases. Por ejemplo, una clase que representa a un usuario podría llamarse Usuario o Cliente.

Dentro de una clase, se pueden definir propiedades (variables) y métodos (funciones). Estas propiedades y métodos determinan el estado y el comportamiento de los objetos creados a partir de la clase.

Ejemplo de una clase sencilla:

<?php
class Saludo
{
    public string $mensaje = "¡Hola, mundo!\n";

    public function mostrarMensaje(): void
    {
        echo $this->mensaje;
    }
}

En este ejemplo, la clase Saludo tiene una propiedad pública $mensaje y un método público mostrarMensaje() que imprime el mensaje en pantalla. La palabra clave $this se utiliza para acceder a la propiedad $mensaje dentro del contexto de la clase.

Para crear un objeto a partir de una clase, se utiliza el operador new:

<?php
$saludo = new Saludo();
$saludo->mostrarMensaje();

Este código instancia un objeto de la clase Saludo y llama al método mostrarMensaje(), resultando en la impresión de ¡Hola, mundo! en la salida.

Es posible establecer tipos de datos para las propiedades y los parámetros de los métodos, lo que permite aprovechar el tipado fuerte introducido en versiones recientes de PHP:

<?php
class Calculadora
{
    public float $resultado = 0.0;

    public function sumar(float $a, float $b): void
    {
        $this->resultado = $a + $b;
        echo "Resultado: {$this->resultado}\n";
    }
}

Aquí, la clase Calculadora tiene una propiedad pública $resultado de tipo float y un método sumar() que acepta dos parámetros de tipo float.

Las clases pueden implementar constructores, que son métodos especiales que se ejecutan al crear un objeto. Aunque los constructores se detallan en otra sección, es importante saber que se declaran como __construct() dentro de la clase.

Además, las clases pueden utilizar modificadores de acceso como public, private y protected para controlar la visibilidad de sus miembros. Por ejemplo:

<?php
class Banco
{
    private float $saldo = 0.0;

    public function depositar(float $cantidad): void
    {
        $this->saldo += $cantidad;
        echo "Depósito realizado. Saldo actual: {$this->saldo}\n";
    }
}

En este caso, la propiedad $saldo es privada, lo que significa que solo es accesible desde dentro de la clase Banco. El método depositar() es público y permite modificar el saldo de manera controlada.

Al declarar clases, es buena práctica incluir comentarios y documentar el código para mejorar su legibilidad y mantenimiento. También es recomendable organizar las clases en diferentes archivos y utilizar autocarga de clases para facilitar el desarrollo en proyectos más grandes.

Finalmente, es común utilizar namespaces para evitar conflictos de nombres y organizar mejor el código, especialmente en aplicaciones complejas:

<?php
namespace Aplicacion\Modelo;

class Producto
{
    // Definición de la clase Producto
}

La declaración de clases es el primer paso para aprovechar al máximo la Programación Orientada a Objetos en PHP, permitiendo crear estructuras más organizadas, reutilizables y mantenibles.

Creación y uso de objetos

En PHP, una vez que se ha declarado una clase, es posible crear instancias de esa clase llamadas objetos. Los objetos representan entidades concretas que poseen las propiedades y métodos definidos en la clase.

Para crear un objeto, se utiliza el operador new seguido del nombre de la clase. Por ejemplo:

<?php
$miObjeto = new MiClase();

Este código crea una nueva instancia de MiClase y la asigna a la variable $miObjeto. A partir de este momento, es posible acceder a los miembros públicos del objeto utilizando el operador de objeto ->.

Una vez creado el objeto, se pueden manipular sus propiedades y llamar a sus métodos. Por ejemplo, si MiClase tiene una propiedad $nombre y un método saludar(), se puede hacer lo siguiente:

<?php
$miObjeto = new MiClase();
$miObjeto->nombre = "Juan";
$miObjeto->saludar();

En este caso, se asigna el valor "Juan" a la propiedad $nombre del objeto y se invoca el método saludar().

El acceso a las propiedades y métodos de un objeto se realiza mediante el operador ->. Es importante respetar la visibilidad de los miembros definidos en la clase (public, private, protected). Solo los miembros públicos son accesibles desde fuera de la clase.

Ejemplo completo de declaración de clase y uso de objeto:

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

    public function presentarse(): void
    {
        echo "Hola, mi nombre es {$this->nombre} y tengo {$this->edad} años.\n";
    }
}

$persona = new Persona();
$persona->nombre = "María";
$persona->edad = 30;
$persona->presentarse();

Este código definirá la clase Persona y creará un objeto $persona, asignando valores a sus propiedades y llamando a su método presentarse().

Los objetos también pueden ser pasados como parámetros a funciones o métodos, lo que permite un diseño más modular del código. Por ejemplo:

<?php
function incrementarEdad(Persona $p): void
{
    $p->edad++;
}

$persona = new Persona();
$persona->nombre = "Luis";
$persona->edad = 25;
incrementarEdad($persona);
echo "{$persona->nombre} ahora tiene {$persona->edad} años.\n";

En este ejemplo, la función incrementarEdad() recibe un objeto de tipo Persona y modifica su propiedad $edad.

Es posible verificar si una variable es un objeto de una clase específica utilizando el operador instanceof:

<?php
if ($persona instanceof Persona) {
    echo "{$persona->nombre} es una instancia de la clase Persona.\n";
}

Esta verificación es útil para asegurar que se está trabajando con el tipo de objeto esperado.

La clonación de objetos permite crear copias independientes de un objeto existente utilizando la palabra clave clone:

<?php
$persona1 = new Persona();
$persona1->nombre = "Ana";
$persona1->edad = 22;

$persona2 = clone $persona1;
$persona2->nombre = "Elena";

echo "{$persona1->nombre} tiene {$persona1->edad} años.\n"; // Ana tiene 22 años.
echo "{$persona2->nombre} tiene {$persona2->edad} años.\n"; // Elena tiene 22 años.

En este caso, persona2 es una copia de persona1, pero al modificar su propiedad $nombre, el objeto original no se ve afectado.

Los objetos en PHP son manipulados por referencia, lo que significa que al asignar un objeto a otra variable, ambas referencias apuntan al mismo objeto:

<?php
$persona1 = new Persona();
$persona1->nombre = "Carlos";

$persona2 = $persona1;
$persona2->nombre = "Diego";

echo "{$persona1->nombre}\n"; // Muestra "Diego"

Aquí, al cambiar el nombre en $persona2, también cambia en $persona1 porque ambos son referencias al mismo objeto.

Para representar un objeto como cadena de texto, se puede implementar el método mágico __toString() en la clase:

<?php
class Producto
{
    public string $nombre;
    public float $precio;

    public function __toString(): string
    {
        return "{$this->nombre} cuesta {$this->precio} euros.\n";
    }
}

$producto = new Producto();
$producto->nombre = "Libro";
$producto->precio = 19.99;
echo $producto;

Al utilizar echo con el objeto $producto, PHP llama automáticamente al método __toString().

Los métodos de una clase pueden devolver $this para permitir llamadas encadenadas, lo que mejora la legibilidad del código:

<?php
class Cadena
{
    private string $texto = "";

    public function agregar(string $nuevoTexto): self
    {
        $this->texto .= $nuevoTexto;
        return $this;
    }

    public function mostrar(): void
    {
        echo "{$this->texto}\n";
    }
}

$cadena = new Cadena();
$cadena->agregar("Hola")->agregar(", mundo")->agregar("!")->mostrar();

En este ejemplo, se encadenan llamadas a los métodos de Cadena para construir y mostrar un mensaje.

Es importante gestionar los objetos de manera adecuada. Cuando un objeto ya no es necesario, PHP se encarga de eliminarlo automáticamente mediante el colector de basura. Sin embargo, se puede asignar null a una variable para liberar explícitamente la referencia:

<?php
$persona = new Persona();
// Uso del objeto
$persona = null; // Se libera la referencia al objeto

Comprender la creación y uso de objetos es fundamental para aprovechar al máximo la programación orientada a objetos en PHP y desarrollar aplicaciones más estructuradas y eficientes.

Propiedades y métodos

En PHP, las propiedades y los métodos son componentes esenciales de una clase que definen su estado y comportamiento. Las propiedades son variables que pertenecen a una clase o a sus objetos, mientras que los métodos son funciones que realizan operaciones utilizando esas propiedades o que ejecutan acciones específicas.

Las propiedades representan los atributos o características de una clase. Se declaran dentro de la clase utilizando un modificador de acceso (public, private, protected), seguido del nombre de la propiedad y, opcionalmente, un valor por defecto. Es recomendable especificar el tipo de las propiedades para aprovechar el tipado fuerte de PHP.

Ejemplo de declaración de propiedades:

<?php
class Vehiculo
{
    public string $marca;
    public string $modelo;
    private int $velocidad = 0;
}

En este ejemplo, la clase Vehiculo tiene tres propiedades: $marca y $modelo, que son públicas y de tipo string, y $velocidad, que es una propiedad privada de tipo int con un valor inicial de 0.

Para acceder y modificar las propiedades públicas de un objeto, se utiliza el operador ->. Por ejemplo:

<?php
$auto = new Vehiculo();
$auto->marca = "Toyota";
$auto->modelo = "Corolla";
echo "Marca: {$auto->marca}\n";
echo "Modelo: {$auto->modelo}\n";

Es importante destacar que intentar acceder a una propiedad privada desde fuera de la clase producirá un error:

<?php
echo "Velocidad: {$auto->velocidad}\n"; // Error: propiedad privada

Para manipular propiedades privadas, se utilizan métodos dentro de la clase que controlan el acceso y permiten la encapsulación de los datos.

Los métodos son funciones definidas dentro de una clase que describen el comportamiento de los objetos. Al igual que las propiedades, los métodos tienen una visibilidad y pueden recibir parámetros y devolver valores. Dentro de los métodos, se utiliza $this para referirse al objeto actual y acceder a sus propiedades y otros métodos.

Ejemplo de declaración de métodos:

<?php
class Vehiculo
{
    // Propiedades previamente declaradas...

    public function acelerar(int $incremento): void
    {
        $this->velocidad += $incremento;
        echo "El vehículo ha acelerado a {$this->velocidad} km/h\n";
    }

    public function frenar(int $decremento): void
    {
        $this->velocidad -= $decremento;
        if ($this->velocidad < 0) {
            $this->velocidad = 0;
        }
        echo "El vehículo ha frenado a {$this->velocidad} km/h\n";
    }
}

En este ejemplo, la clase Vehiculo define dos métodos públicos: acelerar() y frenar(), que modifican la propiedad privada $velocidad. Los métodos pueden recibir parámetros y utilizar lógica interna para realizar acciones sobre las propiedades.

Para utilizar los métodos, se invocan con el operador ->:

<?php
$auto = new Vehiculo();
$auto->acelerar(50); // El vehículo ha acelerado a 50 km/h
$auto->frenar(20);   // El vehículo ha frenado a 30 km/h

Los métodos también pueden devolver valores, lo que permite crear funcionalidades más flexibles. Por ejemplo:

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

$calc = new Calculadora();
$resultado = $calc->sumar(4.5, 3.2);
echo "El resultado es: {$resultado}\n"; // El resultado es: 7.7

Es recomendable especificar los tipos de los parámetros y del valor de retorno para aprovechar el tipado estricto y mejorar la robustez del código.

Las propiedades y métodos estáticos pertenecen a la clase en sí misma y no a instancias individuales. Se declaran con la palabra clave static y se acceden utilizando el operador ::. Por ejemplo:

<?php
class Contador
{
    public static int $total = 0;

    public static function incrementar(): void
    {
        self::$total++;
    }
}

Contador::incrementar();
Contador::incrementar();
echo "Total: " . Contador::$total . "\n"; // Total: 2

Dentro de una clase, se utiliza self:: para acceder a miembros estáticos, mientras que desde fuera se usa NombreDeLaClase::. Las propiedades y métodos estáticos son útiles para valores y comportamientos que son comunes a todas las instancias de una clase.

Las constantes de clase se declaran con const y contienen valores inmutables que pertenecen a la clase. Por ejemplo:

<?php
class Matematica
{
    public const PI = 3.1416;
}

echo "El valor de PI es: " . Matematica::PI . "\n";

Las constantes se acceden de manera similar a las propiedades estáticas, utilizando el operador ::.

PHP incluye también métodos mágicos que permiten personalizar el comportamiento de los objetos. Algunos ejemplos son __get(), __set(), __call(), que permiten controlar el acceso a propiedades y métodos inaccesibles o no definidos. Por ejemplo:

<?php
class Persona
{
    private array $datos = [];

    public function __set(string $nombre, $valor): void
    {
        $this->datos[$nombre] = $valor;
    }

    public function __get(string $nombre)
    {
        return $this->datos[$nombre] ?? null;
    }
}

$p = new Persona();
$p->nombre = "Carlos";
echo "Nombre: {$p->nombre}\n"; // Nombre: Carlos

En este caso, las asignaciones a propiedades no definidas son manejadas por __set(), y su acceso por __get(), proporcionando una mayor flexibilidad en la clase.

Es fundamental utilizar las propiedades y métodos de manera adecuada para aprovechar al máximo la programación orientada a objetos en PHP. La correcta definición y encapsulación de los atributos y comportamientos de las clases contribuye a la creación de código más estructurado, mantenible y reutilizable. El uso apropiado de visibilidades, tipos y convenciones de nomenclatura mejora la legibilidad y la calidad del código en proyectos de cualquier escala.

Modificadores de acceso (public, private, protected)

En PHP, los modificadores de acceso determinan la visibilidad y el alcance de las propiedades y métodos de una clase. Los tres modificadores principales son: public, protected y private. Estos modificadores controlan cómo se pueden acceder a los miembros de una clase desde diferentes contextos.

El modificador public indica que una propiedad o método es accesible desde cualquier parte: desde dentro de la clase, desde clases heredadas y desde fuera de la clase. Por ejemplo:

<?php
class Persona
{
    public string $nombre;

    public function decirNombre(): void
    {
        echo "Mi nombre es {$this->nombre}\n";
    }
}

$persona = new Persona();
$persona->nombre = "Ana";
$persona->decirNombre(); // Salida: Mi nombre es Ana

En este caso, la propiedad $nombre y el método decirNombre() son públicos, por lo que pueden ser accedidos y modificados desde fuera de la clase.

El modificador private limita el acceso de una propiedad o método exclusivamente al interior de la clase donde se declara. Ni siquiera las clases derivadas pueden acceder a miembros privados. Por ejemplo:

<?php
class CuentaBancaria
{
    private float $saldo = 0.0;

    public function depositar(float $cantidad): void
    {
        $this->saldo += $cantidad;
        echo "Depositados {$cantidad} euros\n";
    }

    private function mostrarSaldo(): void
    {
        echo "El saldo es {$this->saldo} euros\n";
    }
}

$cuenta = new CuentaBancaria();
$cuenta->depositar(100.0);
// $cuenta->saldo; // Error: acceso a propiedad privada
// $cuenta->mostrarSaldo(); // Error: acceso a método privado

Aquí, la propiedad $saldo y el método mostrarSaldo() son privados, lo que impide su acceso desde fuera de la clase. Solo el método público depositar() es accesible externamente.

El modificador protected permite que una propiedad o método sea accesible desde la clase donde se declara y desde sus clases hijas, pero no desde fuera de estas. Es útil para permitir que las clases derivadas interactúen con miembros heredados sin exponerlos públicamente.

Ejemplo de miembro protegido:

<?php
class Empleado
{
    protected float $sueldo;

    public function __construct(float $sueldo)
    {
        $this->sueldo = $sueldo;
    }
}

class Gerente extends Empleado
{
    public function mostrarSueldo(): void
    {
        echo "El sueldo del gerente es {$this->sueldo} euros\n";
    }
}

$gerente = new Gerente(3000.0);
$gerente->mostrarSueldo(); // Salida: El sueldo del gerente es 3000 euros
// $gerente->sueldo; // Error: acceso a propiedad protegida desde fuera

En este ejemplo, la propiedad $sueldo es protegida, por lo que la clase hija Gerente puede acceder a ella, pero no es accesible desde fuera de las clases.

El uso adecuado de los modificadores de acceso es esencial para aplicar el principio de encapsulación en la programación orientada a objetos. La encapsulación permite ocultar los detalles internos de una clase y exponer solo una interfaz pública para interactuar con ella.

Para mejorar la seguridad y la integridad del código, es recomendable:

• Declarar las propiedades como private o protected.
• Proporcionar métodos públicos (getters y setters) para acceder y modificar las propiedades cuando sea necesario.

Ejemplo de encapsulación con métodos de acceso:

<?php
class Producto
{
    private string $nombre;
    private float $precio;

    public function __construct(string $nombre, float $precio)
    {
        $this->nombre = $nombre;
        $this->precio = $precio;
    }

    public function getNombre(): string
    {
        return $this->nombre;
    }

    public function setPrecio(float $precio): void
    {
        if ($precio > 0) {
            $this->precio = $precio;
        } else {
            echo "El precio debe ser positivo\n";
        }
    }

    public function getPrecio(): float
    {
        return $this->precio;
    }
}

$producto = new Producto("Laptop", 1200.0);
echo "Producto: {$producto->getNombre()}\n";
echo "Precio: {$producto->getPrecio()}\n";
$producto->setPrecio(1100.0);
echo "Nuevo precio: {$producto->getPrecio()}\n";

En este caso, las propiedades $nombre y $precio son privadas y se accede a ellas mediante métodos públicos getNombre(), getPrecio() y setPrecio(). Así se controla cómo se accede y modifica el estado interno del objeto.

Los métodos protegidos son útiles cuando se desea que las clases derivadas puedan utilizar métodos sin exponerlos públicamente. Por ejemplo:

<?php
class Animal
{
    protected function hacerSonido(): void
    {
        echo "El animal emite un sonido\n";
    }
}

class Perro extends Animal
{
    public function ladrar(): void
    {
        $this->hacerSonido();
        echo "¡Guau!\n";
    }
}

$perro = new Perro();
$perro->ladrar(); // Salida: El animal emite un sonido
                  //         ¡Guau!
// $perro->hacerSonido(); // Error: acceso a método protegido

La clase Perro hereda de Animal y puede utilizar el método protegido hacerSonido(), pero desde fuera de las clases no es posible acceder a él.

Cuando se declara un método o propiedad sin especificar un modificador de acceso, por defecto es public en PHP. Sin embargo, es buena práctica siempre declarar explícitamente la visibilidad para mejorar la claridad del código.

Los modificadores de acceso también aplican a las propiedades y métodos estáticos y a las constantes de clase. Por ejemplo:

<?php
class Utilidades
{
    protected static function mostrarMensaje(string $mensaje): void
    {
        echo "Mensaje: {$mensaje}\n";
    }
}

class Herramientas extends Utilidades
{
    public function usarMensaje(): void
    {
        self::mostrarMensaje("Hola desde una clase hija");
    }
}

$herramienta = new Herramientas();
$herramienta->usarMensaje(); // Salida: Mensaje: Hola desde una clase hija
// Utilidades::mostrarMensaje("Directo"); // Error: método estático protegido

En este ejemplo, el método estático mostrarMensaje() es protegido, por lo que solo puede ser llamado desde la clase misma o desde clases derivadas.

El uso correcto de los modificadores de acceso permite diseñar clases más robustas y seguras, garantizando que los datos sensibles no sean manipulados directamente desde fuera y que las clases controlen cómo se accede y modifica su estado interno.