Explain Abstraction in Java

Abstraction is one of the key principles of object-oriented programming, which allows you to hide the complexity of an object's implementation and expose only the essential features to the users. In Java, you can achieve abstraction using abstract classes and interfaces.
Here are some examples of using abstraction in Java:

Abstract Class Example

public abstract class Animal {
    protected String name;

    public Animal(String name) {
        this.name = name;
    }

    public abstract void makeSound();

    public void eat() {
        System.out.println(name + " is eating.");
    }
}

In this example, we're creating an abstract class Animal. The class has a name field and a constructor that initializes the field. The class also has an abstract method makeSound() that is intended to be implemented by the subclasses, and a non-abstract method eat() that prints a message to the console.
By defining the Animal class as abstract, we're indicating that it should not be instantiated directly. Instead, we expect the subclasses to provide the implementation for the abstract method makeSound().

Interface Example

public interface Shape {
    double getArea();
    double getPerimeter();
}

In this example, we're creating an interface Shape. The interface defines two abstract methods getArea() and getPerimeter(), which represent the common behavior for all shapes. Any class that implements the Shape interface must provide the implementation for these methods.


Polymorphism Example

public class Main {
    public static void main(String[] args) {
        Animal dog = new Dog("Max");
        Animal cat = new Cat("Luna");
        dog.makeSound();
        cat.makeSound();
    }
}

class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }

    @Override
    public void makeSound() {
        System.out.println(name + " is barking.");
    }
}

class Cat extends Animal {
    public Cat(String name) {
        super(name);
    }

    @Override
    public void makeSound() {
        System.out.println(name + " is meowing.");
    }
}

In this example, we're creating two subclasses Dog and Cat that extend the Animal abstract class. Both subclasses implement the abstract method makeSound() with their own implementation.
In the Main class, we're creating two objects dog and cat of type Animal, but their actual type is Dog and Cat respectively. We're using polymorphism to call the makeSound() method on each object, which calls the implementation defined in the respective subclass.

By using abstraction, we're able to create a common interface for objects of different types, which makes the code more flexible and easier to maintain.