Programación

Los pilares de la orientación a objetos

Community LatAm

12 de jul. de 2024 • 5 min read

Los pilares de la orientación a objetos son cuatro conceptos fundamentales que guían la programación orientada a objetos. Son conceptos esenciales para crear un código modular, flexible, reutilizable y de fácil mantenimiento. Estos son: Abstracción, Encapsulamiento, Herencia y Polimorfismo.

En este artículo, vamos a detallar cada uno y proporcionar ejemplos.

1. Abstracción

El paradigma de la abstracción sostiene que debemos diseñar un sistema en varias partes, separadas y bien definidas, de modo que nos concentremos en los aspectos esenciales, desconsiderando las características menos importantes. De esta forma, se abstrae la complejidad del sistema y se enfoca en una parte determinada, que es el tema central en ese momento.

La abstracción consiste en la representación simple de objetos del mundo real. Una clase es un tipo de abstracción que define un conjunto de propiedades y métodos que representan un concepto particular. La abstracción permite que los objetos tengan características comunes y funcionen de manera consistente.

Vamos a aplicar este concepto en un ejemplo. Supongamos que queremos crear diferentes formas geométricas (círculo, cuadrado, triángulo) y calcular su respectiva área.

<?php
// Classe abstrata para representar uma forma geométrica
abstract class FormaGeometrica {
// Método abstrato para calcular a área
abstract public function calcularArea();
}

// Classe para representar um círculo
class Circulo extends FormaGeometrica {
private $raio;

public function __construct($raio) {
$this->raio = $raio;
}

public function calcularArea() {
return pi() * pow($this->raio, 2);
}
}

// Classe para representar um quadrado
class Quadrado extends FormaGeometrica {
private $lado;

public function __construct($lado) {
$this->lado = $lado;
}

public function calcularArea() {
return pow($this->lado, 2);
}
}

// Classe para representar um triângulo
class Triangulo extends FormaGeometrica {
private $base;
private $altura;

public function __construct($base, $altura) {
$this->base = $base;
$this->altura = $altura;
}

public function calcularArea() {
return ($this->base * $this->altura) / 2;
}
}

// Uso das classes
$circulo = new Circulo(5);
$quadrado = new Quadrado(4);
$triangulo = new Triangulo(6, 3);

echo "Área do círculo: " . $circulo->calcularArea() . " ";
echo "Área do quadrado: " . $quadrado->calcularArea() . " ";
echo "Área do triângulo: " . $triangulo->calcularArea() . " ";
?>

En este ejemplo, creamos una clase abstracta FormaGeometrica que define un método abstracto calcularArea(). A continuación, creamos clases concretas para representar las formas geométricas específicas (círculo, cuadrado y triángulo), y cada una de ellas implementa el método calcularArea() de acuerdo con su fórmula apropiada.

Esta abstracción permite que el código que utiliza estas clases interactúe con las formas geométricas de manera independiente de las implementaciones específicas de cada forma.

2. Encapsulamiento

El encapsulamiento es la idea de ocultar los detalles internos y el funcionamiento de los objetos, exponiendo solo una interfaz controlada para interactuar con ellos. Esto se logra usando modificadores de acceso en los atributos y métodos, como "private", "protected" y "public", para controlar quién puede acceder y modificar los datos y comportamientos de los objetos.

<?

class Aluno {
private $nota;
protected $faltas;
public $nome;

public function __construct($nota, $faltas, $nome) {
$this->nota = $nota;
$this->faltas = $faltas;
$this->nome = $nome;
}

// Método público que pode ser acessado de qualquer lugar
public function obtemNome() {
return "O nome do aluno é " . $this->nome;
}

// Método protegido que pode ser acessado apenas dentro da classe e suas subclasses
protected function obtemFaltas() {
return "O número de faltas do aluno é " . $this->faltas;
}

// Método privado que só pode ser acessado dentro da própria classe
private function obtemNota() {
return "A nota do aluno é " . $this->nota;
}
}

//Nova instância
$novoAluno = new Exemplo(5.5, 10, "Maria");

// Acesso ao atributo público (pode ser acessado de qualquer lugar)
echo "Atributo público: " . $novoAluno->nome . " "; // Sucesso

// Tentativa de acesso aos atributos privado e protegido resultará em erro
echo "Atributo privado: " . $novoAluno->nota; // Erro
echo "Atributo protegido: " . $novoAluno->faltas; // Erro

// Acesso ao método público (pode ser acessado de qualquer lugar)
echo $novoAluno->obtemNome() . " "; // Sucesso

// Tentativa de acesso aos métodos privado e protegido resultará em erro
echo $novoAluno->obtemFaltas(); // Erro
echo $novoAluno->obtemNota(); // Erro

3. Herencia

Cuando pensamos en herencia, imaginamos la relación familiar entre padres, hijos y abuelos y en las características que se transmiten de generación en generación. En la orientación a objetos, la herencia se trata de un compartimiento de atributos y comportamientos entre clases de una misma jerarquía, de la clase madre a las clases hijas. Veamos un ejemplo en la siguiente imagen.

La clase Empleado es la clase madre, de la cual aprovechamos sus propiedades (nombre, fechaNacimiento, cpf, sector y salario) y métodos (registraPunto) para crear las clases hijas Profesor y Director. Las clases hijas, además de heredar los puntos anteriormente mencionados, tendrán algunas características únicas. Para la clase Profesor, se agregó la inicialización de las propiedades disciplina y grupo, y para Director, se incluyó la propiedad unidad. En el caso de los métodos, la clase Profesor puede registrar la calificación de un alumno, y la clase Director puede registrar un nuevo empleado en la unidad escolar donde trabaja.

La herencia tiene una gran aplicabilidad, ya que en lugar de crear nuevas estructuras, se pueden aprovechar estructuras ya existentes.

4. Polimorfismo

El polimorfismo en orientación a objetos es el principio que permite que dos o más clases derivadas de una misma superclase tengan métodos iguales (con el mismo nombre y parámetros), pero con comportamientos distintos, redefinidos en cada una de las clases hijas. A continuación, tenemos un ejemplo utilizando el juego de ajedrez.

<?

class Peca {
abstract public function mover();
}

<?

class Torre extends Peca {
public function mover() {
echo "Movimenta em linha reta";
}
}

class Cavalo extends Peca {
public function mover() {
echo "Movimenta em 'L'";
}
}

class Bispo extends Peca {
public function mover() {
echo "Movimenta na diagonal";
}
}

class Peao extends Peca {
public function mover() {
echo "Movimenta para frente";
}
}

Torre->mover(); // Movimenta em linha reta
Cavalo->mover(); // Movimenta em 'L'
Bispo->mover(); // Movimenta na diagonal

Peao->mover(); // Movimenta para frente

El juego de ajedrez tiene diferentes piezas, y cada pieza realiza su movimiento: el peón se mueve hacia adelante, el caballo se mueve en L, la torre se mueve en línea recta y el alfil en diagonal. Aplicando esto al principio del polimorfismo, todos son derivados de la clase Peca y tienen el método mover, pero cada uno se mueve de una manera diferente, teniendo el método redefinido en la clase hija (clase Torre, Caballo, Alfil y Peon).

Conclusión

La orientación a objetos permite que el código refleje los conceptos del mundo real, facilitando su comprensión. De este modo, es esencial tener un buen entendimiento de sus paradigmas (Abstracción, Encapsulamiento, Herencia y Polimorfismo), para poder desarrollar software más eficiente, organizado y de mejor mantenimiento.

💡

Las opiniones y comentarios emitidos en este artículo son propiedad única de su autor y no necesariamente representan el punto de vista de Listopro.

Listopro Community da la bienvenida a todas las razas, etnias, nacionalidades, credos, géneros, orientaciones, puntos de vista e ideologías, siempre y cuando promuevan la diversidad, la equidad, la inclusión y el crecimiento profesional de los profesionales en tecnología.