Cómo utilizar las PHP classes en la pro­gra­ma­ción orientada a objetos

Las clases PHP es­tru­c­tu­ran el código en módulos lógicos in­de­pe­n­die­n­tes, cada uno de los cuales tiene pro­pie­da­des y métodos es­pe­cí­fi­cos. Esto favorece su re­uti­li­za­ción y la gestión en proyectos de gran en­ve­r­ga­du­ra.

¿Qué son las clases PHP?

Las clases PHP son como pla­n­ti­llas o esquemas que se utilizan para crear objetos. Una clase define las pro­pie­da­des (variables o atributos) y métodos (funciones) que tendrá un objeto. Las clases son una parte esencial de la pro­gra­ma­ción orientada a objetos y pueden uti­li­zar­se junto con otras funciones PHP, por ejemplo. También puedes crear clases para utilizar PHP para recuperar in­fo­r­ma­ción de una base de datos MySQL.

Cómo definir clases PHP

Para definir una clase en PHP, uti­li­za­mos la palabra clave clase, seguida del nombre de la clase y de llaves. En medio, es­cri­bi­mos las pro­pie­da­des y métodos de la clase.

class Name {
    // php class example properties and methods
}

Aquí tienes un ejemplo más concreto:

class Animal {
    // Properties
    public $name;
    public $color;
    // Methods
    function set_name($name) {
        $this->name = $name;
    }
    function get_name() {
        return $this->name;
    }
}

La clase “Animal” tiene las dos pro­pie­da­des “name” y “color”, así como dos métodos para es­ta­ble­cer (set_name) y recuperar (get_name) el nombre.

¿Cuál es la conexión entre las clases PHP y los objetos?

Los objetos son in­s­ta­n­cias de una clase. Cuando creas una instancia de una clase, obtienes un objeto es­pe­cí­fi­co que puede utilizar las pro­pie­da­des y métodos definidos en esa clase. Puedes crear objetos a partir de una clase uti­li­za­n­do la palabra clave new.

class Animal {
    // Properties
    public $name;
    public $color;
    // Methods
    function set_name($name) {
        $this->name = $name;
    }
    function get_name() {
        return $this->name;
    }
}
$dog = new Animal();
$cat = new Animal();
$dog->set_name('Tom');
$cat->set_name('Mickey');
echo $dog->get_name();
echo "<br>";
echo $cat->get_name();

Aquí, “dog” y “cat” son in­s­ta­n­cias de la clase “Animal”, a las que damos sus propios nombres.

Además, las clases PHP pueden heredarse, lo que significa que puedes derivar una clase existente para definir una nueva clase. La clase derivada hereda las pro­pie­da­des y métodos de la clase base. Esto permite re­uti­li­zar y ampliar funciones. Los objetos de la clase derivada también son in­s­ta­n­cias de la clase base y pueden utilizar sus métodos.

class Mammal extends Animal {
function breathesAir() {
      echo "inhale";
    }
}
$horse = new Mammal;
$horse->setName("Louis");

Con PHP extend, la clase “Mammal” hereda todas las pro­pie­da­des y métodos de la su­pe­r­cla­se “Animal”. Podemos añadir una nueva función a “Mammal”, pero también podemos acceder a las funciones heredadas.

Ejemplos de uso de clases PHP

Las clases PHP son muy ve­r­sá­ti­les. A co­n­ti­nua­ción, te ofrecemos ejemplos prácticos de su uso.

PHP in­s­ta­n­ceof

En PHP, in­s­ta­n­ceof es un operador para comprobar si un objeto pertenece a una clase concreta o a una clase derivada de ella.

Aquí tienes un ejemplo sencillo:

class Animal {
    public function speak() {
        echo "sound";
    }
}
class Dog extends Animal {
    public function speak() {
        echo "bark";
    }
}
$animal = new Dog();
if ($animal instanceof Animal) {
    $animal->speak(); // Output: "bark"
}

En primer lugar, uti­li­za­mos in­s­ta­n­ceof para comprobar si $animal es una instancia de la clase PHP “Animal” o de una de sus clases derivadas. Como $animal es una instancia de la clase derivada “Dog” (que hereda de Animal), se cumple la condición y se ejecuta el código del bloque If.

El operador instanceof es útil si quieres ase­gu­rar­te de que puedes acceder a ciertos métodos o pro­pie­da­des sin errores si el objeto no tiene la clase esperada.

PHP classes y arrays

Las clases pueden al­ma­ce­nar­se en arrays PHP para diseñar es­tru­c­tu­ras de datos complejas.

class Product {
    public $name;
    public $price;
    public function __construct($name, $price) {
        $this->name = $name;
        $this->price = $price;
    }
}
$products = [
    new Product("Laptop", 800),
    new Product("Smartphone", 400),
    new Product("Tablet", 300)
];
foreach ($products as $product) {
    echo "Product: " . $product->name . ", Price: $" . $product->price . "<br>";
}

En este ejemplo, definimos la clase “Product” para re­pre­se­n­tar di­fe­re­n­tes productos y al­ma­ce­nar­los en la matriz “products”. A co­n­ti­nua­ción, podemos recorrer la matriz con loops PHP como la co­n­s­tru­c­ción foreach para obtener los nombres de los productos y sus precios.

PHP class co­n­s­tru­c­tor

El co­n­s­tru­c­tor es un método especial dentro de una clase PHP que se llama au­to­má­ti­ca­me­n­te cuando se crea un objeto de esta clase. El propósito de un co­n­s­tru­c­tor es ini­cia­li­zar los estados iniciales de un objeto o realizar otro trabajo pre­pa­ra­to­rio necesario para que el objeto funcione co­rre­c­ta­me­n­te.

class Dog {
    private $name;
    private $color;
    // Constructor
    public function __construct($name, $color) {
        $this->name = $name;
        $this->color = $color;
    }
    public function sayHello() {
        return "Hello, my name is {$this->name} and my color is {$this->color}.";
    }
}
$dog = new Dog("Tom", "brown");
echo $dog->sayHello(); // Output: "Hello, my name is Tom and my color is brown."