9. POO básico

La Programación Orientada a Objetos (POO) nos permite estructurar el código pensando en entidades del mundo real o de un videojuego.

1. Clases vs Objetos (La clase `Espada`)

Una clase es como el plano o plantilla. Un objeto es una instancia concreta creada a partir de esa plantilla.

Clase Espada y creación de objetos

CPP

#include <iostream>
#include <string>
 
using namespace std;
 
class Espada {
private:
    string name;
    string type;
    int damage;
    int durability;
 
public:
    // Constructor
    Espada(string name, string type, int damage, int durability) {
        this->name = name;
        this->type = type;
        this->damage = damage;
        this->durability = durability;
    }
 
    // Métodos
    void atacar() {
        cout << name << " ataca y causa " << damage << " de daño." << endl;
        durability--;
    }
 
    void mostrarInfo() {
        cout << "Nombre: " << name << "\n"
             << "Tipo: " << type << "\n"
             << "Daño: " << damage << "\n"
             << "Durabilidad: " << durability << endl;
    }
};
 
int main() {
    // Creación de objetos a partir de la clase Espada
    Espada excalibur("Excalibur", "Legendaria", 100, 50);
    Espada katana("Katana", "Samurai", 70, 80);
    Espada espadaHierro("Espada de Hierro", "Medieval", 40, 100);
 
    excalibur.mostrarInfo();
    excalibur.atacar();
 
    return 0;
}

2. Encapsulamiento: `private`, `public` y Getters/Setters

Los atributos definidos como private solo se pueden acceder o modificar desde dentro de la propia clase.

¿Es obligatorio crear get y set para todos los atributos?
No. Solo debes crearlos cuando sea necesario acceder o modificar un atributo desde fuera de forma controlada (por ejemplo, para validar que el daño no sea negativo). Si un valor solo se usa internamente (como la durabilidad al usar la espada), no necesitas getters ni setters para él.

Uso práctico de Getters y Encapsulamiento

CPP

class Espada {
private:
    string name;
    int damage;
    int durability;
 
public:
    Espada(string name, int damage, int durability)
        : name(name), damage(damage), durability(durability) {}
 
    // Getter: Solo lectura para consultar el daño desde fuera
    int getDamage() const {
        return damage;
    }
 
    string getName() const {
        return name;
    }
 
    // Método que modifica el estado interno sin requerir un setter
    void usar() {
        durability--;
        if (durability < 0) durability = 0;
    }
};

3. Asociación entre Clases (`Player` tiene una `Espada`)

Las clases pueden relacionarse entre sí. Por ejemplo, un Player puede contener una Espada como atributo y combatir contra otro Player.

Combate entre Players usando la clase Espada

CPP

#include <iostream>
#include <string>
 
using namespace std;
 
class Espada {
private:
    string name;
    string type;
    int damage;
    int durability;
 
public:
    Espada(string name, string type, int damage, int durability)
        : name(name), type(type), damage(damage), durability(durability) {}
 
    int getDamage() const { return damage; }
    string getName() const { return name; }
 
    void usar() {
        durability--;
        if (durability < 0) durability = 0;
    }
};
 
class Player {
private:
    string name;
    int health;
    Espada espada;
 
public:
    Player(string name, int health, Espada espada)
        : name(name), health(health), espada(espada) {}
 
    // Recibe otro Player por referencia para aplicarle el ataque
    void atacar(Player &enemigo) {
        cout << name << " ataca a " << enemigo.name 
             << " usando " << espada.getName() << "!" << endl;
 
        enemigo.health -= espada.getDamage();
        espada.usar();
 
        if (enemigo.health < 0) enemigo.health = 0;
    }
 
    void mostrarEstado() const {
        cout << name << " | Vida: " << health << endl;
    }
 
    bool estaVivo() const {
        return health > 0;
    }
};
 
int main() {
    Espada excalibur("Excalibur", "Legendaria", 30, 100);
    Espada katana("Katana", "Samurai", 20, 100);
 
    Player guerrero("Guerrero", 100, excalibur);
    Player samurai("Samurai", 100, katana);
 
    guerrero.mostrarEstado();
    samurai.mostrarEstado();
 
    cout << "\n--- COMBATE ---\n" << endl;
 
    guerrero.atacar(samurai);
    samurai.mostrarEstado();
 
    samurai.atacar(guerrero);
    guerrero.mostrarEstado();
 
    return 0;
}

Ejercicio

Agregá a la clase Espada una comprobación para que si durability == 0, la espada ya no cause daño en getDamage() o devuelva 0 de daño. Luego probá realizar varios ataques en main() hasta romper la espada.

Contenido

📚 Cursos de Café y Código

9. POO básico

1. Clases vs Objetos (La clase `Espada`)

2. Encapsulamiento: `private`, `public` y Getters/Setters

3. Asociación entre Clases (`Player` tiene una `Espada`)

Ejercicio

¡Hecho con mucho cariño! ☕

9. POO básico

1. Clases vs Objetos (La clase Espada)

2. Encapsulamiento: private, public y Getters/Setters

3. Asociación entre Clases (Player tiene una Espada)

Ejercicio

1. Clases vs Objetos (La clase `Espada`)

2. Encapsulamiento: `private`, `public` y Getters/Setters

3. Asociación entre Clases (`Player` tiene una `Espada`)