Abstraction in Java

Abstraction in Java refers to the process of hiding implementation details while showing only the necessary information to the user. It is one of the core concepts of object-oriented programming and plays a vital role in creating reusable, maintainable, and scalable code.

In Java, abstraction is achieved using two main mechanisms: abstract classes and interfaces. An abstract class is a class that cannot be instantiated, meaning you cannot create an object of that class. Instead, you can only create objects of its subclasses, which are required to provide implementations for all the abstract methods defined in the abstract class. Abstract classes can also have non-abstract methods and variables.

An interface, on the other hand, is a collection of abstract methods and constants. Unlike abstract classes, interfaces cannot have any implementation details, and they cannot be instantiated. Instead, classes that implement an interface must provide concrete implementations for all its abstract methods.

The main benefit of abstraction is that it allows you to separate the interface of a class or module from its implementation. This makes your code more modular, easier to maintain, and more resilient to changes. Additionally, abstraction also promotes code reusability, as classes and modules that adhere to a common interface can be easily interchanged without affecting the rest of the codebase.

Here is an example of abstraction in Java using abstract classes:

abstract class Animal {
   public abstract void makeSound();
}

class Dog extends Animal {
   public void makeSound() {
      System.out.println("Woof!");
   }
}

class Cat extends Animal {
   public void makeSound() {
      System.out.println("Meow!");
   }
}

public class Main {
   public static void main(String[] args) {
      Animal dog = new Dog();
      Animal cat = new Cat();

      dog.makeSound(); // Output: Woof!
      cat.makeSound(); // Output: Meow!
   }
}

Woof!
Meow!

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

class Rectangle implements Shape {
   private double length;
   private double width;
   
   public Rectangle(double length, double width) {
      this.length = length;
      this.width = width;
   }
   
   public double getArea() {
      return length * width;
   }
   
   public double getPerimeter() {
      return 2 * (length + width);
   }
}

class Circle implements Shape {
   private double radius;
   
   public Circle(double radius) {
      this.radius = radius;
   }
   
   public double getArea() {
      return Math.PI * radius * radius;
   }
   
   public double getPerimeter() {
      return 2 * Math.PI * radius;
   }
}

public class Main {
   public static void main(String[] args) {
      Shape rectangle = new Rectangle(4, 6);
      Shape circle = new Circle(3);

      System.out.println("Area of rectangle: " + rectangle.getArea());
      System.out.println("Perimeter of rectangle: " + rectangle.getPerimeter());
      
      System.out.println("Area of circle: " + circle.getArea());
      System.out.println("Perimeter of circle: " + circle.getPerimeter());
   }
}

Area of rectangle: 24.0
Perimeter of rectangle: 20.0
Area of circle: 28.274333882308138
Perimeter of circle: 18.84955592153876