Abstraction In Java - PlanetLearning

Abstraction in Object-Oriented Programming (OOP) in Java

What is Abstraction?

Abstraction is one of the four fundamental principles of object-oriented programming (OOP), along with encapsulation, inheritance, and polymorphism. Abstraction is the concept of hiding the complex implementation details and showing only the essential features of an object. It allows a programmer to focus on what an object does rather than how it does it.

Key Aspects of Abstraction

Simplification: Abstraction simplifies complex systems by breaking them down into more manageable pieces and providing a simplified interface to interact with these pieces.
Hiding Implementation: It hides the internal workings of an object and exposes only what is necessary for the usage of the object.
Focus on Interface: Abstraction emphasizes designing objects in terms of their interfaces rather than their implementations.

Benefits of Abstraction

Reduced Complexity: By hiding the complex implementation details, abstraction reduces the complexity of understanding and working with an object.
Enhanced Maintainability: Changes to the implementation of an object do not affect the code that uses the object, as long as the interface remains unchanged.
Increased Reusability: Abstraction allows for creating reusable components by defining clear interfaces that can be implemented in various ways.
Improved Flexibility: It provides the flexibility to change the internal implementation of an object without affecting its external behavior.

How to Achieve Abstraction in Java

In Java, abstraction can be achieved through abstract classes and interfaces.

Abstract Classes: An abstract class is a class that cannot be instantiated and may contain abstract methods (methods without a body). Abstract classes can provide a common base for subclasses to extend and implement the abstract methods.
Interfaces: An interface is a reference type in Java, similar to a class, that can contain only abstract methods (until Java 8, which introduced default and static methods). Classes that implement an interface must provide implementations for all the abstract methods in the interface.

Benefits of Using Abstract Classes and Interfaces

Abstract Classes:
- Code Reusability: Allows for defining common methods that can be reused by subclasses.
- Partial Implementation: Subclasses can choose to implement only the abstract methods and inherit concrete methods from the abstract class.
Interfaces:
- Multiple Inheritance: A class can implement multiple interfaces, allowing for a form of multiple inheritance.
- Loose Coupling: Provides a way to use polymorphism to create loosely coupled code that can interact with different implementations of the same interface.

Example of Abstraction using Abstract Classes

Code Example

​x
 
abstract class Shape {    // Abstract method    abstract void draw();        // Concrete method    public void display() {        System.out.println("Displaying shape.");    }}​class Circle extends Shape {    @Override    void draw() {        System.out.println("Drawing a circle.");    }}​class Rectangle extends Shape {    @Override    void draw() {        System.out.println("Drawing a rectangle.");    }}​public class TestAbstraction {    public static void main(String[] args) {        Shape circle = new Circle();        Shape rectangle = new Rectangle();​        circle.draw(); // Calls the draw method in Circle        rectangle.draw(); // Calls the draw method in Rectangle                circle.display(); // Calls the concrete method in Shape    }}

Output

Drawing a circle.
Drawing a rectangle.
Displaying shape.

Explanation: An abstract class, such as Shape, can contain both abstract methods (methods without a body) and concrete methods (methods with a body). Subclasses like Circle and Rectangle must implement the abstract methods. This allows for a common interface (draw method) while enabling specific implementations in each subclass.

Example of Abstraction using Interfaces

xxxxxxxxxx
 
interface Drawable {    void draw(); // Abstract method}​class Circle implements Drawable {    @Override    public void draw() {        System.out.println("Drawing a circle.");    }}​class Rectangle implements Drawable {    @Override    public void draw() {        System.out.println("Drawing a rectangle.");    }}​public class TestInterfaceAbstraction {    public static void main(String[] args) {        Drawable circle = new Circle();        Drawable rectangle = new Rectangle();​        circle.draw(); // Calls the draw method in Circle        rectangle.draw(); // Calls the draw method in Rectangle    }}