Learn Java OOP Fundamentals: Encapsulation, Inheritance, Polymorphism, and Abstraction

Java Basics Refresher: Object-Oriented Programming Concepts

Welcome to Week 1 of our Java Basics Refresher series! In this article, we’ll explore Object-Oriented Programming (OOP)—the backbone of Java programming. Understanding OOP is essential for writing organized, efficient, and reusable code.

What is Object-Oriented Programming?

OOP is a programming paradigm that uses objects to model real-world entities. Java’s OOP approach allows you to break down complex problems into simpler, manageable parts. OOP in Java is built on four main principles:

• Encapsulation
• Inheritance
• Polymorphism
• Abstraction

1. Encapsulation

Encapsulation is the practice of keeping fields (attributes) private and providing public methods to access or modify them. This helps protect data from outside interference and misuse.

Example of Encapsulation:

public class Car {
    private String color;

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }
}

In this example, the color field is private, meaning it can only be accessed through the public getColor and setColor methods. This encapsulation provides control over how the color attribute is accessed and modified.

2. Inheritance

Inheritance allows one class to inherit attributes and methods from another class, promoting code reuse. The parent class (superclass) shares its properties with the child class (subclass).

Example of Inheritance:

public class Animal {
    public void eat() {
        System.out.println("This animal is eating.");
    }
}

public class Dog extends Animal {
    public void bark() {
        System.out.println("The dog is barking.");
    }
}

Here, Dog is a subclass of Animal and inherits the eat method. It can also have its own methods, like bark.

3. Polymorphism

Polymorphism means “many forms.” In Java, it allows objects to be treated as instances of their parent class. Polymorphism is commonly used with method overriding.

Example of Polymorphism:

public class Animal {
    public void sound() {
        System.out.println("Some animal sound");
    }
}

public class Cat extends Animal {
    @Override
    public void sound() {
        System.out.println("Meow");
    }
}

public class Dog extends Animal {
    @Override
    public void sound() {
        System.out.println("Bark");
    }
}

In this example, both Cat and Dog classes override the sound method. This allows each subclass to provide its own version of the method, demonstrating polymorphism.

4. Abstraction

Abstraction involves hiding complex implementation details and showing only essential features. In Java, you can achieve abstraction using abstract classes or interfaces.

Example of Abstraction with Interface:

public interface Animal {
    void sound();
}

public class Bird implements Animal {
    public void sound() {
        System.out.println("Chirp");
    }
}

Here, the Animal interface declares the sound method, and the Bird class implements it, providing a specific sound.

Wrapping Up

Understanding these four OOP principles—Encapsulation, Inheritance, Polymorphism, and Abstraction—is key to mastering Java and creating well-structured, reusable code. With these concepts, you’ll be equipped to tackle more complex programming challenges in future articles.

Stay tuned for next article, where we’ll dive deeper into Java variables and data types!