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

Introducción a la POO

Siguiente ►
►

La Programación Orientada a Objetos (POO) es un paradigma de programación que utiliza "objetos" y sus interacciones para diseñar aplicaciones y programas. Este enfoque se centra en los datos (objetos) y en las operaciones que se pueden realizar sobre esos datos (métodos). En este módulo, aprenderás los conceptos fundamentales de la POO y cómo aplicarlos en C++.

Conceptos Clave de la POO

  1. Clases y Objetos:

    • Clase: Es una plantilla o blueprint que define las propiedades (atributos) y comportamientos (métodos) que los objetos creados a partir de la clase pueden tener.
    • Objeto: Es una instancia de una clase. Cada objeto tiene su propio conjunto de atributos y puede ejecutar los métodos definidos en la clase.

  2. Encapsulación:

    • Es el concepto de agrupar datos y métodos que operan sobre esos datos en una sola unidad (clase) y restringir el acceso a algunos de los componentes del objeto.

  3. Herencia:

    • Permite crear nuevas clases basadas en clases existentes. La nueva clase (subclase) hereda atributos y métodos de la clase existente (superclase).

  4. Polimorfismo:

    • Permite que una entidad, como una función o un objeto, tome múltiples formas. En C++, esto se logra principalmente a través de la sobrecarga de funciones y la herencia.

  5. Abstracción:

    • Es el proceso de ocultar los detalles de implementación y mostrar solo la funcionalidad esencial del objeto.

Ejemplo Práctico: Definición de una Clase y Creación de Objetos

Vamos a crear una clase simple llamada Persona que tendrá atributos como nombre y edad, y métodos para establecer y obtener estos atributos.

Definición de la Clase

#include <iostream>
#include <string>

class Persona {
private:
    std::string nombre;
    int edad;

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

    // Métodos para establecer y obtener el nombre
    void setNombre(std::string n) {
        nombre = n;
    }

    std::string getNombre() {
        return nombre;
    }

    // Métodos para establecer y obtener la edad
    void setEdad(int e) {
        edad = e;
    }

    int getEdad() {
        return edad;
    }

    // Método para mostrar la información de la persona
    void mostrarInformacion() {
        std::cout << "Nombre: " << nombre << ", Edad: " << edad << std::endl;
    }
};

Creación de Objetos

int main() {
    // Crear un objeto de la clase Persona
    Persona persona1("Juan", 30);

    // Mostrar la información de la persona
    persona1.mostrarInformacion();

    // Modificar los atributos del objeto
    persona1.setNombre("Carlos");
    persona1.setEdad(35);

    // Mostrar la información actualizada de la persona
    persona1.mostrarInformacion();

    return 0;
}

Explicación del Código

  1. Definición de la Clase:

    • La clase Persona tiene dos atributos privados: nombre y edad.
    • El constructor Persona(std::string n, int e) inicializa los atributos nombre y edad.
    • Los métodos setNombre, getNombre, setEdad y getEdad permiten establecer y obtener los valores de los atributos.
    • El método mostrarInformacion imprime los valores de los atributos en la consola.

  2. Creación de Objetos:

    • En la función main, se crea un objeto persona1 de la clase Persona con el nombre "Juan" y la edad 30.
    • Se llama al método mostrarInformacion para imprimir los valores iniciales de los atributos.
    • Se modifican los atributos del objeto usando los métodos setNombre y setEdad.
    • Se llama nuevamente al método mostrarInformacion para imprimir los valores actualizados de los atributos.

Ejercicio Práctico

Ejercicio 1: Crear una Clase Coche

  1. Define una clase Coche con los siguientes atributos privados:

    • marca (tipo std::string)
    • modelo (tipo std::string)
    • año (tipo int)

  2. Implementa un constructor que inicialice estos atributos.

  3. Implementa métodos públicos para establecer y obtener los valores de estos atributos.

  4. Implementa un método mostrarInformacion que imprima los valores de los atributos en la consola.

Solución

#include <iostream>
#include <string>

class Coche {
private:
    std::string marca;
    std::string modelo;
    int año;

public:
    // Constructor
    Coche(std::string m, std::string mod, int a) : marca(m), modelo(mod), año(a) {}

    // Métodos para establecer y obtener la marca
    void setMarca(std::string m) {
        marca = m;
    }

    std::string getMarca() {
        return marca;
    }

    // Métodos para establecer y obtener el modelo
    void setModelo(std::string mod) {
        modelo = mod;
    }

    std::string getModelo() {
        return modelo;
    }

    // Métodos para establecer y obtener el año
    void setAño(int a) {
        año = a;
    }

    int getAño() {
        return año;
    }

    // Método para mostrar la información del coche
    void mostrarInformacion() {
        std::cout << "Marca: " << marca << ", Modelo: " << modelo << ", Año: " << año << std::endl;
    }
};

int main() {
    // Crear un objeto de la clase Coche
    Coche coche1("Toyota", "Corolla", 2020);

    // Mostrar la información del coche
    coche1.mostrarInformacion();

    // Modificar los atributos del objeto
    coche1.setMarca("Honda");
    coche1.setModelo("Civic");
    coche1.setAño(2022);

    // Mostrar la información actualizada del coche
    coche1.mostrarInformacion();

    return 0;
}

Retroalimentación y Consejos

  • Errores Comunes:

    • Olvidar inicializar los atributos en el constructor.
    • No utilizar los métodos set y get para acceder a los atributos privados.
    • No utilizar el operador de resolución de ámbito :: correctamente.

  • Consejos:

    • Siempre encapsula los atributos de una clase para proteger los datos y mantener la integridad del objeto.
    • Utiliza nombres de métodos y atributos descriptivos para mejorar la legibilidad del código.
    • Practica creando diferentes clases y objetos para familiarizarte con los conceptos de la POO.

Conclusión

En esta sección, hemos introducido los conceptos fundamentales de la Programación Orientada a Objetos y cómo aplicarlos en C++. Aprendiste a definir clases, crear objetos y utilizar métodos para manipular los atributos de los objetos. Estos conceptos son esenciales para desarrollar aplicaciones complejas y bien estructuradas en C++. En la próxima sección, profundizaremos en las clases y objetos, explorando constructores y destructores.

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