Object-Oriented Programming, commonly called OOP, is a programming approach that organizes software around objects rather than treating a program as a collection of unrelated variables and functions.
The central idea is simple: instead of asking only “What should the program do?”, OOP also asks “Which object should be responsible for doing it?”
Java is designed heavily around this approach. When you work with a customer, bank account, employee, product, order, or vehicle, you can model each concept as an object containing its own data and behavior.
Why Does OOP Exist?
Imagine building a banking application. You might initially create variables for an account number, customer name, and balance, followed by methods that modify those values.
String accountNumber;
String holderName;
double balance;
void deposit(double amount) {
balance += amount;
}
void withdraw(double amount) {
balance -= amount;
}
This approach becomes difficult to manage when the application contains thousands of accounts. Which balance belongs to which customer? Which code is allowed to modify it? How do you prevent unrelated parts of the application from changing account information incorrectly?
OOP provides a structured solution: combine related data and the operations that work on that data into a meaningful unit called an object.
A Real-World Analogy
Think about a real-world Car. A car has characteristics such as its brand, colour, speed, and fuel level. It also performs actions such as starting, accelerating, braking, and stopping.
In an object-oriented program, characteristics become data, while actions become methods.
| Real-World Concept | OOP Concept | Example |
|---|---|---|
| Car | Object | myCar |
| Colour, speed | Data | red, 80 km/h |
| Start, accelerate | Methods | start(), accelerate() |
| Car design | Class | Car |
This analogy captures an important distinction: a class describes what an object should contain and do, while an object represents an actual instance created from that description.
The Core Idea of OOP
OOP combines state and behavior into objects.
- State represents the information an object currently holds.
- Behavior represents the actions an object can perform.
- Identity allows one object to be distinguished from another object.
For example, two BankAccount objects may have the same type but completely different account numbers and balances. They are separate objects with separate state.
A Simple Java Example
class Student {
String name;
int marks;
void displayResult() {
System.out.println(name + " scored " + marks);
}
}
public class Main {
public static void main(String[] args) {
Student student = new Student();
student.name = "Aarav";
student.marks = 85;
student.displayResult();
}
}
Here, Student is a class. It describes the data and behavior that a student object can have.
The statement new Student() creates an object. That object is accessed through the student reference variable.
The fields name and marks represent the object's state, while displayResult() represents its behavior.
Remember: A class is a blueprint or definition, while an object is a runtime instance created from that class. The class describes what an object can contain and do; the object carries actual values.
The Four Major Principles of OOP
Java's object-oriented design is commonly explained through four major principles. These principles help developers create software that is easier to organize, extend, maintain, and reuse.
| Principle | Main Idea | Purpose |
|---|---|---|
| Encapsulation | Bundle data and behavior while controlling access | Protect object state |
| Inheritance | Create a new class from an existing class | Reuse and specialize behavior |
| Polymorphism | Allow one operation or interface to have different implementations | Make code flexible |
| Abstraction | Expose essential features while hiding implementation details | Reduce complexity |
These principles are not isolated features. In real applications, they often work together. A class may encapsulate its state, inherit common behavior, use polymorphism to support different implementations, and expose only the essential operations through abstraction.
How OOP Changes the Way You Think
One of the most important skills in OOP is not memorizing keywords such as class, extends, or interface. The real skill is learning how to divide a problem into meaningful responsibilities.
Suppose you are developing an online shopping system. Instead of creating one enormous program that handles everything, you can identify concepts such as Customer, Product, Cart, Order, and Payment.
Each object can own the information and behavior that logically belongs to it. The result is code that is easier to understand because the software structure begins to resemble the business problem being solved.
OOP and Maintainability
Professional applications rarely remain unchanged. New requirements appear, features evolve, bugs are fixed, and existing behavior must continue working.
A well-designed object-oriented system can isolate responsibilities. When a change affects one part of the application, fewer unrelated components may need to change.
This is one reason OOP remains important in enterprise Java development. Its value is not simply that it lets developers create classes. Its real value comes from creating clear boundaries of responsibility.
Common Beginner Mistakes
- Thinking that OOP simply means creating many classes.
- Using inheritance whenever code reuse is required, even when the relationship is not logically appropriate.
- Making every field public and ignoring encapsulation.
- Creating large classes that handle unrelated responsibilities.
- Focusing entirely on syntax while ignoring object responsibilities and relationships.
Important: More classes do not automatically mean better OOP. Good object-oriented design is about meaningful responsibilities, sensible relationships, controlled access, and code that can evolve without becoming unnecessarily fragile.
Best Practices
- Give each class a clear and meaningful responsibility.
- Protect an object's internal state when direct modification is not appropriate.
- Prefer composition when it represents a relationship more naturally than inheritance.
- Keep methods focused instead of creating methods that perform unrelated tasks.
- Design objects around the actual problem domain rather than forcing everything into an artificial class hierarchy.
Interview Insight
A common interview question is: “What is OOP?”
A strong answer is more than saying, “OOP is a programming paradigm based on objects.” Explain that OOP models software using objects that combine state and behavior, and that Java provides principles such as encapsulation, inheritance, polymorphism, and abstraction to help create modular and maintainable systems.
Another useful distinction is: a class defines a type, while an object represents an instance of that type at runtime.
Quick Learning Check
Before moving to the next chapter, make sure you can answer these questions without looking back:
- What problem does OOP try to solve?
- What is the difference between state and behavior?
- Why is a class called a blueprint?
- What is an object?
- What are the four major principles of OOP?
Final Takeaway
Object-Oriented Programming is fundamentally a way of organizing software around objects that own data and provide behavior. Java gives you powerful language features for applying this approach, but the real value of OOP comes from designing clear responsibilities and meaningful relationships between objects. Once this mental model becomes natural, classes, constructors, inheritance, polymorphism, and abstraction stop feeling like unrelated Java features and begin to fit together as parts of one larger design philosophy.