Lecciones de PHP - Lección 13 - Fundamentos de la POO (Programación Orientada a Objetos)

En las lecciones anteriores ya hablé sobre los siguientes tipos de datos en PHP: booleanos, enteros, flotantes, cadenas de texto y arrays. En esta lección hablaré de otro tipo de dato disponible en PHP: el objeto.
Los objetos se parecen en cierto modo a los arrays, ya que pueden contener diferentes tipos de datos como: números, texto, arrays e incluso otros objetos.

Los objetos pueden contener otros tipos de datos como los arrays. A estos datos los llamamos propiedades (campos) del objeto. Los objetos también pueden contener funciones en sí mismos; a estas funciones las llamamos métodos.

Pero los objetos tienen dos diferencias importantes con respecto a los arrays:

1. Los objetos pueden contener métodos.

Los métodos son funciones que se llaman en nombre del objeto. Asociar funciones a un objeto permite definir qué operaciones puede realizar y qué operaciones se pueden hacer sobre él.

2. Los objetos se crean a partir de clases.

Antes de crear un objeto, debemos definir una clase. En una clase describimos qué campos y métodos tendrá el objeto. Esto permite definir la estructura de los objetos y facilita entender qué datos debe almacenar un objeto y qué operaciones puede realizar. Al crear un objeto desde una clase, podemos inicializarlo con datos base para que los objetos recién creados no estén vacíos.

El objeto es probablemente el contenedor más conveniente para almacenar datos. Los objetos en PHP permiten modelar objetos del mundo real, por ejemplo, si tenemos una base de datos donde almacenamos información sobre libros. Un libro tiene autor, número de páginas, editorial, número de edición, reseña, datos tipográficos. Por comodidad, agrupamos esta información en una clase llamada Libro, con propiedades como Autor, Número de páginas, Editorial, Número de edición, Reseña, Datos tipográficos, etc. Así creamos objetos que se asemejan a libros reales. Esto es especialmente útil porque los datos de nuestros sitios web se almacenan en tablas con campos, por lo que podemos usar los nombres de las tablas como nombres de clases, y los campos como nombres de propiedades. Como resultado, trabajar con datos se vuelve mucho más sencillo.

Veremos más a fondo la diferencia entre arrays y objetos con ejemplos.

Características de PHP 5.2 y superior:

Comencemos definiendo una clase para nuestros objetos. Nota que usamos el singular para "clase" y el plural para "objetos", para destacar que de una sola clase se pueden crear muchos objetos:

<?php
class book{

}
?>

Con la palabra class definimos una clase para los objetos futuros. Ahora vamos a crear algunos objetos:

<?php
class book{
  
}

$book1 = new book;
$book2 = new book;
print_r($book1);
print_r($book2);
?>

Con la palabra clave new creamos nuevos objetos de la clase book. A cada objeto de una clase lo llamamos una instancia de la clase. Así tenemos dos instancias de la clase book: $book1 y $book2. Además, usamos print_r para mostrar el contenido de $book1 y $book2 en pantalla y vemos lo siguiente:

Como puedes ver, PHP muestra de qué clase proviene el objeto. Si el objeto contuviera datos, también se mostrarían. Ahora vamos a añadir datos. Primero, debemos definir propiedades de clase. Desde PHP 5.2, las propiedades se definen con tres palabras clave: public, protected, private (también se admite la antigua forma var, de la cual hablaremos más adelante). Si has trabajado con Delphi o C++, esto te será más familiar, ya que las palabras clave funcionan igual que en esos lenguajes.

public: define propiedades y métodos accesibles públicamente. Se pueden usar después de crear el objeto. Con esta palabra definiremos todas las propiedades del libro.

protected: define propiedades y métodos protegidos. Solo se pueden usar dentro de la clase o clases hijas (heredadas). Si intentas acceder desde fuera a una propiedad protegida, obtendrás un error. Más adelante estudiaremos esto en detalle.

private: define propiedades y métodos privados. Solo se pueden usar dentro de la clase, ni siquiera en clases hijas.

Por ahora, no nos complicaremos con protected y private, y definiremos todo como public.

class book{
  public $author;
  public $numberOfPages;
  public $year;
  public $publishingOffice;
  public $editionNumber;
}

Ahora nuestra clase tiene propiedades, lo que nos permite acceder a ellas desde sus instancias:

class book{
  public $author;
  public $numberOfPages;
  public $year;
  public $publishingOffice;
  public $editionNumber;
}

$book1 = new book;
$book1->author = 'Abramenko I.A';
$book1->numberOfPages = 192;
$book1->year = 2013;
$book1->publishingOffice = 'Moscow';
$book1->editionNumber = 1;
$book2 = new book;
print '<pre>';
print_r($book1);
print_r($book2);
print '</pre>';

Como resultado, obtenemos un objeto lleno de datos y otro vacío:

 

Creo que ahora te queda claro cómo escribir datos en objetos. Ahora veamos los métodos de clase. Como dije antes, los métodos son funciones que se invocan desde el objeto o la clase. Agreguemos métodos para mostrar cada propiedad:

<?php

class book{
  public $author;
  public $numberOfPages;
  public $year;
  public $publishingOffice;
  public $editionNumber;
  public function getAuthor(){
    return $this->author;
  }
  public function getNumberOfPages(){
    return $this->numberOfPages;
  }
  public function getYear(){
    return $this->year;
  }
  public function getPublishingOffice(){
    return $this->publishingOffice;
  }
  public function getEditionNumber(){
    return $this->editionNumber;
  }
}

$book1 = new book;
$book1->author = 'Abramenko I.A';
$book1->numberOfPages = 192;
$book1->year = 2013;
$book1->publishingOffice = 'Moscow';
$book1->editionNumber = 1;
$book2 = new book;
print '<pre>';
print $book1->getAuthor() . '<br />';
print $book1->getNumberOfPages() . '<br />';
print $book1->getYear() . '<br />';
print $book1->getPublishingOffice() . '<br />';
print $book1->getEditionNumber() . '<br />';
print '</pre>';
?>

De este modo podemos acceder a los datos del objeto usando métodos en lugar de acceder directamente a sus propiedades. Fíjate en la variable $this. Representa la instancia actual del objeto. Por ejemplo, si estamos trabajando con $book1, entonces dentro de la clase, $this se refiere a $book1. Así podemos trabajar con variables internas del objeto. Fuera del objeto, $this no tiene sentido.

Ahora vamos a crear dos métodos para mostrar la información del libro de diferentes formas: en una tabla y en bloques div.

class book{
  public $author;
  public $numberOfPages;
  public $year;
  public $publishingOffice;
  public $editionNumber;
  public function getAuthor(){
    return $this->author;
  }
  public function getNumberOfPages(){
    return $this->numberOfPages;
  }
  public function getYear(){
    return $this->year;
  }
  public function getPublishingOffice(){
    return $this->publishingOffice;
  }
  public function getEditionNumber(){
    return $this->editionNumber;
  }
  public function displayTable(){
    $content = '<table style="border: 1px solid #000">';
    $content .= '<tr><td>Author</td><td>'. $this->getAuthor() . '</td></tr>';
    $content .= '<tr><td>Number of pages</td><td>'. $this->getNumberOfPages() . '</td></tr>';
    $content .= '<tr><td>Year</td><td>'. $this->getYear() . '</td></tr>';
    $content .= '<tr><td>Publishing office</td><td>'. $this->getPublishingOffice() . '</td></tr>';
    $content .= '<tr><td>Edition number</td><td>'. $this->getEditionNumber() . '</td></tr>';
    $content .= '</table>';
    return $content;
  }
  public function displayUnformatted(){
    $content = '<div style="border:1px solid #ddd">';
    $content .= '<label>Author:</label><div>'. $this->getAuthor() . '</div>';
    $content .= '<label>Number of pages:</label><div>'. $this->getNumberOfPages() . '</div>';
    $content .= '<label>Year:</label><div>'. $this->getYear() . '</div>';
    $content .= '<label>Publishing office:</label><div>'. $this->getPublishingOffice() . '</div>';
    $content .= '<label>Edition number:</label><div>'. $this->getEditionNumber() . '</div>';
    $content .= '</div>';
    return $content;
  }
}

$book1 = new book;
$book1->author = 'Abramenko I.A';
$book1->numberOfPages = 192;
$book1->year = 2013;
$book1->publishingOffice = 'Moscow';
$book1->editionNumber = 1;
$book2 = new book;
$book2->author = 'Leshkina S.O.';
$book2->numberOfPages = 200;
$book2->year = 2013;
$book2->publishinOffice = 'Moscow';
$book2->editionNumber = 1;
print $book1->displayTable();
print $book2->displayUnformatted();

Ya tenemos un bloque importante de código que, como ves, es fácil de leer. Ah, me olvidaba del título del libro, agreguemos una propiedad name y los métodos correspondientes.

<?php

class book{
  public $author;
  public $name; // arghh, lo olvidé.
  public $numberOfPages;
  public $year;
  public $publishingOffice;
  public $editionNumber;

  public function getAuthor(){
    return $this->author;
  }
  public function getName(){
    return $this->name;
  }
  public function getNumberOfPages(){
    return $this->numberOfPages;
  }
  public function getYear(){
    return $this->year;
  }
  public function getPublishingOffice(){
    return $this->publishingOffice;
  }
  public function getEditionNumber(){
    return $this->editionNumber;
  }

  public function displayTable(){
    $content = '<table style="border: 1px solid #000">';
    $content .= '<tr><td>Author</td><td>'. $this->getAuthor() . '</td></tr>';
    $content .= '<tr><td>Name</td><td>'. $this->getName() . '</td></tr>';
    $content .= '<tr><td>Number of pages</td><td>'. $this->getNumberOfPages() . '</td></tr>';
    $content .= '<tr><td>Year</td><td>'. $this->getYear() . '</td></tr>';
    $content .= '<tr><td>Publishing office</td><td>'. $this->getPublishingOffice() . '</td></tr>';
    $content .= '<tr><td>Edition number</td><td>'. $this->getEditionNumber() . '</td></tr>';
    $content .= '</table>';
    return $content;
  }

  public function displayUnformatted(){
    $content = '<div style="border:1px solid #ddd">';
    $content .= '<label>Author:</label><div>'. $this->getAuthor() . '</div>';
    $content .= '<label>Name:</label><div>'. $this->getName() . '</div>';
    $content .= '<label>Number of pages:</label><div>'. $this->getNumberOfPages() . '</div>';
    $content .= '<label>Year:</label><div>'. $this->getYear() . '</div>';
    $content .= '<label>Publishing office:</label><div>'. $this->getPublishingOffice() . '</div>';
    $content .= '<label>Edition number:</label><div>'. $this->getEditionNumber() . '</div>';
    $content .= '</div>';
    return $content;
  }
}

$book1 = new book;
$book1->author = 'Abramenko I.A';
$book1->name = 'Drupal: User guide';
$book1->numberOfPages = 192;
$book1->year = 2013;
$book1->publishingOffice = 'Moscow';
$book1->editionNumber = 1;

$book2 = new book;
$book2->author = 'Leshkina S.O.';
$book2->name = 'Drupal: Fields, Images, Views';
$book2->numberOfPages = 200;
$book2->year = 2013;
$book2->publishinOffice = 'Moscow';
$book2->editionNumber = 1;

print $book1->displayTable();
print $book2->displayUnformatted();

?>

Características de PHP 5.1.3 y anteriores:

Si queremos definir propiedades (variables) dentro de una clase, usamos la palabra var.

<?php

class myClass{

 

}

?>

 

Veamos un ejemplo con arrays y funciones:

<?php
$newArray = array(1,2,3,4,5);

function _increment_all_elements($customArray){
  foreach($customArray as $key){
    $customArray[] = $key+1;
  }
  return $customArray;
}

$newArray = _increment_all_elements($newArray);
print_r($newArray);
?>

Este ejemplo no tiene mucha lógica, simplemente añadimos al array sus propios elementos incrementados en 1. Lo importante es cómo lo hicimos: con una función, que es la base de la programación funcional en PHP. Los objetos tienen un rol especial, y programar con ellos se llama programación orientada a objetos (POO).
Más adelante volveremos a este ejemplo y lo haremos con un objeto, pero antes entendamos qué es un objeto.
Los objetos, al igual que las funciones, permiten asociar funciones y datos, pero de una forma más cercana al mundo real. Por ejemplo, un objeto producto puede tener propiedades como precio, peso, ancho, largo. Esta similitud con el mundo real facilita la comprensión del código.
Los objetos generalmente se crean como instancias de una clase. Por ejemplo, el objeto "pelota" puede ser una instancia de la clase "producto". La clase es una generalización con la descripción de propiedades y métodos, y el objeto es la implementación de esa clase.
Ahora sí, vamos a crear nuestra primera clase y objeto:

<?php
class WorkWithArray{

}
?>

Con la palabra class creamos una clase. Dentro de las llaves escribimos las propiedades y funciones de la clase. En POO, las funciones dentro de clases se llaman métodos, así que en adelante diremos "método" en lugar de "función", y "propiedades" en lugar de "variables" cuando estén dentro de clases.
Ahora agregamos la primera propiedad: un array.

<?php
class WorkWithArray{
  var $myArray = array();
}
?>

Ahora nuestra clase tiene una propiedad llamada myArray. Estas también se llaman miembros de datos o propiedades de instancia. Se definen con la palabra var. También sería útil añadir una función a nuestra clase:

<?php
class WorkWithArray{
  var $myArray = array();
  function increment_all_elements($newArray){
    foreach($newArray as $key){
      $newArray[] = $key+1;
    }
    return $newArray;
  }
}
?>

Como puedes ver, las funciones se añaden a la clase como cualquier función normal. Ahora que tenemos nuestra clase, vamos a crear un objeto a partir de ella:

<?php
$myObject = new WorkWithArray;
print_r($myObject);
?>

Mostramos el objeto con print_r(), igual que hacíamos con arrays. Ahora que el objeto está creado, accedemos a su propiedad myArray y a su método increment_all_elements():

<?php
class WorkWithArray{
  var $myArray = array();
  function increment_all_elements($newArray){
    foreach($newArray as $key){
      $newArray[] = $key+1;
    }
    return $newArray;
  }
}

$myObject = new WorkWithArray;
$myObject->myArray = array(2,4,6,7);
print_r($myObject);
?>

Accedemos a las propiedades del objeto con ->, lo cual se puede leer como “el objeto myObject tiene la propiedad myArray”.
Ahora podemos operar con esa propiedad usando el método definido:

<?php
class WorkWithArray{
  var $myArray = array();
  function increment_all_elements($newArray){
    foreach($newArray as $key){
      $newArray[] = $key+1;
    }
    return $newArray;
  }
}

$myObject = new WorkWithArray;
$myObject->myArray = array(2,4,6,7);
$myObject->myArray = $myObject->increment_all_elements($myObject->myArray);
print_r($myObject);
?>

Accedemos a los métodos de un objeto igual que a sus propiedades, usando ->. Esta acción se llama “llamada” de método. Llamamos a increment_all_elements() pasando como argumento la propiedad myArray, y luego actualizamos esa misma propiedad con el resultado. Así mostramos el array modificado.
Este es un ejemplo simple para ilustrar cómo se crean objetos y cómo se accede a sus propiedades y métodos. Más adelante exploraremos programación orientada a objetos más a fondo.