El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Encapsulación y Abstracción

Siguiente ►
►

En este tema, exploraremos dos conceptos fundamentales de la Programación Orientada a Objetos (POO): la encapsulación y la abstracción. Ambos conceptos son esenciales para escribir código modular, mantenible y reutilizable.

Encapsulación

¿Qué es la Encapsulación?

La encapsulación es el proceso de agrupar datos (variables) y métodos (funciones) que operan sobre esos datos en una sola unidad, llamada clase. La encapsulación también implica restringir el acceso a ciertos componentes de un objeto, lo que se logra mediante modificadores de acceso.

Modificadores de Acceso

En C++, los modificadores de acceso son:

  • public: Los miembros son accesibles desde cualquier parte del programa.
  • private: Los miembros solo son accesibles desde dentro de la misma clase.
  • protected: Los miembros son accesibles desde la misma clase y las clases derivadas.

Ejemplo de Encapsulación

#include <iostream>
using namespace std;

class Persona {
private:
    string nombre;
    int edad;

public:
    // Constructor
    Persona(string n, int e) : nombre(n), edad(e) {}

    // Métodos para acceder a los datos privados
    string getNombre() {
        return nombre;
    }

    void setNombre(string n) {
        nombre = n;
    }

    int getEdad() {
        return edad;
    }

    void setEdad(int e) {
        edad = e;
    }

    void mostrarInformacion() {
        cout << "Nombre: " << nombre << ", Edad: " << edad << endl;
    }
};

int main() {
    Persona p1("Juan", 30);
    p1.mostrarInformacion();

    // Modificar los datos usando métodos públicos
    p1.setNombre("Carlos");
    p1.setEdad(35);
    p1.mostrarInformacion();

    return 0;
}

Explicación del Código

  1. Clase Persona: Contiene dos datos privados (nombre y edad) y métodos públicos para acceder y modificar estos datos.
  2. Constructor: Inicializa los datos privados.
  3. Métodos get y set: Permiten acceder y modificar los datos privados de manera controlada.
  4. Método mostrarInformacion: Muestra la información de la persona.

Ventajas de la Encapsulación

  • Control de Acceso: Protege los datos internos de accesos no autorizados.
  • Modularidad: Facilita la división del código en módulos independientes.
  • Mantenibilidad: Hace que el código sea más fácil de mantener y modificar.

Abstracción

¿Qué es la Abstracción?

La abstracción es el proceso de ocultar los detalles de implementación y mostrar solo la funcionalidad esencial de un objeto. En otras palabras, se enfoca en lo que hace un objeto en lugar de cómo lo hace.

Ejemplo de Abstracción

#include <iostream>
using namespace std;

// Clase abstracta
class Figura {
public:
    virtual void dibujar() = 0; // Método puro virtual
};

class Circulo : public Figura {
public:
    void dibujar() override {
        cout << "Dibujando un círculo" << endl;
    }
};

class Rectangulo : public Figura {
public:
    void dibujar() override {
        cout << "Dibujando un rectángulo" << endl;
    }
};

int main() {
    Figura* f1 = new Circulo();
    Figura* f2 = new Rectangulo();

    f1->dibujar();
    f2->dibujar();

    delete f1;
    delete f2;

    return 0;
}

Explicación del Código

  1. Clase Abstracta Figura: Contiene un método puro virtual dibujar(), lo que la convierte en una clase abstracta.
  2. Clases Circulo y Rectangulo: Heredan de Figura e implementan el método dibujar().
  3. Uso de Polimorfismo: Se crean objetos de Circulo y Rectangulo y se llaman sus métodos dibujar() a través de punteros de tipo Figura.

Ventajas de la Abstracción

  • Simplicidad: Facilita la comprensión del código al ocultar los detalles complejos.
  • Reusabilidad: Permite reutilizar el código en diferentes contextos.
  • Flexibilidad: Facilita la modificación y extensión del código sin afectar otras partes del sistema.

Ejercicio Práctico

Ejercicio

Crea una clase CuentaBancaria que tenga los siguientes atributos privados: numeroCuenta, saldo y titular. Implementa métodos públicos para depositar y retirar dinero, así como para mostrar la información de la cuenta.

Solución

#include <iostream>
using namespace std;

class CuentaBancaria {
private:
    string numeroCuenta;
    double saldo;
    string titular;

public:
    // Constructor
    CuentaBancaria(string nc, double s, string t) : numeroCuenta(nc), saldo(s), titular(t) {}

    // Métodos para depositar y retirar dinero
    void depositar(double cantidad) {
        saldo += cantidad;
    }

    void retirar(double cantidad) {
        if (cantidad <= saldo) {
            saldo -= cantidad;
        } else {
            cout << "Fondos insuficientes" << endl;
        }
    }

    // Método para mostrar la información de la cuenta
    void mostrarInformacion() {
        cout << "Titular: " << titular << ", Número de Cuenta: " << numeroCuenta << ", Saldo: " << saldo << endl;
    }
};

int main() {
    CuentaBancaria cuenta("123456789", 1000.0, "Ana Perez");
    cuenta.mostrarInformacion();

    cuenta.depositar(500.0);
    cuenta.mostrarInformacion();

    cuenta.retirar(200.0);
    cuenta.mostrarInformacion();

    cuenta.retirar(1500.0); // Intento de retiro con fondos insuficientes

    return 0;
}

Explicación del Código

  1. Clase CuentaBancaria: Contiene atributos privados (numeroCuenta, saldo, titular) y métodos públicos para depositar, retirar y mostrar información.
  2. Método depositar: Aumenta el saldo de la cuenta.
  3. Método retirar: Disminuye el saldo de la cuenta si hay fondos suficientes.
  4. Método mostrarInformacion: Muestra la información de la cuenta.

Conclusión

En esta sección, hemos aprendido sobre la encapsulación y la abstracción, dos pilares fundamentales de la Programación Orientada a Objetos. La encapsulación nos permite proteger y controlar el acceso a los datos, mientras que la abstracción nos ayuda a simplificar y modularizar nuestro código. Estos conceptos son esenciales para escribir código limpio, mantenible y escalable.

En el próximo módulo, profundizaremos en temas avanzados de POO, como la herencia y el polimorfismo, que nos permitirán crear jerarquías de clases más complejas y reutilizables.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados