El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
HOME Els meus cursos Finalitzats
◄ Anterior
◄

Encapsulació i Abstracció

Següent ►
►

Introducció

En aquest tema, explorarem dos conceptes fonamentals de la Programació Orientada a Objectes (POO): l'encapsulació i l'abstracció. Aquests conceptes ajuden a organitzar i gestionar el codi de manera més eficient i segura.

Encapsulació

Què és l'Encapsulació?

L'encapsulació és el procés de restringir l'accés a certs components d'un objecte i només exposar aquells que són necessaris per a l'ús extern. Això es fa per protegir les dades i assegurar que només es puguin modificar de maneres controlades.

Beneficis de l'Encapsulació

  • Seguretat: Protegeix les dades de modificacions no autoritzades.
  • Modularitat: Facilita la divisió del codi en mòduls més petits i manejables.
  • Mantenibilitat: Simplifica la modificació i actualització del codi.

Implementació de l'Encapsulació en C++

En C++, l'encapsulació es realitza utilitzant modificadors d'accés com private, protected i public.

#include <iostream>
using namespace std;

class Rectangle {
private:
    double length;
    double width;

public:
    // Constructor
    Rectangle(double l, double w) {
        length = l;
        width = w;
    }

    // Mètode per calcular l'àrea
    double area() {
        return length * width;
    }

    // Mètode per establir la longitud
    void setLength(double l) {
        if (l > 0) {
            length = l;
        }
    }

    // Mètode per obtenir la longitud
    double getLength() {
        return length;
    }
};

int main() {
    Rectangle rect(10.0, 5.0);
    cout << "Àrea: " << rect.area() << endl;

    rect.setLength(15.0);
    cout << "Nova longitud: " << rect.getLength() << endl;
    cout << "Nova àrea: " << rect.area() << endl;

    return 0;
}

Explicació del Codi

  • Modificadors d'Accés: private restringeix l'accés a les variables length i width només dins de la classe Rectangle.
  • Mètodes Públics: setLength i getLength són mètodes públics que permeten modificar i accedir a la variable length de manera controlada.

Abstracció

Què és l'Abstracció?

L'abstracció és el procés de simplificar un sistema complex ocultant els detalls innecessaris i exposant només les parts rellevants. Això ajuda a reduir la complexitat i facilita la comprensió i l'ús del sistema.

Beneficis de l'Abstracció

  • Simplicitat: Redueix la complexitat mostrant només la informació essencial.
  • Reutilització: Facilita la reutilització del codi en diferents contextos.
  • Mantenibilitat: Simplifica la modificació i actualització del codi.

Implementació de l'Abstracció en C++

En C++, l'abstracció es pot aconseguir mitjançant l'ús de classes i interfícies.

#include <iostream>
using namespace std;

// Classe abstracta
class Shape {
public:
    // Mètode purament virtual
    virtual double area() = 0;
};

class Circle : public Shape {
private:
    double radius;

public:
    Circle(double r) {
        radius = r;
    }

    double area() override {
        return 3.14159 * radius * radius;
    }
};

int main() {
    Circle circle(5.0);
    cout << "Àrea del cercle: " << circle.area() << endl;

    return 0;
}

Explicació del Codi

  • Classe Abstracta: Shape és una classe abstracta amb un mètode purament virtual area().
  • Classe Derivada: Circle hereta de Shape i implementa el mètode area().

Exercicis Pràctics

Exercici 1: Encapsulació

Crea una classe BankAccount amb les següents característiques:

  • Variables privades: accountNumber, balance.
  • Mètodes públics: deposit(double amount), withdraw(double amount), getBalance().

Solució

#include <iostream>
using namespace std;

class BankAccount {
private:
    int accountNumber;
    double balance;

public:
    BankAccount(int accNum, double bal) {
        accountNumber = accNum;
        balance = bal;
    }

    void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        }
    }

    void withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
        }
    }

    double getBalance() {
        return balance;
    }
};

int main() {
    BankAccount account(12345, 1000.0);
    account.deposit(500.0);
    cout << "Saldo: " << account.getBalance() << endl;

    account.withdraw(200.0);
    cout << "Saldo: " << account.getBalance() << endl;

    return 0;
}

Exercici 2: Abstracció

Crea una classe abstracta Vehicle amb un mètode purament virtual move(). Implementa dues classes derivades Car i Bicycle que heretin de Vehicle i implementin el mètode move().

Solució

#include <iostream>
using namespace std;

class Vehicle {
public:
    virtual void move() = 0;
};

class Car : public Vehicle {
public:
    void move() override {
        cout << "El cotxe es mou per carretera." << endl;
    }
};

class Bicycle : public Vehicle {
public:
    void move() override {
        cout << "La bicicleta es mou per carretera." << endl;
    }
};

int main() {
    Car car;
    Bicycle bicycle;

    car.move();
    bicycle.move();

    return 0;
}

Resum

En aquest tema, hem après sobre l'encapsulació i l'abstracció, dos conceptes clau de la Programació Orientada a Objectes. Hem vist com aquests conceptes ajuden a organitzar i gestionar el codi de manera més eficient i segura. També hem implementat exemples pràctics per reforçar els conceptes apresos. En el proper tema, explorarem la programació orientada a objectes amb més profunditat, incloent-hi herència i polimorfisme.

◄ Anterior
◄
Següent ►
►
El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
© Copyright 2024. Tots els drets reservats