Explain OOP concepts in Java.

Object-Oriented Programming (OOP) is a programming paradigm that uses 'objects' – instances of classes – to design applications and computer programs. In Java, OOP is a fundamental concept that structures code into modular, reusable, and maintainable units. It is based on several core principles that guide software development.

What is OOP?

Object-Oriented Programming (OOP) is a methodology that organizes software design around data, or objects, rather than functions and logic. An object can be defined as a data field that has unique attributes and behavior. OOP focuses on modeling real-world entities and their interactions, leading to more intuitive and manageable code.

Four Main OOP Concepts

1. Encapsulation

Encapsulation is the bundling of data (attributes) and methods (behaviors) that operate on the data into a single unit, which is a class. It also involves restricting direct access to some of an object's components, meaning the internal state of an object is hidden from the outside world. This is typically achieved using access modifiers like 'private' for data fields and 'public' for getter and setter methods, providing controlled access.

class BankAccount {
    private double balance; // Encapsulated data

    public BankAccount(double initialBalance) {
        this.balance = initialBalance;
    }

    // Public method to access balance safely
    public double getBalance() {
        return balance;
    }

    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        }
    }
}

2. Inheritance

Inheritance is a mechanism in which one class (subclass or child class) acquires the properties and behaviors of another class (superclass or parent class). It promotes code reusability and establishes an 'is-a' relationship between classes. The 'extends' keyword is used in Java to implement inheritance, allowing subclasses to inherit fields and methods from their superclass.

class Vehicle {
    String brand = "Generic";
    public void honk() {
        System.out.println("Vehicle sound!");
    }
}

class Car extends Vehicle { // Car inherits from Vehicle
    String modelName = "Sedan";
}

3. Polymorphism

Polymorphism means 'many forms'. It is the ability of an object to take on many forms. In Java, polymorphism allows methods to do different things depending on the object it is acting upon. It is primarily achieved through method overloading (compile-time polymorphism, where methods have the same name but different parameters) and method overriding (runtime polymorphism, where a subclass provides a specific implementation for a method already defined in its superclass).

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

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

// Example of usage:
// Animal myDog = new Dog();
// myDog.makeSound(); // Outputs "Dog barks"

4. Abstraction

Abstraction is the concept of hiding the complex implementation details and showing only the essential features of an object. It focuses on 'what' an object does rather than 'how' it does it. In Java, abstraction is achieved using abstract classes and interfaces. Abstract classes can have both abstract (without implementation) and concrete methods, while interfaces (since Java 8, can also have default and static methods) define a contract for classes that implement them.

abstract class Shape {
    abstract double area(); // Abstract method
    public void display() {
        System.out.println("This is a shape.");
    }
}

class Circle extends Shape {
    double radius;
    public Circle(double radius) {
        this.radius = radius;
    }
    @Override
    double area() {
        return Math.PI * radius * radius;
    }
}

Mastering these OOP concepts in Java is crucial for developing robust, scalable, and maintainable software. They provide a structured approach to program design, making code easier to understand, debug, and extend in large-scale applications.