Abstraction In Java

Abstraction is a key principle of object-oriented programming (OOP) that allows you to create abstract representations of real-world objects and concepts. It involves hiding the implementation details of a class and exposing only the essential features and behavior through a well-defined interface. In Java, abstraction is primarily achieved through abstract classes and interfaces.

1. Abstract Classes:

An abstract class in Java is a class that cannot be instantiated and serves as a blueprint for other classes. It may contain both abstract and non-abstract methods, as well as member variables. An abstract method is a method without an implementation, declared using the `abstract` keyword. Subclasses that extend an abstract class must provide implementations for all the abstract methods defined in the superclass, or they must also be declared as abstract.

Here's an example: abstract class Shape { protected String color; public Shape(String color) { this.color = color; } public abstract double calculateArea(); public void display() { System.out.println("This is a " + color + " shape."); } } class Circle extends Shape { private double radius; public Circle(String color, double radius) { super(color); this.radius = radius; } @Override public double calculateArea() { return Math.PI * radius * radius; } } public class Main { public static void main(String[] args) { Circle circle = new Circle("red", 5.0); circle.display(); // Output: This is a red shape. System.out.println("Area: " + circle.calculateArea()); // Output: Area: 78.53981633974483 } }

In the above example, the `Shape` class is an abstract class that defines the common behavior for all shapes. It has an abstract method `calculateArea()` that is implemented in the `Circle` class. The `Shape` class also has a non-abstract method `display()` that provides a default implementation. The `Circle` class extends the `Shape` class and provides its implementation for the abstract method.

2. Interfaces:

An interface in Java is a collection of abstract methods that define a contract for classes that implement the interface. It defines what methods a class must implement, but it does not provide any implementation details. Any class can implement one or multiple interfaces, providing implementations for all the methods declared in the interface.

Here's an example: interface Vehicle { void start(); void stop(); } class Car implements Vehicle { @Override public void start() { System.out.println("Car started"); } @Override public void stop() { System.out.println("Car stopped"); } } public class Main { public static void main(String[] args) { Vehicle vehicle = new Car(); vehicle.start(); // Output: Car started vehicle.stop(); // Output: Car stopped } }

In the above example, the `Vehicle` interface defines the `start()` and `stop()` methods. The `Car` class implements the `Vehicle` interface and provides the implementations for both methods.

Abstraction allows you to create high-level, modular, and reusable code by focusing on the essential characteristics and behavior of objects, without worrying about the internal details. It promotes code maintenance, flexibility, and loose coupling between classes.