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:
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;
public function__construct($nombre) {
$this->nombre = $nombre;
}
// getters y setters
}
classCurso{
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('[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;
public function__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";