Object-Oriented Programming (OOP) is a powerful paradigm in software development, designed to model real-world entities and their interactions. By using objects as its foundation, OOP allows developers to create modular, reusable, and maintainable code. Key principles such as inheritance, polymorphism, and encapsulation ensure seamless integration of data and functions, while safeguarding data from unauthorized access.
Core concepts of OOP include classes, which define the blueprint for objects; objects, the runtime instances of classes; and techniques like abstraction, which hides unnecessary details, exposing only essential functionalities. These features, combined with dynamic binding and message passing, make OOP a preferred approach for building robust and flexible applications.
Whether you’re modeling a Student class with attributes like StudentName and behaviors like CalculateAttendance(), or using inheritance to define a Dog class that extends an Animal class, OOP simplifies complex problems by mirroring the way we perceive the world.
Name impiles uses objects in programming.
Oop is aimed to implement real time entiites
The primary objective of OOP is to combine data and the functions that manipulate it into a single unit, ensuring that only the designated functions have access to this data, preventing other parts of the code from directly interacting with it.
The real world entity that has both data and functions are binded together.so that other functions will not access will not access data members of other function.
For example: let take a student class that has data members:
Data members:
Studentname:
StudentId:
StudentMarks:
Data functions:
Calculatetotal()
CalculateAverage()
CalculateAttedance()
For example: let take a vehicle class that has data members:
Data members:
VehicleNo:
ModelName:
Modelno:
ModelColor:
Data functions:
Start()
Stope()
ApplyBrake();
Object:
When a class is defined in C++, no memory is allocated. However, memory is allocated when the class is instantiated by creating an object.
Encapsulation is a process of binding the data and members together
Class is an example of class
Class Student
{
string studentname:
int studentid:
int studentmarks:
Calculatetotal()
CalculateAverage()
CalculateAttedance()
};
Abstraction in C refers to the concept of hiding implementation details and exposing only the necessary functionality to the user.
While C does not directly support abstraction in the way object-oriented programming languages like C++ or Java do,
it can achieve abstraction through the use of functions, pointers, and structures.
#include <stdio.h>
// Abstracted function
int add(int a, int b) {
return a + b; // Implementation detail hidden
}
int main() {
int result = add(5, 3); // Focus on the “what” rather than “how”
printf(“Result: %d\n”, result);
return 0;
}
The word “polymorphism” means having many forms.
A Person who exhibits different behavior like employee, husband,father
One function is used in different purposes.
There are two types of polymorphism:
Compile time polymorphism
Compile time polymorphism is a polymorphism that can be achieved by using
Changing the number of arguments:
Changing the number of arguments:
Void add(int a,int b)
Void add(int a,int b,int c)
Changing the type of arguments:
Void add(int a,int b)
Void add(Float a,float b)
Runtime polymorphism occurs when the method to be executed is determined at runtime. This is achieved in C++ using inheritance and virtual functions.
#include <iostream>
using namespace std;
// Base class
class Animal {
public:
virtual void makeSound() { // Virtual function
cout << “Animal makes a sound” << endl;
}
};
// Derived class: Dog
class Dog : public Animal {
public:
void makeSound() override { // Override the base class method
cout << “Dog barks” << endl;
}
};
// Derived class: Cat
class Cat : public Animal {
public:
void makeSound() override { // Override the base class method
cout << “Cat meows” << endl;
}
};
int main() {
Animal* animalPtr; // Pointer to base class
Dog dog;
Cat cat;
animalPtr = &dog;
animalPtr->makeSound(); // Calls Dog’s makeSound at runtime
animalPtr = &cat;
animalPtr->makeSound(); // Calls Cat’s makeSound at runtime
return 0;
}
Inheritence is used to acquire the properties and behavior of one class into another class
Code Reusability
Polymorphism
class BaseClass {
// Members of BaseClass
};
class DerivedClass : access_specifier BaseClass {
// Members of DerivedClass
};
:
class Animal {
public:
void eat() { cout << “This animal eats food.” << endl; }
};
class Dog : public Animal {
public:
void bark() { cout << “Dog barks.” << endl; }
};
class Father {
public:
void traits() { cout << “Traits from Father.” << endl; }
};
class Mother {
public:
void care() { cout << “Care from Mother.” << endl; }
};
class Child : public Father, public Mother {};