Object-Oriented Programming Concepts Tutorial from Scratch (2026)
As a senior software architect with over a decade of experience designing enterprise-grade systems, I have seen firsthand how mastering Object-Oriented Programming (OOP) concepts separates exceptional developers from average ones. OOP is not just a programming paradigm — it is a mental model that fundamentally changes how you decompose problems and build maintainable software.
This tutorial covers the four pillars of OOP — encapsulation, inheritance, polymorphism, and abstraction — with real-world code examples in Java. You will learn how each concept promotes code reuse, reduces complexity, and enables teams to work on large codebases without stepping on each other's toes.
Encapsulation — Protecting Internal State
Encapsulation is the mechanism of wrapping data (variables) and methods (functions) operating on that data into a single unit called a class. It also restricts direct access to some of an object's internal components, which prevents accidental interference and misuse. The core idea is to expose only what is necessary through a public interface while hiding implementation details.
In practical terms, encapsulation means marking fields as private and providing public getter and setter methods. This gives you control over how data is accessed and modified, enabling validation, logging, or lazy loading behind the scenes without affecting consumers of your class.
public class BankAccount {
private double balance;
public BankAccount(double initialBalance) {
if (initialBalance >= 0) {
this.balance = initialBalance;
}
}
public double getBalance() {
return balance;
}
public void deposit(double amount) {
if (amount > 0) {
balance += amount;
}
}
public void withdraw(double amount) {
if (amount > 0 && amount <= balance) {
balance -= amount;
}
}
}Inheritance — Reusing and Extending Behavior
Inheritance allows a class to acquire the properties and methods of another class, forming a parent-child hierarchy. The child class (subclass) can reuse, extend, or override the behavior defined in the parent class (superclass). This promotes DRY (Don't Repeat Yourself) principles and establishes a natural taxonomic relationship between classes.
Use inheritance when you have an "is-a" relationship — for example, a Dog is an Animal. However, prefer composition over inheritance in most modern designs, as deep inheritance hierarchies can become brittle and hard to maintain.
public class Animal {
protected String name;
public Animal(String name) {
this.name = name;
}
public void speak() {
System.out.println("Animal speaks");
}
}
public class Dog extends Animal {
public Dog(String name) {
super(name);
}
@Override
public void speak() {
System.out.println(name + " says Woof!");
}
}Polymorphism — One Interface, Many Implementations
Polymorphism means "many forms" and allows objects of different classes to be treated as objects of a common superclass. The most common use is when a parent class reference is used to refer to a child class object, and the correct method implementation is resolved at runtime. This enables you to write code that works on the superclass type and automatically adapts to the actual subtype.
There are two types: compile-time polymorphism (method overloading) and runtime polymorphism (method overriding). Runtime polymorphism is what most developers refer to when they talk about polymorphism, and it is the foundation of many design patterns like Strategy and Template Method.
public interface PaymentProcessor {
void processPayment(double amount);
}
public class CreditCardProcessor implements PaymentProcessor {
@Override
public void processPayment(double amount) {
System.out.println("Processing credit card payment: $" + amount);
}
}
public class PayPalProcessor implements PaymentProcessor {
@Override
public void processPayment(double amount) {
System.out.println("Processing PayPal payment: $" + amount);
}
}
// Usage
PaymentProcessor processor = new CreditCardProcessor();
processor.processPayment(99.99);Abstraction — Hiding Complexity
Abstraction is the process of hiding implementation details and showing only the essential features of an object. In Java, this is achieved through abstract classes and interfaces. Abstraction reduces complexity by allowing the programmer to focus on what an object does instead of how it does it.
The key difference between abstraction and encapsulation is subtle but important: encapsulation hides the internal state, while abstraction hides the implementation details. Abstraction is about designing clean contracts (interfaces) that separate specification from implementation.
abstract class Shape {
abstract double calculateArea();
public void display() {
System.out.println("Area: " + calculateArea());
}
}
class Circle extends Shape {
private double radius;
public Circle(double radius) {
this.radius = radius;
}
@Override
double calculateArea() {
return Math.PI * radius * radius;
}
}
class Rectangle extends Shape {
private double length, width;
public Rectangle(double length, double width) {
this.length = length;
this.width = width;
}
@Override
double calculateArea() {
return length * width;
}
}Frequently Asked Questions
What are the 4 main concepts of OOP?
The four main concepts of Object-Oriented Programming are Encapsulation, Inheritance, Polymorphism, and Abstraction. These are often referred to as the four pillars of OOP.
What is the difference between abstraction and encapsulation?
Encapsulation hides the internal state of an object by keeping fields private and exposing them through public methods. Abstraction hides implementation details and shows only the essential features, typically using abstract classes or interfaces.
Why is inheritance considered harmful in some cases?
Deep inheritance hierarchies can lead to fragile code where changes in a parent class ripple through all subclasses. Many designers now prefer composition over inheritance, using techniques like dependency injection and strategy pattern instead.
Can you achieve polymorphism without inheritance?
Yes, through interfaces and duck typing. In languages like Go or TypeScript, structural typing allows polymorphism without explicit class hierarchies. Java also supports polymorphism entirely through interfaces.
Originally published on Ayodhyyya. Last updated June 1, 2026.