OOP Concepts

Core OOP Principles

• Encapsulation: Bundling data and methods together, hiding internal details
• Abstraction: Showing only essential features, hiding implementation details
• Inheritance: Creating new classes based on existing classes
• Polymorphism: Ability to take multiple forms

1. Classes and Objects

Class Definition

A class is a blueprint for creating objects:

class ClassName {
    // Access specifiers
    private:
        // Private members
    public:
        // Public members
    protected:
        // Protected members
};

Object Creation

An object is an instance of a class:

ClassName objectName;  // Static object
ClassName *ptr = new ClassName();  // Dynamic object

Complete Example

#include <iostream>
#include <string>
using namespace std;

class Student {
private:
    string name;
    int rollNo;
    float marks;

public:
    // Member functions
    void setData(string n, int r, float m) {
        name = n;
        rollNo = r;
        marks = m;
    }
    
    void displayData() {
        cout << "Name: " << name << endl;
        cout << "Roll No: " << rollNo << endl;
        cout << "Marks: " << marks << endl;
    }
    
    float getMarks() {
        return marks;
    }
};

int main() {
    Student s1;  // Object creation
    s1.setData("John", 101, 85.5);
    s1.displayData();
    
    return 0;
}

2. Access Specifiers

• private: Members are accessible only within the class
• public: Members are accessible from anywhere
• protected: Members are accessible within the class and derived classes

class Example {
private:
    int privateVar;  // Only accessible within class
    
public:
    int publicVar;   // Accessible everywhere
    
protected:
    int protectedVar;  // Accessible in class and derived classes
};

3. Constructors

Special member functions that initialize objects. They have the same name as the class:

Default Constructor

class MyClass {
public:
    MyClass() {
        // Default constructor
        cout << "Default constructor called" << endl;
    }
};

Parameterized Constructor

class MyClass {
    int value;
public:
    MyClass(int v) {
        value = v;
        cout << "Parameterized constructor called" << endl;
    }
};

Copy Constructor

class MyClass {
    int value;
public:
    MyClass(const MyClass &obj) {
        value = obj.value;
        cout << "Copy constructor called" << endl;
    }
};

Complete Example

#include <iostream>
using namespace std;

class Rectangle {
private:
    int length, width;

public:
    // Default constructor
    Rectangle() {
        length = 0;
        width = 0;
    }
    
    // Parameterized constructor
    Rectangle(int l, int w) {
        length = l;
        width = w;
    }
    
    // Copy constructor
    Rectangle(const Rectangle &r) {
        length = r.length;
        width = r.width;
    }
    
    int area() {
        return length * width;
    }
};

int main() {
    Rectangle r1;           // Default constructor
    Rectangle r2(5, 3);     // Parameterized constructor
    Rectangle r3(r2);       // Copy constructor
    
    cout << "Area: " << r2.area() << endl;
    return 0;
}

4. Destructors

Special member function that is called when an object is destroyed. Used for cleanup:

#include <iostream>
using namespace std;

class MyClass {
public:
    MyClass() {
        cout << "Constructor called" << endl;
    }
    
    ~MyClass() {
        cout << "Destructor called" << endl;
    }
};

int main() {
    MyClass obj;
    // Destructor called automatically when obj goes out of scope
    return 0;
}

5. Encapsulation

Binding data and methods together, hiding internal implementation:

class BankAccount {
private:
    double balance;  // Hidden data
    
public:
    void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        }
    }
    
    void withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
        }
    }
    
    double getBalance() {
        return balance;
    }
};

6. Abstraction

Showing only essential features, hiding implementation details:

class Calculator {
public:
    // Public interface - what user sees
    double add(double a, double b) {
        return performAddition(a, b);
    }
    
private:
    // Hidden implementation - how it works
    double performAddition(double a, double b) {
        return a + b;
    }
};

7. Static Members

Shared by all objects of the class:

#include <iostream>
using namespace std;

class Counter {
private:
    static int count;  // Static member variable

public:
    Counter() {
        count++;
    }
    
    static int getCount() {  // Static member function
        return count;
    }
};

int Counter::count = 0;  // Definition outside class

int main() {
    Counter c1, c2, c3;
    cout << "Total objects: " << Counter::getCount() << endl;
    return 0;
}