La Escuela del Programador

Objetos en PHP

El Paradigma de Programación orientada a objetos

Hoy en día prácticamente todos los lenguajes de programación, utilizan el paradigma de Programación orientada a objetos (OOP sigla en inglés proveniente de: Object Oriented Programming)

OOP es un estilo de programación que permite a los desarrolladores agrupar código en clases. Esto ayuda a mantener código que sigue el principio "Don’t repeat yourself (DRY)" y es mucho más fácil de mantener.

Una de las principales ventajas de la programación OOP es que, si una pieza de información cambia en el programa, se requiere por lo general un solo cambio para actualizar el código.

Diferencia entre Clases y objetos

Una clase, es como un plano de una casa. Define la forma de la casa sobre el papel, con las relaciones entre las diferentes partes de la casa claramente definidos y planeadas, a pesar de que la casa no existe.

En cambio, un objeto es, la casa real construida de acuerdo a ese modelo; es decir que un objeto es una instancia de la clase.

Clases y Objetos en PHP

La sintaxis para crear una clase en PHP, es bastante sencilla: declaramos una clase mediante la palabra clave class, seguida del nombre de la clase y un juego de llaves ({}), como se ve en el código siguiente:

<? php
  class MyClass
  {
    // Las propiedades de clase y los métodos van aquí
  }
?>

Veamos como ejemplo una simple página php, que define una clase Persona y luego instancia un objeto del tipo Persona:

<!DOCTYPE html>
<html>
    <head>
        <meta charset="utf-8" />
        <title>Objetos en PHP</title>
    </head>
    <body>
        <h2>OOP en PHP</h2>
        <hr>
        <?php
            class Persona
            {
                // Declaración del campo
                private $nombre;
     
                //Constructor
                function Persona($nom) {
                    $this->nombre = $nom;
                }

                // Métodos accesorios... 
                // ...de escritura
                function setNombre($n) {
                    $this->nombre = $n;
                }
                
                //.. de lectura
                function getNombre() {
                    return $this->nombre;
                }
		
                // otros métodos
		public function Saluda($saludo) {
		    echo $saludo."<br>";
                }
            }

            $objPersona = new Persona("Rubén");
            echo "<p>El objeto <span style='color:red; font-weight:bold'> objPersona</span> se llama ".
                 $objPersona->getNombre()."</p>"; 
            $objPersona->Saluda("Hola, PHP!"); 
        ?>
    </body>
</html>

La salida de este programa es la que se observa en la figura 1:

Figura 1 - Salida de la pagina al ser vista con Internet Explorer

Explicación del código

Dentro de la declaración de la clase observamos que una clase tiene:

Campos (los datos, que siguiendo el principio de Encapsulación, deben ser privados)
Al menos un constructor (se llama así a un método que lleva el nombre de la clase y que será el responsable de construir el objeto)
Los métodos accesorios de los campos: como los campos deben ser privados, para leer o establecer los valores de los campos, usamos estos métodos. Usamos la convensión de llamar a estos métodos setXxx (para el método de escritura) y getXxx (para el método de lectura), donde Xxx es el nombre del campo a leer o escribir.
Otros métodos: son las responsabilidades del objeto, o sea las acciones que puede llevar a cabo (en nuestro ejemplo, cualquier objeto del tipo Persona, será capaz de saludar, llamando al método Saluda(), pasándole como argumento el saludo a hacer.)

En las últimas líneas de código:

$objPersona = new Persona("Rubén");
echo "<p>El objeto <span style="color: red; font-weight: bold;"> objPersona</span> se llama ". 
      $objPersona->getNombre()."</p> 
$objPersona->Saluda("Hola, PHP!");

declaramos un objeto ($objPersona) del tipo Persona, usando el operador new, llamando al constructor de la clase, que asigna al campo nombre el valor pasado como argumento al constructor.

Nota: Dentro del constructor, observamos el uso de la palabra clave this, que hace referencia a la instancia actual, y mediante

 $this->nombre = $nom;

le asignamos al campo nombre el valor pasado al constructor. Además observamos el uso de la notación flecha, que se usa para llamar miembros de una clase (ej: $myObject->someProperty)

Separando el código de las clases en otros archivos e Incluyéndolos en la página: Es una buena práctica escribir nuestras clases en un archivo .php separado (uno por clase, dentro de un directorio clases) y luego incluir dicho archivo en la página, mediante el uso de la directiva include:

include("clases/persona.php");

Por ejemplo, luego de crear un directorio clases y dentro de él, un archivo llamado persona.php y llevando toda la definición de la clase a ese directorio, tendríamos el siguiente archivo personas.php:

<?php
     class Persona
     {
       //Toda la definición de la clase persona va aquí...
     }
?>

Por ultimo, nuestro archivo original quedaría simplificado a :

<!DOCTYPE html>
<html>
    <head>
        <meta charset="utf-8" />
        <title>Objetos en PHP</title>
    </head>
    <body>
        <h2>OOP en PHP</h2>
        <hr>
        <?php
            include("clases/persona.php");
            $objPersona = new Persona("Rubén");
            echo "<p>El objeto <span style='color:red; font-weight:bold'> objPersona</span> se llama ".
                 $objPersona->getNombre()."</p>";  
            $objPersona->Saluda("Hola, PHP!"); 
        ?>
    </body>
</html>

Como se ve, de esta manera, el código queda mucho mejor organizado...

Más adelante explicaremos como se puede definir en PHP un concepto clave de la OPP como la Herencia.

respag Seguir