Abstracción en POO

Dentro del paradigma de la Programación Orientada a Objetos (POO) es importante poder representar cada una de las entidades que intervienen en el programa que estemos realizando. A continuación veremos una breve explicación acerca de la Abstracción.

La abstracción la podemos definir como el proceso de identificar aquellas características (atributos) y acciones o comportamientos (métodos) propios de un elemento que deseemos representar. Para entender más a detalle este concepto, que mejor que con un ejemplo.

Supongamos que tenemos un programa en el que se registre y consulte información correspondiente a Cursos y Estudiantes; cada uno de estos puede representarse como una clase (como se describe a continuación), dado que hacen parte del contexto en el que nos encontramos.

class Curso
{
  // atributos y métodos correspondientes
}

class Estudiante
{
  // atributos y métodos correspondientes
}

Retomando el concepto de abstracción, los atributos representan aquellas características que permite diferenciar un elemento de los demás.

class Estudiante
{
  protected $nombre;
  protected $email;
  // ..
}

class Curso
{
  protected $nombre;
  protected $descripción;
  // ...
}

Podemos adicionar más atributos a cada una de las clases definidas como son:

• Estudiante: fecha de nacimiento, lugar de residencia, estado civil, N° de identificación, estatura, peso, color de piel, etc.
• Curso: precio, profesor, puntuación, categoría, etc.

Sin embargo, con la abstracción justamente se busca incluir aquellos atributos que sean relevantes dentro del contexto en el que estemos trabajando.

Los métodos suelen representar aquellas acciones que pueden realizarse a través de la clase que representa. Usualmente podemos encontrar métodos encargados de obtener o modificar los atributos definidos en la clase (conocidos como los getters y setters).

class Estudiante
{
  protected $nombre;
  protected $email;

  public function getNombre() {
    return $nombre;
  }

  public function setNombre($nombre) {
    $this->nombre = $nombre;
  }

  public function getEmail() {
    return $email;
  }

  public function setEmail($email) {
    $this->email= $email;
  }
}

class Curso
{
  protected $nombre;
  protected $descripción;

  public function getNombre() {
    return $nombre;
  }

  public function setNombre($nombre) {
    $this->nombre = $nombre;
  }

  public function getDescripcion() {
    return $descripción;
  }

  public function setDescripcion($descripción) {
    $this->descripción= $descripción;
  }
}

Así también podemos encontrar aquellos métodos con los cuales podemos crear un objeto de una clase, los cuales se le conoce cómo Métodos constructores.

class Estudiante
{
  protected $nombre;
  protected $email;

  public function__construct($nombre) {
    $this->nombre = $nombre;
  }

  // getters y setters
}

class Curso
{
  protected $nombre;
  protected $descripción;

  public function__construct($nombre){
    $this->nombre = $nombre;
  }

  // getters y setters
}

// Se crea un nuevo curso y un nuevo estudiante con sus respectivos valores
$curso = new Curso('Programación Orientada a Objetos en PHP');
$curso->setDescripcion('Una descripción breve de los conceptos de POO en el lenguaje PHP');

$estudiante = new Estudiante('César');
$estudiante->setEmail('cesar@correo.com');

// Se obtiene el nombre del curso y del estudiante a través de sus respectivos métodos
$nombreCurso = $curso->getNombre();
$nombreEstudiante = $estudiante->getNombre();

// Imprime: César está haciendo el curso de Programación Orientada a Objetos en PHP en Platzi
echo "$nombreEstudiante está haciendo el curso de $nombreCurso en Platzi";

Al desarrollar un programa usando el paradigma de POO es común encontrar situaciones en donde una clase tenga uno o varios atributos cuyo tipo corresponde a otra clase o clases. Por ejemplo, en la clase Curso podemos contemplar añadir por ejemplo, la lista de estudiantes inscritos, así como el profesor que orienta el curso.

class Profesor
{
  // Atributos y métodos contemplados
}

// (Se omitirá los atributos y métodos definidos al inicio)
class Curso
{
  protected $listaEstudiantes;
  protected $profesor;

  public function__construct($nombre, Profesor $profesor) {
    $this->nombre = $nombre;
    $this->profesor = $profesor;
    $this->listaEstudiantes = [];
  }

  public function getNumeroEstudiantes() {
    return count($listaEstudiantes);
  }

  public function adicionarEstudiante(Estudiante $estudiante) {
    array_push($this->listaEstudiantes, $estudiante);
  }
}

// Se crea el objeto del profesor para asociarlo al objeto del curso
$profesor = new Profesor('Italo Morales');
$curso = new Curso('Programación Orientada a Objetos en PHP', $profesor);

// Se invoca el método que permite adicionar un estudiante al curso definido en $curso
$curso->adicionarEstudiante(new Estudiante('César'));
$curso->adicionarEstudiante(new Estudiante('Juan'));
// En fin, cuantas veces se requiera

// Se obtiene el nombre del curso y del profesor asociado; así como el número de estudiantes a través de los respectivos métodos
$nombreCurso = $curso->getNombre();
$nombreProfesor = $curso->getProfesor()->getNombre();
$numeroEstudiantes = $curso->getNumeroEstudiantes();

// Imprime: El curso Programación Orientada a Objetos en PHP que orienta el profesor Italo Morales tiene 1000 estudiantes, y contando
echo "El curso $nombreCurso que orienta el profesor $nombreProfesor tiene $numeroEstudiantes, y contando";