El polimorfismo es un concepto fundamental en la programación orientada a objetos y está presente, entre otros lenguajes, en PHP. Derivado del griego, “polimorfismo” significa “muchas formas” y se refiere a la capacidad de una función, método o clase para tratar objetos de diferentes tipos de manera uniforme o para ofrecer múltiples comportamientos según el contexto en el que se invoca.
En PHP, el polimorfismo se puede lograr de varias maneras, a través de interfaces, clases abstractas y sobrecarga de métodos. Permite que una clase hija o derivada pueda ser tratada como una instancia de su clase padre, pero con la capacidad de sobrescribir o modificar el comportamiento de los métodos heredados.
1. Polimorfismo mediante Interfaces:
Una interfaz en PHP define un conjunto de métodos que cualquier clase que implementa la interfaz debe definir. Los objetos de diferentes clases que implementan la misma interfaz se pueden tratar de manera uniforme.
```php
interface Shape {
public function area();
}
class Circle implements Shape { private $radius;
public function __construct($radius) { $this->radius = $radius; } public function area() { return pi() * $this->radius * $this->radius; } }class Rectangle implements Shape { private $width; private $height;
public function __construct($width, $height) { $this->width = $width; $this->height = $height; } public function area() { return $this->width * $this->height; } }function printArea(Shape $shape) {
echo “Area: “ . $shape->area() . “\n”;
}
$circle = new Circle(5);
$rectangle = new Rectangle(4, 6);
printArea($circle);
printArea($rectangle);
```
En este ejemplo, `Circle` y `Rectangle` implementan la interfaz `Shape` y deben definir el método `area()`. La función `printArea()` acepta cualquier objeto que implemente la interfaz `Shape`, demostrando el polimorfismo.
2. Clases Abstractas:
En PHP, las clases abstractas pueden definir métodos que otras clases deben implementar. Esto permite un comportamiento polimórfico cuando se trabaja con clases derivadas de una clase abstracta.
```php
abstract class Animal {
abstract public function makeSound();
}
class Dog extends Animal {
public function makeSound() {
return “Woof!”;
}
}
class Cat extends Animal {
public function makeSound() {
return “Meow!”;
}
}
function animalSound(Animal $animal) {
echo $animal->makeSound() . “\n”;
}
$dog = new Dog();
$cat = new Cat();
animalSound($dog);
animalSound($cat);
```
En este caso, `Dog` y `Cat` extienden la clase abstracta `Animal` e implementan el método `makeSound()`. La función `animalSound()` demuestra el uso del polimorfismo al aceptar cualquier objeto que extienda `Animal`.
1. PHP Manual: – [Interfaces](https://www.php.net/manual/en/language.oop5.interfaces.php) – [Clases Abstractas](https://www.php.net/manual/en/language.oop5.abstract.php)
2. Libros y Recursos en Programación Orientada a Objetos: – “PHP Objects, Patterns, and Practice” de MATT ZANDSTRA, un libro destacado para profundizar en el conocimiento OOP en PHP. – Sitios educativos como [W3Schools PHP OOP](https://www.w3schools.com/php/php_oop_what_is.asp) y [GeeksforGeeks PHP OOP](https://www.geeksforgeeks.org/oop-php/).
El estudio profundo del polimorfismo y su implementación en PHP permite desarrollar aplicaciones más flexibles y escalables, dado que facilita el manejo de métodos y atributos de clases de manera más abstracta y reutilizable.
