Object-Oriented Programming (OOP) Concepts in Java

Object-Oriented Programming (OOP) is a programming paradigm that revolves around objects and data rather than actions and logic. Java, being an object-oriented language, fully supports these concepts. In this blog post, we'll explore the key OOP concepts in Java and how they enhance code reusability, maintainability, and flexibility.

1. Classes and Objects

Class Definition

A class in Java is a blueprint or template that defines the data and behavior (methods) that objects of the class will have.

public class Car {
    // Instance variables (data members)
    String model;
    int year;

    // Constructor
    public Car(String model, int year) {
        this.model = model;
        this.year = year;
    }

    // Method
    public void displayDetails() {
        System.out.println("Model: " + model + ", Year: " + year);
    }
}

Object Creation

An object is an instance of a class. You create objects in Java using the new keyword followed by a call to a constructor.

public class Main {
    public static void main(String[] args) {
        // Creating objects of class Car
        Car car1 = new Car("Toyota", 2022);
        Car car2 = new Car("Honda", 2023);

        // Calling methods on objects
        car1.displayDetails();
        car2.displayDetails();
    }
}

2. Encapsulation

Encapsulation is the bundling of data (variables) and methods (functions) that operate on the data into a single unit (class). It helps in hiding the implementation details and protecting the data from unauthorized access.

public class Car {
    private String model; // Private access modifier

    public String getModel() { // Getter method
        return model;
    }

    public void setModel(String model) { // Setter method
        this.model = model;
    }
}

3. Inheritance

Inheritance is a mechanism in Java where one class (subclass/child class) inherits the properties and behaviors (methods) of another class (superclass/parent class). It promotes code reusability and allows you to create a hierarchical class structure.

public class ElectricCar extends Car { // ElectricCar inherits from Car
    private int batteryCapacity;

    public ElectricCar(String model, int year, int batteryCapacity) {
        super(model, year); // Calling superclass constructor
        this.batteryCapacity = batteryCapacity;
    }

    // Additional methods specific to ElectricCar
    public void displayElectricCarDetails() {
        System.out.println("Model: " + getModel() + ", Year: " + year + ", Battery Capacity: " + batteryCapacity);
    }
}

4. Polymorphism

Polymorphism means the ability to take on many forms. In Java, polymorphism allows objects of different classes to be treated as objects of a common superclass through method overriding and method overloading.

Method Overriding

public class Animal {
    public void sound() {
        System.out.println("Animal makes a sound");
    }
}

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

Method Overloading

public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }

    public double add(double a, double b) {
        return a + b;
    }
}

5. Abstraction

Abstraction is the process of hiding the implementation details and showing only the essential features of the object. In Java, abstraction is achieved using abstract classes and interfaces.

Abstract Class

public abstract class Shape {
    // Abstract method (does not have a body)
    public abstract void draw();
}

public class Circle extends Shape {
    @Override
    public void draw() {
        System.out.println("Drawing Circle");
    }
}

Interface

public interface Drawable {
    void draw(); // Abstract method
}

public class Rectangle implements Drawable {
    @Override
    public void draw() {
        System.out.println("Drawing Rectangle");
    }
}

Conclusion

Object-Oriented Programming concepts like classes, objects, inheritance, encapsulation, polymorphism, and abstraction form the foundation of Java programming. They help in building modular, scalable, and maintainable code. By understanding and applying these concepts effectively, you can write more efficient and flexible Java applications.