Abstraction

 Abstraction is a fundamental concept in object-oriented programming (OOP) that helps to reduce complexity by hiding unnecessary details and focusing on essential features. It is one of the four key principles of OOP, alongside encapsulation, inheritance, and polymorphism. In Java, abstraction is implemented through abstract classes and interfaces. In this article, we'll explore what abstraction is and how it works in Java.

What is Abstraction?

Abstraction is the process of identifying essential features of an object and ignoring irrelevant details. In Java, abstraction allows us to create classes that provide a high-level view of an object's behavior, without revealing how that behavior is implemented.

Abstraction is achieved through two mechanisms in Java:

01.Abstract Classes

An abstract class is a class that cannot be instantiated directly and is meant to be subclassed. An abstract class is declared using the abstract keyword, and it can contain both abstract and concrete methods.

An abstract method is a method that has no implementation and is meant to be overridden by subclasses. An abstract method is declared using the abstract keyword and has no body.

Here is an example of an abstract class in Java:

In this example, the Shape class is declared as abstract, and it contains two abstract methods: getArea() and getPerimeter(). Any class that extends the Shape class must implement these methods.

02.Interfaces

An interface is a collection of abstract methods that defines a contract between a class and the outside world. An interface is declared using the interface keyword, and it can contain only abstract methods.

Here is an example of an interface in Java:

In this example, the Drawable interface contains a single abstract method: draw(). Any class that implements the Drawable interface must provide an implementation for this method.

Abstraction in Action

Let's take a look at an example to see how abstraction works in Java:

In this example, we have an abstract Shape class that defines two abstract methods: getArea() and getPerimeter(). We also have a concrete Circle class that extends the Shape class and provides implementations for the two abstract methods.

In the Main class, we create a Circle object and assign it to a variable of type Shape. Since Circle is a subclass of Shape, it can be treated as a Shape object. We then call the getArea() and getPerimeter() methods on the Shape object, which are actually implemented by the Circle class.

Conclusion

Abstraction is a powerful concept in Java that helps to reduce complexity by hiding unnecessary details and focusing on essential features. It is implemented through abstract classes and interfaces, which allow us to create high-level views of objects without revealing how they are implemented. By using abstraction in your Java code, you can make it more flexible