1

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.

<h1>Definición</h1>

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.

classCurso{
  // atributos y métodos correspondientes
}

classEstudiante{
  // atributos y métodos correspondientes
}
<h1>Atributos</h1>

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

classEstudiante{
  protected $nombre;
  protected $email;
  // ..
}

classCurso{
  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.

<h1>Métodos</h1>

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).

classEstudiante{
  protected $nombre;
  protected $email;

  publicfunctiongetNombre(){
    return $nombre;
  }

  publicfunctionsetNombre($nombre){
    $this->nombre = $nombre;
  }

  publicfunctiongetEmail(){
    return $email;
  }

  publicfunctionsetEmail($email){
    $this->email= $email;
  }
}
classCurso{
  protected $nombre;
  protected $descripción;

  publicfunctiongetNombre(){
    return $nombre;
  }

  publicfunctionsetNombre($nombre){
    $this->nombre = $nombre;
  }

  publicfunctiongetDescripcion(){
    return $descripción;
  }

  publicfunctionsetDescripcion($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.

classEstudiante{
  protected $nombre;
  protected $email;

  publicfunction__construct($nombre){
    $this->nombre = $nombre;
  }

  // getters y setters
}

classCurso{
  protected $nombre;
  protected $descripción;

  publicfunction__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('[email protected]');

// 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 Platziecho"$nombreEstudiante está haciendo el curso de $nombreCurso en Platzi";
<h1>Relación entre clases</h1>

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.

classProfesor{
  // Atributos y métodos contemplados
}

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

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

  publicfunctiongetNumeroEstudiantes(){
    return count($listaEstudiantes);
  }

  publicfunctionadicionarEstudiante(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 contandoecho"El curso $nombreCurso que orienta el profesor $nombreProfesor tiene $numeroEstudiantes, y contando";
Escribe tu comentario
+ 2