Object-Oriented Programming (OOP) Explained

When I first started learning programming, I often wrote code that worked but looked messy. As projects grew bigger, my code became harder to manage, reuse, or extend. That’s when I discovered Object-Oriented Programming (OOP), and it changed the way I thought about coding forever.

In this blog, I’m going to explain OOP concepts in simple terms, with examples, and also show how we apply them in real-world software systems. Whether you're a beginner or brushing up for interviews, this guide will help you understand and apply OOP like a pro.

What Is Object-Oriented Programming (OOP)?

Object-Oriented Programming is a programming paradigm (style or approach to programming) that organizes code around objects rather than functions and logic. These objects represent real-world entities and contain data (attributes) and behaviors (methods).

In OOP, the main building blocks are:

Let’s go through them one by one.

1. Class and Object

Class

A class is a blueprint or template. It defines how something should look and behave.

Example: Think of a class as a "Car design". It tells us a car should have wheels, an engine, and methods like start() and stop().

Object

An object is an instance of a class, it’s the actual "thing" built from the blueprint.

Code

class Car {

String brand = "Toyota";

int speed = 120;

void start() {

System.out.println("Car is starting...");

}

public class Main {

public static void main(String[] args) {

Car myCar = new Car(); // Object creation

System.out.println(myCar.brand);

myCar.start();

}

Real-Life Analogy:

Class: Mobile phone model (e.g., iPhone 15)
Object: Your actual iPhone 15 in your hand

2. Inheritance

Inheritance allows one class to inherit properties and methods from another class. It helps reuse code and establish a hierarchical relationship.

Code

// Base class

class Vehicle {

void move() {

System.out.println("This vehicle is moving");

}

// Derived class

class Bike extends Vehicle {

void wheelie() {

System.out.println("Bike is doing a wheelie");

}

// Test class

public class Main {

public static void main(String[] args) {

Bike myBike = new Bike();

myBike.move(); // Inherited method

myBike.wheelie(); // Bike-specific method

}

Now, Bike automatically gets the move() method from Vehicle.

Real-Life Example:

A Dog is an Animal. All dogs have properties of animals, but dogs also have special behavior like barking.

Where to apply?
Use inheritance when different classes share common logic but also have their own unique features. For example:

User and Admin both inherit from a Person class
ElectricCar inherits from Car

3. Polymorphism

Polymorphism means "many forms". The same function name can behave differently depending on the object calling it.

Java supports two types of polymorphism:

Compile-Time Polymorphism (Static)

What is it?

Compile-time polymorphism is achieved through method overloading, where multiple methods have the same name but differ in the number or type of parameters.

Example in Java: Method Overloading

class MathOperations {

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;

}

public class Main {

public static void main(String[] args) {

MathOperations op = new MathOperations();

System.out.println(op.add(2, 3)); // 5

System.out.println(op.add(2.5, 3.5)); // 6.0

System.out.println(op.add(1, 2, 3)); // 6

}

Real-Life Example:

Think of a calculator app. The add() function can work with two or three numbers, or with integers or decimals. The method is named the same, but behaves differently depending on parameters.

Where to apply?

Use method overloading when:

You want to handle different types of input using the same method name.
You need different behaviors for different parameter lists (number or type).

Runtime Polymorphism (Dynamic)

What is it?

Runtime polymorphism is achieved through method overriding, where a subclass provides a specific implementation of a method that is already defined in its superclass.

Example in Java: Method Overriding

// Base class

class Animal {

// Method that will be overridden by child classes

void sound() {

System.out.println("Animal makes a sound");

}

// Derived class 1: Dog extends Animal

class Dog extends Animal {

@Override // This annotation tells the compiler we are overriding the method

void sound() {

System.out.println("Bark"); // Dog-specific implementation

}

// Derived class 2: Cat extends Animal

class Cat extends Animal {

@Override

void sound() {

System.out.println("Meow"); // Cat-specific implementation

}

// Main class to test polymorphism

public class Main {

public static void main(String[] args) {

// Creating an Animal reference pointing to a Dog object

Animal a1 = new Dog();

// Creating an Animal reference pointing to a Cat object

Animal a2 = new Cat();

// Although the reference is of type Animal,

// the actual object is Dog, so Dog's sound() is called

a1.sound(); // Output: Bark

// Similarly, this calls Cat's overridden sound() method

a2.sound(); // Output: Meow

}

What's Happening:
Animal a1 = new Dog();
This is upcasting, where a Dog object is referenced by a parent class (Animal) type.
When a1.sound() is called, Java uses dynamic method dispatch to determine at runtime which version of sound() to call based on the actual object, not the reference type.
Since a1 is actually a Dog, Dog's sound() method is executed.
Same goes for a2, which is a Cat.
This is called: Runtime Polymorphism or Dynamic Method Dispatch
 It's useful when you want to write general code that works on a superclass type, but behaves differently depending on the subclass object passed.

Real-Life Example:

A remote control has a power() button. When used on a TV, it turns on the TV. On an AC, it powers the AC. The interface is same, but behavior differs based on the object.

Where to apply?

Use method overriding when:

Subclasses must implement specific behavior of a general method from the superclass.
It allows dynamic decision making at runtime.
Examples: pay() method for different payment gateways (Paytm, UPI, Card).

4. Encapsulation

Encapsulation means binding data and methods together and keeping internal details hidden from the outside.

Code

class Student {

private String name; // private = hidden from outside

// public method to set the name

public void setName(String newName) {

name = newName;

}

// public method to get the name

public String getName() {

return name;

}

public class Main {

public static void main(String[] args) {

Student s = new Student();

s.setName("Manoha"); // setting the name safely

System.out.println(s.getName()); // getting the name safely

}

Explanation:
In the Student class, we made the name variable private, so no one can access or change it directly from outside the class.
To safely allow access, we created:
setName(): to change the name
getName(): to read the name
These are called getter and setter methods.

Real-Life Example:

You drive a car but don’t need to know how the engine works internally.

Where to apply?
Use encapsulation to protect sensitive data, like:

Hiding a user’s password or bank balance
Preventing unauthorized access to system configurations

5. Abstraction

Abstraction means showing only the necessary details and hiding the complexity.

You care about what something does, not how it does it.

You interact with the interface, not the internal mechanics.

Code

// Abstract class

abstract class Vehicle {

// Abstract method (no body)

abstract void startEngine(); // Only saying "what" must be done

}

// Subclass that extends the abstract class

class Car extends Vehicle {

// Implementing the abstract method

void startEngine() {

System.out.println("Starting car engine...");

}

public class Main {

public static void main(String[] args) {

Car c = new Car();

c.startEngine(); // Output: Starting car engine...

}

Explanation
Vehicle is an abstract class. That means:
You cannot create an object of  Vehicle directly.
It can have abstract methods (methods without a body).
This Vehicle class is saying:

"Every vehicle must be able to start its engine, but I'm not telling you how, the details are hidden".
startEngine() is an abstract method, which means every subclass (like Car) must implement it.
Car is a concrete class that provides the actual body for startEngine().
          Here, theCar Class says how to start the engine. 
In main(), we created a Car object and called startEngine().

Real-Life Example:

You press "call" on your phone. You don’t care how the signal is transmitted, just that the call goes through.

Where to apply?
Use abstraction when you want to hide the complex details and show only what the user needs.

Examples:

Login Form
- User sees: Email & Password fields
- Hidden: How it checks the database, handles encryption, etc.
Payment Interface
- User clicks: "Pay ₹500"
- Hidden: How the payment gateway works, how card data is verified, etc.
APIs
- You call: getWeather(city)
- Hidden: How it connects to a server, reads data, formats the result, etc.

When and Where to Use OOP Concepts in Real Life

Class & Object

Imagine you're designing a car factory.
You first make a blueprint (that's the class), it defines how the car should look and work (wheels, engine, color).
Now, you build many actual cars from that blueprint, those are objects.

In software:
A User, Employee, or Product class is the blueprint, and each actual user or product in the system is an object.

Inheritance

Say you have a general class called Vehicle.
Cars, Bikes, and Buses are all vehicles, they inherit common properties like speed, fuel type, but each can have its own unique features too.

In software:
You might have a User class, and then create an Admin or Customer class that inherits from User. They get all the basic stuff from User but also have their own extra features.

Polymorphism

Let’s say you ask different musicians to "play"
A guitarist will strum, a pianist will press keys, a drummer will beat drums.
Same instruction, different behavior.

In software:
You can have a method called draw() in a graphics app, it behaves differently for a circle, a square, or a triangle.
Same method name, but each object responds in its own way.

Encapsulation

Think of a bank ATM. You insert your card and enter your PIN, and it shows you the balance.
But you don’t know how the bank handles that info internally, it's hidden to keep it safe.

In software:
A class like BankAccount might hide its data (like balance or PIN) using private variables, and you interact with it through public methods like deposit() or getBalance().

Abstraction

When you use a TV remote, you press "Power On" or "Volume Up", you don’t care about the circuits inside.
It hides all the complexity and gives you just what you need.

In software:
Abstraction is used in APIs, login forms, or payment gateways, users see a simple interface, while complex things happen behind the scenes.

Benefits of OOP in Software Development

Code Reusability
Clean & Organized Codebase
Easy to Maintain & Update
Secure and Controlled Access to Data
Supports Design Patterns and Scalability

Simple Project Ideas to Practice OOP

Library Management System
- Classes: Book, Member, Library etc
Online Shopping Cart
- Classes: Product, Cart, User, Order etc
ATM Simulation
- Classes: Account, ATM, Transaction etc

Conclusion: Why OOP Is a Must-Know for Every Developer

Object-Oriented Programming isn't just theory, it's a mindset. It helps you think like a designer, not just a coder. Once you start building with objects, you’ll write cleaner, scalable, and future-proof code.

So next time you build a project, try to model the real world into classes and objects. Think in terms of behaviors and properties. That’s how software becomes smart, maintainable, and robust.

KnowDigy

Search This Blog