Object-Oriented Programming (OOP) Explained
Object-Oriented Programming (OOP) is a programming paradigm that organizes software design around objects, which are instances of classes. OOP focuses on encapsulating data and behavior into reusable and modular components. This section will cover the key concepts related to OOP in C++.
Key Concepts
1. Classes and Objects
A class is a blueprint for creating objects (instances of the class). It defines the properties (data members) and behaviors (member functions) that the objects will have. An object is an instance of a class.
Example:
#include <iostream>
using namespace std;
class Car {
public:
string brand;
string model;
int year;
void displayInfo() {
cout << "Brand: " << brand << endl;
cout << "Model: " << model << endl;
cout << "Year: " << year << endl;
}
};
int main() {
Car car1;
car1.brand = "Toyota";
car1.model = "Camry";
car1.year = 2020;
car1.displayInfo();
return 0;
}
2. Encapsulation
Encapsulation is the process of bundling the data (attributes) and methods (functions) that operate on the data into a single unit (class). It also involves restricting direct access to some of the object's components.
Example:
#include <iostream>
using namespace std;
class BankAccount {
private:
double balance;
public:
void deposit(double amount) {
balance += amount;
}
void withdraw(double amount) {
if (balance >= amount) {
balance -= amount;
} else {
cout << "Insufficient funds" << endl;
}
}
double getBalance() {
return balance;
}
};
int main() {
BankAccount account;
account.deposit(1000);
account.withdraw(500);
cout << "Balance: " << account.getBalance() << endl;
return 0;
}
3. Inheritance
Inheritance allows a class to inherit properties and behaviors from another class. The class that inherits is called the derived class (or subclass), and the class being inherited from is called the base class (or superclass).
Example:
#include <iostream>
using namespace std;
class Animal {
public:
void eat() {
cout << "Eating..." << endl;
}
};
class Dog : public Animal {
public:
void bark() {
cout << "Barking..." << endl;
}
};
int main() {
Dog dog;
dog.eat();
dog.bark();
return 0;
}
4. Polymorphism
Polymorphism allows objects of different classes to be treated as objects of a common superclass. It enables methods to be written that can work with objects of multiple types.
Example:
#include <iostream>
using namespace std;
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 Square : public Shape {
public:
void draw() override {
cout << "Drawing a square" << endl;
}
};
int main() {
Shape* shapes[2];
shapes[0] = new Circle();
shapes[1] = new Square();
for (int i = 0; i < 2; i++) {
shapes[i]->draw();
}
return 0;
}
5. Abstraction
Abstraction is the process of hiding the complex reality while exposing only the necessary parts. In C++, abstraction is achieved through abstract classes and interfaces.
Example:
#include <iostream>
using namespace std;
class AbstractShape {
public:
virtual void draw() = 0; // Pure virtual function
};
class Circle : public AbstractShape {
public:
void draw() override {
cout << "Drawing a circle" << endl;
}
};
int main() {
AbstractShape* shape = new Circle();
shape->draw();
return 0;
}
6. Composition
Composition is a design principle where a class is composed of one or more objects of other classes. It allows for more flexible and modular code.
Example:
#include <iostream>
using namespace std;
class Engine {
public:
void start() {
cout << "Engine started" << endl;
}
};
class Car {
private:
Engine engine;
public:
void startCar() {
engine.start();
cout << "Car started" << endl;
}
};
int main() {
Car car;
car.startCar();
return 0;
}
7. Association
Association is a relationship between two classes that allows one object instance to cause another to perform an action on its behalf. It can be a one-to-one, one-to-many, or many-to-many relationship.
Example:
#include <iostream>
#include <vector>
using namespace std;
class Student {
public:
string name;
Student(string n) : name(n) {}
};
class Course {
public:
string title;
vector<Student*> students;
Course(string t) : title(t) {}
void addStudent(Student* student) {
students.push_back(student);
}
void displayStudents() {
cout << "Students in " << title << ":" << endl;
for (Student* student : students) {
cout << student->name << endl;
}
}
};
int main() {
Student s1("Alice");
Student s2("Bob");
Course c1("Math");
c1.addStudent(&s1);
c1.addStudent(&s2);
c1.displayStudents();
return 0;
}
Examples and Analogies
Example: Using OOP to Model a Library System
#include <iostream>
#include <vector>
using namespace std;
class Book {
public:
string title;
string author;
int year;
Book(string t, string a, int y) : title(t), author(a), year(y) {}
void displayInfo() {
cout << "Title: " << title << endl;
cout << "Author: " << author << endl;
cout << "Year: " << year << endl;
}
};
class Library {
public:
vector<Book> books;
void addBook(Book book) {
books.push_back(book);
}
void displayBooks() {
cout << "Books in the library:" << endl;
for (Book book : books) {
book.displayInfo();
}
}
};
int main() {
Library library;
library.addBook(Book("The Great Gatsby", "F. Scott Fitzgerald", 1925));
library.addBook(Book("1984", "George Orwell", 1949));
library.displayBooks();
return 0;
}
Analogy: OOP as a Car Factory
Think of OOP as a car factory where each car (object) is built from a blueprint (class). The factory (program) can produce different models (classes) of cars, each with its own features (attributes and methods). The factory can also assemble cars from different parts (composition), and each car can perform actions (methods) like starting the engine or honking the horn.