OOPS stands for Object-Oriented Programming System. It’s a way of organizing and designing software by modeling real-world entities as “objects” that have properties and behaviors.
Instead of writing long, procedural code, OOPS helps programmers break down complex problems into manageable pieces — just like how we think about real things around us. Each object represents something meaningful, whether it’s a car, a user, or a product, with its own data and actions.
This approach makes code easier to understand, reuse, and maintain — which is why OOPS is the foundation of many modern programming languages like Java, C++, and Python. (Resources at the end)
In OOPS, there are five key properties that help structure your code clearly and efficiently:
- Class and Object
- Inheritance
- Polymorphism
- Encapsulation
- Abstraction
Class and Object
Think of a class as a blueprint or a template — like the general idea of a car. It defines common features that all cars share, such as:
- Number of seats
- Engine type (petrol, diesel, electric)
- Color options
But a class itself isn’t a car. It’s just the plan.
An object is the actual car built from that blueprint. Different companies use the same blueprint to create their own cars, but with different specific values.
For example:
- An Audi object might have 4 seats, a diesel engine, automatic transmission, and be black.
- A Maruti object might have 6 seats, a petrol engine, manual transmission, and be white.
Both Audi and Maruti are objects created from the same class (car), but with their own unique details.
Inheritance
Inheritance is like when a car company releases a new model based on an older version. The new model inherits all the features of the previous one but also adds some upgrades.
For example, say Audi releases a newer version of its car. This new Audi model will inherit the properties from the older version — like the number of seats and engine type — but it might also add new features, such as improved safety systems or a better infotainment display.
In programming, inheritance allows a new class to reuse properties and behaviors from an existing class, saving time and effort while keeping things organized.
Polymorphism
The word polymorphism comes from Greek, meaning “many shapes” or “many behaviors.” In programming, it refers to the ability of a single function or method to behave differently based on the context.
There are two main types of polymorphism:
Runtime polymorphism (also called method overriding)
Compile-time polymorphism (also called method overloading)
Compile-Time Polymorphism (Method Overloading):
This happens when you have multiple versions of the same function but with different parameters. For example, a start() function could work differently based on how you start the car:
- start() with no parameters: Just press the start button.
- start(key: String): Start the car using a physical key.
- start(voiceCommand: String): Start the car using a voice command like “Start engine.”
All these methods share the same name but differ by the type or number of inputs — this is compile-time polymorphism.
Runtime Polymorphism (Method Overriding):
Here, different car brands have the same function name but their actual behavior differs at runtime:
- The start() function for an Audi might start smoothly and silently.
- The start() function for a Maruti might start with a loud roar.
Both cars use the same start() method, but each executes it differently depending on the object — this is runtime polymorphism.
3 Free Apps Students Must Have to Stay Focused
Encapsulation and Abstraction
Sometimes, these two get mixed up, but they mean different things — let me break it down.
Encapsulation
Think of it like how everything inside your car is interlinked and hidden safely. The engine, wiring, fuel system — all packed inside so you don’t have to worry about how they work internally. The manufacturer keeps all this protected and controlled.
Encapsulation is all about wrapping up the implementation details of data and methods inside a single unit (class), keeping everything protected and hidden from outside interference.
Abstraction
Abstraction is about showing only the useful parts and hiding the complex details. When you use your car, you just use the key or push a button to start it — you don’t care about all the wires, sensors, and engine parts working behind the scenes.
So, abstraction is like the user interface — it presents only what’s necessary and hides the complicated stuff, making it easier to use.
Encapsulation is like the manufacturer’s view — it focuses on safely wrapping up and protecting all the internal details and implementation inside the car. On the other hand, abstraction is the user’s view — it shows only the essential features you need to use, hiding all the complex workings under the hood.
Resources
Best OOPS Playlist — Object Oriented Programming by Kunal Kushawaha
