A constructor is a special method that is automatically called when an object is created. It initializes the object's attributes. A destructor is called when an object is destroyed to release resources.

Constructor Types

1. Default Constructor: Takes no parameters
2. Parameterized Constructor: Takes parameters to initialize attributes with specific values

class BankAccount {
private:
    string accountHolder;
    double balance;

public:
    // Parameterized constructor
    BankAccount(string name, double initialBalance) {
        accountHolder = name;
        balance = initialBalance;
    }
    
    // Destructor
    ~BankAccount() {
        cout << "Account for " << accountHolder << " closed." << endl;
    }
    
    void display() {
        cout << "Holder: " << accountHolder << ", Balance: TZS " << balance << endl;
    }
};

int main() {
    BankAccount acc("John Mwakidudu", 500000);
    acc.display();
    return 0;
}

Encapsulation bundles data (attributes) and methods that operate on that data into a single unit (class). It also restricts direct access to some components, which prevents accidental modification of data. Access specifiers control visibility:

• public: Accessible from anywhere
• private: Accessible only within the class (default for class members)
• protected: Accessible within the class and derived classes

class BankAccount {
private:                  // Private data - hidden from outside
    string accountNumber;
    double balance;

public:                   // Public methods - controlled access
    // Constructor
    BankAccount(string accNum, double bal) {
        accountNumber = accNum;
        balance = bal;
    }
    
    // Getter method
    double getBalance() {
        return balance;
    }
    
    // Setter method with validation
    void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        }
    }
    
    void withdraw(double amount) {
        if (amount <= balance) {
            balance -= amount;
        } else {
            cout << "Insufficient funds!" << endl;
        }
    }
};

Inheritance allows a new class (subclass/derived class) to inherit attributes and methods from an existing class (superclass/base class). This promotes code reusability.

Types of Inheritance

1. Single Inheritance: One subclass inherits from one superclass
2. Multilevel Inheritance: A class inherits from another class, which itself inherits from another
3. Hierarchical Inheritance: One superclass has multiple subclasses
4. Hybrid Inheritance: Combination of multiple inheritance types

// Base class (Parent)
class Animal {
public:
    string name;
    int age;
    
    void eat() {
        cout << name << " is eating." << endl;
    }
};

// Derived class (Child)
class Dog : public Animal {
public:
    string breed;
    
    void bark() {
        cout << name << " barks: Woof! Woof!" << endl;
    }
};

int main() {
    Dog myDog;
    myDog.name = "Bingo";
    myDog.age = 3;
    myDog.breed = "German Shepherd";
    myDog.eat();
    myDog.bark();
    return 0;
}

Polymorphism allows objects of different classes to be treated as objects of a common superclass. It enables a single interface to represent different underlying forms.

Method Overloading (Compile-time Polymorphism)

Multiple methods with the same name but different parameters within the same class.

class Calculator {
public:
    int add(int a, int b) {
        return a + b;
    }
    
    double add(double a, double b) {
        return a + b;
    }
    
    int add(int a, int b, int c) {
        return a + b + c;
    }
};

Method Overriding (Runtime Polymorphism)

A subclass provides its own implementation of a method already defined in the superclass.

class Shape {
public:
    virtual void draw() {
        cout << "Drawing a shape" << endl;
    }
};

class Circle : public Shape {
public:
    void draw() override {
        cout << "Drawing a circle" << endl;
    }
};

class Rectangle : public Shape {
public:
    void draw() override {
        cout << "Drawing a rectangle" << endl;
    }
};

int main() {
    Shape* shapes[2];
    shapes[0] = new Circle();
    shapes[1] = new Rectangle();
    
    for (int i = 0; i < 2; i++) {
        shapes[i]->draw();  // Polymorphic call
    }
    return 0;
}

Abstraction hides complex implementation details and shows only essential features. It focuses on what an object does rather than how it does it.

#include <iostream>
using namespace std;

class BankAccount {
private:
    string accountNumber;
    double balance;

public:
    void deposit(double amount) {
        // Implementation hidden from user
        balance += amount;
        cout << "Deposit successful!" << endl;
    }
    
    void withdraw(double amount) {
        // User doesn't need to know internal logic
        if (amount <= balance) {
            balance -= amount;
            cout << "Withdrawal successful!" << endl;
        } else {
            cout << "Insufficient balance!" << endl;
        }
    }
    
    void displayBalance() {
        cout << "Current balance: TZS " << balance << endl;
    }
};

int main() {
    BankAccount acc;
    acc.deposit(100000);
    acc.displayBalance();
    acc.withdraw(30000);
    acc.displayBalance();
    return 0;
}

Arrays of Objects

class Student {
public:
    string name;
    int marks;
    
    void display() {
        cout << name << ": " << marks << endl;
    }
};

int main() {
    Student students[3];
    students[0].name = "Amina";
    students[0].marks = 85;
    students[1].name = "Rajabu";
    students[1].marks = 92;
    students[2].name = "Grace";
    students[2].marks = 78;
    
    for (int i = 0; i < 3; i++) {
        students[i].display();
    }
    return 0;
}

Syntax Errors

• Missing semicolons, parentheses, or braces
• Misspelled keywords
• Case sensitivity issues

Semantic Errors

• Using uninitialized variables
• Type mismatches
• Incorrect operator usage

Logical Errors

• Wrong formula implementation
• Loop errors (off-by-one)
• Incorrect condition in if statements

Runtime Errors

• Division by zero
• Array index out of bounds
• Null pointer dereference

In Tanzania, OOP principles are widely used in mobile banking applications like M-Pesa and banking systems. For example, when developing a school fee payment system, a programmer would create a Student class with attributes like name, admission number, and balance, then use inheritance to create PrimaryStudent and SecondaryStudent subclasses. Encapsulation ensures that private data like account balances can only be modified through public methods like deposit() and withdraw(), preventing unauthorized access and maintaining data integrity for handling school fees in Tanzanian shillings.