Programación orientada a objetos en PHP

Constantes

En PHP, puedes definir constantes utilizando la función define() o, desde PHP 7.0 en adelante, utilizando la palabra clave const. Las constantes son valores que no cambian durante la ejecución de un script PHP y se utilizan para almacenar valores que no deben modificarse. Aquí tienes un ejemplo de cómo definir y utilizar constantes en PHP:

Usando define():

// Definir una constante con la función define()
define("PI", 3.14159);

// Utilizar la constante en el código
$radio = 5;
$area = PI * pow($radio, 2);

echo "El área de un círculo con radio $radio es: $area";

Usando const (a partir de PHP 7.0):

// Definir una constante con la palabra clave const
const PI = 3.14159;

// Utilizar la constante en el código
$radio = 5;
$area = PI * pow($radio, 2);

echo "El área de un círculo con radio $radio es: $area";

Ambos ejemplos hacen lo mismo: definen una constante llamada PI con el valor de 3.14159 y luego la utilizan para calcular el área de un círculo.

Es importante destacar que las constantes son siempre globales y su nombre se recomienda que esté en mayúsculas. También son inmutables, lo que significa que no se pueden cambiar después de ser definidas. Las constantes son útiles para almacenar valores que deben permanecer constantes en todo el script PHP y que no deberían cambiar accidentalmente.

Clases

En PHP, una clase es un plano o una plantilla para crear objetos. Define las propiedades (variables) y los métodos (funciones) que los objetos creados a partir de esa clase tendrán. Las clases se definen con la palabra clave class.

class Persona {
    public $nombre;
    public $edad;
    
    public function saludar() {
        echo "Hola, soy {$this->nombre} y tengo {$this->edad} años.";
    }
}

Objetos

Los objetos son instancias de una clase. Son entidades concretas que tienen datos (propiedades) y pueden realizar acciones (métodos).

$persona1 = new Persona();
$persona1->nombre = "Juan";
$persona1->edad = 30;

Propiedades y Métodos

Las propiedades son variables que pertenecen a un objeto, mientras que los métodos son funciones que pueden ser llamadas en objetos para realizar ciertas acciones.

class Persona {
    // Propiedades (variables de instancia)
    public $nombre;
    public $edad;
    
    // Método constructor
    public function __construct($nombre, $edad) {
        $this->nombre = $nombre;
        $this->edad = $edad;
    }
    
    // Método para saludar
    public function saludar() {
        echo "Hola, soy {$this->nombre} y tengo {$this->edad} años.";
    }
    
    // Método para calcular la edad en años bisiestos
    public function calcularEdadEnBisiestos($anioBisiesto) {
        $diferencia = $anioBisiesto - 2023;
        $edadEnBisiestos = $this->edad + ($diferencia / 4);
        return $edadEnBisiestos;
    }
}

// Crear una instancia de la clase Persona
$persona1 = new Persona("Juan", 30);

// Llamar al método saludar
$persona1->saludar();

// Calcular la edad en años bisiestos
$anioBisiesto = 2024;
$edadEnBisiestos = $persona1->calcularEdadEnBisiestos($anioBisiesto);
echo "<br>Edad en años bisiestos: $edadEnBisiestos";

En este ejemplo:

• Persona es una clase que tiene dos propiedades públicas: $nombre y $edad.
• El método constructor __construct se llama automáticamente cuando se crea una nueva instancia de la clase y se utiliza para inicializar las propiedades.
• saludar() es un método público que muestra un mensaje saludando a la persona.
• calcularEdadEnBisiestos() es otro método público que toma un año bisiesto como argumento y calcula la edad de la persona en años bisiestos.

Luego, se crea una instancia de la clase Persona, se llama al método saludar() para mostrar un saludo y se calcula la edad en años bisiestos llamando al método calcularEdadEnBisiestos().

class MiClase {
    // Método estático
    public static function metodoEstatico() {
        echo "Este es un método estático.";
    }
    
    // Método no estático
    public function metodoNoEstatico() {
        echo "Este es un método no estático.";
    }
}

// Llamar al método estático
MiClase::metodoEstatico(); // Salida: "Este es un método estático."

// Crear una instancia de la clase
$instancia = new MiClase();

// Llamar al método no estático a través de la instancia
$instancia->metodoNoEstatico(); // Salida: "Este es un método no estático."

Encapsulación

En PHP, los modificadores de acceso son palabras clave que se utilizan para controlar el acceso a las propiedades y métodos de una clase. Los modificadores de acceso determinan si una propiedad o método es visible y accesible desde fuera de la clase en la que se define. Los principales modificadores de acceso en PHP son los siguientes:

class Ejemplo {
    public $variablePublica;
    
    public function metodoPublico() {
        // Código aquí
    }
}

class Ejemplo {
    protected $variableProtegida;
    
    protected function metodoProtegido() {
        // Código aquí
    }
}

class Ejemplo {
    private $variablePrivada;
    
    private function metodoPrivado() {
        // Código aquí
    }
}

Estos modificadores de acceso son fundamentales para la encapsulación en la programación orientada a objetos. Permiten controlar el nivel de visibilidad y acceso a los miembros de una clase, lo que ayuda a mantener la integridad de los datos y la seguridad del código.

En resumen:

• public: Accesible desde cualquier lugar.
• protected: Accesible desde dentro de la clase y desde clases derivadas.
• private: Accesible solo desde dentro de la clase.

Herencia

La herencia en PHP permite que una clase (llamada subclase o clase derivada) herede propiedades y métodos de otra clase (llamada superclase o clase base). Aquí tienes un ejemplo simple de herencia en PHP:

// Clase base (superclase)
class Animal {
    protected $nombre;
    
    public function __construct($nombre) {
        $this->nombre = $nombre;
    }
    
    public function hablar() {
        echo "El animal está haciendo un sonido.";
    }
}

// Clase derivada (subclase)
class Perro extends Animal {
    public function hablar() {
        echo "{$this->nombre} dice Woof!";
    }

    public function moverCola() {
        echo "{$this->nombre} mueve la cola.";
    }
}

// Crear una instancia de la clase derivada (Perro)
$perro = new Perro("Buddy");

// Llamar a métodos de la clase base (Animal)
$perro->hablar(); // Salida: "Buddy dice Woof!"

// Llamar a métodos de la clase derivada (Perro)
$perro->moverCola(); // Salida: "Buddy mueve la cola."

En este ejemplo:

• Animal es la clase base que tiene una propiedad $nombre y un método hablar() que muestra un mensaje genérico.
• Perro es la clase derivada que hereda de Animal. Sobrescribe el método hablar() para proporcionar su propia implementación y agrega un nuevo método moverCola().

Cuando creamos una instancia de la clase Perro y llamamos a sus métodos, podemos ver que el método hablar() de la clase Perro sobrescribe el método de la clase Animal, lo que permite que el perro hable de una manera específica para su tipo. Además, el método moverCola() es exclusivo de la clase Perro.

La herencia en PHP permite la reutilización de código y la creación de jerarquías de clases, lo que facilita la organización y extensión del código en proyectos más grandes.

Polimorfismo

El polimorfismo permite que objetos de diferentes clases respondan de manera similar a un mismo método o función. Esto se logra a través de la herencia y la implementación de interfaces en PHP. En este ejemplo, utilizaremos herencia para demostrar el polimorfismo:

// Clase base (superclase)
class Animal {
    protected $nombre;
    
    public function __construct($nombre) {
        $this->nombre = $nombre;
    }
    
    public function hablar() {
        // Cada animal puede hacer un sonido diferente
    }
}

// Clases derivadas (subclases)
class Perro extends Animal {
    public function hablar() {
        return "{$this->nombre} dice Woof!";
    }
}

class Gato extends Animal {
    public function hablar() {
        return "{$this->nombre} dice Meow!";
    }
}

// Función que muestra el sonido de un animal
function mostrarSonido(Animal $animal) {
    echo $animal->hablar() . "\n";
}

// Crear instancias de las clases derivadas
$perro = new Perro("Buddy");
$gato = new Gato("Whiskers");

// Llamar a la función mostrarSonido con diferentes objetos
mostrarSonido($perro); // Salida: "Buddy dice Woof!"
mostrarSonido($gato);  // Salida: "Whiskers dice Meow!"

En este ejemplo:

• Tenemos una clase base llamada Animal con un método hablar(). Esta clase define la interfaz común para los objetos de tipo Animal.
• Luego, tenemos dos clases derivadas, Perro y Gato, que heredan de Animal. Cada una de estas clases sobrescribe el método hablar() para proporcionar su propia implementación específica.
• La función mostrarSonido() toma un objeto de tipo Animal como argumento y llama a su método hablar(). Debido al polimorfismo, esta función puede funcionar con objetos de tipo Perro o Gato, ya que ambas clases implementan el método hablar().

Cuando llamamos a mostrarSonido() con un objeto de tipo Perro y luego con un objeto de tipo Gato, podemos ver cómo el método hablar() se comporta de manera diferente para cada tipo de animal, a pesar de que la función mostrarSonido() es la misma en ambos casos. Esto es un ejemplo de polimorfismo, donde objetos de diferentes clases pueden responder de manera similar a una función o método común.

Abstracción

La abstracción en la programación orientada a objetos (POO) es el proceso de ocultar los detalles de implementación de un objeto y mostrar solo las características esenciales y relevantes para el usuario. En PHP, puedes lograr la abstracción mediante la definición de clases y métodos abstractos. Aquí tienes un ejemplo de abstracción en PHP:

// Clase abstracta que define una forma geométrica
abstract class Forma {
    protected $nombre;
    
    public function __construct($nombre) {
        $this->nombre = $nombre;
    }
    
    // Método abstracto para calcular el área
    abstract public function calcularArea();
    
    // Método para obtener el nombre de la forma
    public function obtenerNombre() {
        return $this->nombre;
    }
}

// Clase concreta que implementa una forma geométrica (círculo)
class Circulo extends Forma {
    private $radio;
    
    public function __construct($nombre, $radio) {
        parent::__construct($nombre);
        $this->radio = $radio;
    }
    
    public function calcularArea() {
        return pi() * pow($this->radio, 2);
    }
}

// Clase concreta que implementa una forma geométrica (rectángulo)
class Rectangulo extends Forma {
    private $ancho;
    private $alto;
    
    public function __construct($nombre, $ancho, $alto) {
        parent::__construct($nombre);
        $this->ancho = $ancho;
        $this->alto = $alto;
    }
    
    public function calcularArea() {
        return $this->ancho * $this->alto;
    }
}

// Crear instancias de las clases concretas
$circulo = new Circulo("Círculo", 5);
$rectangulo = new Rectangulo("Rectángulo", 4, 6);

// Calcular y mostrar áreas
echo "{$circulo->obtenerNombre()}: Área = {$circulo->calcularArea()}<br>";
echo "{$rectangulo->obtenerNombre()}: Área = {$rectangulo->calcularArea()}";

En este ejemplo:

• Forma es una clase abstracta que define una forma geométrica básica. Contiene una propiedad $nombre y un método abstracto calcularArea() que debe ser implementado por las clases concretas.
• Circulo y Rectangulo son clases concretas que heredan de Forma y proporcionan implementaciones concretas del método calcularArea(). Cada una tiene sus propias propiedades específicas ($radio y $ancho, $alto) y constructor.
• Puedes crear instancias de las clases concretas (Circulo y Rectangulo) y llamar a sus métodos, como obtenerNombre() y calcularArea(), para obtener información específica de cada forma geométrica.

La abstracción permite definir una interfaz común (Forma) que oculta los detalles de implementación de las formas geométricas concretas (Circulo y Rectangulo). Esto facilita la extensión del código para agregar nuevas formas geométricas sin modificar la lógica existente.

Conclusión de la programación orientada a objetos en PHP

La programación orientada a objetos en PHP es una técnica poderosa y flexible que ayuda a organizar y estructurar el código de manera más modular y mantenible. Permite la reutilización de código, la separación de preocupaciones y la creación de sistemas más complejos y extensibles.