Conceptos Básicos de Programación Orientada a Objetos (OOP) en PHP

14/04/2024 | General, PHP | 0 comentarios

Aprende los principios básicos de OOP: Encapsulamiento, Herencia, Abstracción y Polimorfismo con ejemplos sencillos.

Descargar archivos


La Programación Orientada a Objetos (OOP : Object Oriented Programming) es un paradigma de programación que se basa en el concepto de objetos y clases. En PHP, el OOP permite organizar y estructurar el código de manera eficiente y modular. En este artículo, exploraremos los conceptos básicos de OOP como: clases, objetos, propiedades, métodos, herencia y encapsulamiento.

Definiciones

Lo primero es definir el conceptos de clases y objetos.

Clase

Una clase es una plantilla o molde donde se definen las propiedades (variables) y comportamientos (métodos) de un objeto. En la clase no se definen los valores de las propiedades, sólo se definen cuales son las propiedades que tiene el objeto.

  • Propiedades: son las características o datos de un objeto, se representan como variables o constantes.
  • Métodos: son las acciones que puede realizar un objeto, se representan como funciones.

Como ejemplo para representar a cualquier persona podríamos crear una clase con dos propiedades (nombre, edad) y un método (saludar).


class Person {
    // properties
    public $name;
    public $age;

    // constructor
    public function __construct($name, $age) {
        $this->name = $name;
        $this->age = $age;
    }

    // method
    public function greet() {
        echo "¡Hola, mi nombre es {$this->name} y tengo {$this->age} años!";
    }
}

Objeto

Un objeto es una instancia de una clase, el cual tiene valores específicos de las propiedades definidos en la clase. Usando la definición anterior de Person se pueden crear varias personas con nombres y edades diferentes.


$person1 = new Person("Juan", 30);
$person1->greet();  // ¡Hola, soy Juan y tengo 30 años!

Conceptos en OOP

Ahora definamos los conceptos básicos relaciones en la OOP:

Encapsulamiento

El encapsulamiento es el concepto que permite ocultar algunos detalles internos de un objeto y exponer solo lo necesario para interactuar con él. En PHP se pueden definir los tipos de acceso de propiedades y métodos con los siguientes tipos:

  • public: Accesible desde fuera de la clase.
  • private: Solo accesible desde la propia clase.
  • protected: Accesible desde la clase y sus subclases.

Como ejemplo, crearemos una clase para el manejo de puntos de nuestros clientes. Para ello tendremos una propiedad privada (que no se puede acceder directamente) con el total de puntos, además de ellos tres métodos que permitan interactuar con el total de puntos de manera sencilla y segura.


class Points
{
    // private property
    private $total;

    // public methods
    public function reward($points) {
        $this->total += $points;
    }

    public function redeem($points) {
        if ($points > $this->total) {
            throw new Exception('Saldo de puntos insuficiente.');
        }

        $this->total -= $points;
    }

    public function printBalance() {
        echo "Total de puntos: " . $this->total;
    }
}

Luego, podemos crear un objeto e interactuar con los puntos del cliente.


$pointsClient1 = new Points();
$pointsClient1->reward(300);
$pointsClient1->redeem(35);
$pointsClient1->printBalance();   // Total de puntos: 265

Herencia

La herencia es un principio de programación que permite que una clase herede las propiedades y métodos de otra clase (clase padre). La nueva clase puede modificar o crear nuevos métodos. En PHP se usa extends para extender clases.

Como ejemplo, podemos crear una nueva clase Estudiante que tenga las mismas cualidades que una Persona, pero que además tenga una nueva propiedad (carrera que estudia) y un nuevo método (estudiar):


class Student extends Person
{
    // properties
    public $career;

    public function __construct($name, $age, $career)
    {
        parent::__construct($name, $age);
        $this->career = $career;
    }

    // methods
    public function study()
    {
        echo "{$this->name} está estudiando {$this->career}.
"; } }

Para usar esta nueva clase, podemos crear un nuevo objeto:


$person2 = new Student("Luis", 22, 'Ingeniería');
$person2->greet();  // ¡Hola, soy Luis y tengo 30 años!
$person2->study();  // Luis está estudiando Ingeniería.

Abstracción

La abstracción es el proceso de identificar las características esenciales de un objeto y declararlos pero no implementarlos. Se declaran las clases abstractas usando abstract. Una vez declaradas las clases se puede implementar extendiendo la clase abstracta con extends, tener en cuenta que se deben implementar todas los métodos de la clase abstracta usando la misma visibilidad.

Como ejemplo creamos una clase abstracta para definir a cualquier forma geométrica, el cual tendrá un método para calcular su área.


abstract class Shape
{
    abstract protected function getArea();
}

Ahora implementamos dos formas geométricas (Circulo y Cuadrado) usando la clase abstracta previa y las implementaremos.


class Circle extends Shape
{
    private $radius = 0;

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

    public function getArea()
    {
        return M_PI * $this->radius * $this->radius;
    }
}

class Square extends Shape
{
    private $width = 0;

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

    public function getArea()
    {
        return $this->width * $this->width;
    }
}

Finalmente usamos nuestras clases para calcular el área de algunas formas geométricas:


$shape1 = new Circle(3);
echo $shape1->getArea();    // 28.274333882308

$shape2 = new Square(3);
echo $shape2->getArea();    // 9

Polimorfismo

El polimorfismo es la capacidad de un objeto de cambiar su comportamiento dependiendo de la clase a la que pertenece, pero usando una misma interfaz (métodos comunes). El polimorfismo en PHP se logra a través de la herencia y la implementación de métodos con el mismo nombre pero con comportamientos diferentes.

En el ejemplo anterior, se crearon dos clases (Circulo y Cuadrado) que tenían un método para calcular el área, pero cada uno de ellos se calculaba de forma diferente a pesar de tener la misma clase padre y el mismo nombre del método.


class Circle extends Shape
{
    // ...

    public function getArea()
    {
        return M_PI * $this->radius * $this->radius;
    }
}

class Square extends Shape
{
    // ...

    public function getArea()
    {
        return $this->width * $this->width;
    }
}

Esta característica permite usar diferentes clases con las mismas interfaces, esto es muy útil en la creación de módulos o plugins que tengan comportamientos diferentes pero que se puedan usar con las mismas instrucciones.

Referencias

Envíar Comentario

En este sitio los comentarios se publican previa aprobación del equipo de Kodetop. Evita los comentarios ofensivos, obscenos o publicitarios. Si deseas publicar código fuente puedes hacerlo entre las etiquedas <pre></pre>