Know, What is Abstraction In Java

Abstraction is a crucial concept in object-oriented programming that allows you to hide complex implementation details and only show the essential features of an object. In Java, abstraction is achieved through interfaces and abstract classes.

Abstract Class

An abstract class in Java is a class that cannot be instantiated on its own and may contain abstract methods (methods without a body) that must be implemented by its subclasses. Abstract classes can have both non-abstract and abstract methods.

Example of Abstract Class:

package com.java.how2injava.abstraction;

abstract class Shape {
	protected String color;

	public Shape(String color) {
		this.color = color;
	}

	public abstract double calculateArea();
}

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 AbstractSample {
	public static void main(String[] args) {
		Shape circle = new Circle("Red", 5.0);
		System.out.println("Circle Area: " + circle.calculateArea());
	}
}

In this example, the Shape class is an abstract class with an abstract method calculateArea(). The Circle class extends the Shape class and provides an implementation for the calculateArea() method. Objects of the Circle class can be created and used, but objects of the Shape class cannot be instantiated directly due to its abstract nature.

Interface

An interface in Java is a blueprint of a class that defines a set of methods that a class must implement. Interfaces allow for multiple inheritance and provide a way to achieve full abstraction.

Example of Interface:

interface Sound {
    void makeSound();
}

class Dog implements Sound {
    @Override
    public void makeSound() {
        System.out.println("Dog barks");
    }
}

public class Main {
    public static void main(String[] args) {
        Sound dog = new Dog();
        dog.makeSound();
    }
}

In this example, the Sound interface defines a makeSound() method that the implementing class (Dog class) must override. The Dog class implements the Sound interface and provides an implementation for the makeSound() method.

Advantages of Abstraction

• Simplified complexity: Abstraction allows you to simplify complex systems by breaking them down into smaller, more manageable pieces. Understand, maintain, and modify the code is easy due to this
• Reusability: Abstraction promotes code reusability by allowing you to create abstract classes and interfaces that can be implemented by multiple classes. This reduces the amount of redundant code in your program and makes it easier to maintain and update.
• Flexibility: Abstraction makes your code more flexible by allowing you to change the implementation details of a class without affecting the code that uses it. This makes it easier to adapt your code to changing requirements and environments.
• Encapsulation: Abstraction promotes encapsulation by hiding implementation details and exposing only the essential features of an object or system. This helps prevent accidental modification of the code and ensures data integrity.
• Polymorphism: Abstraction enables polymorphism by allowing you to create classes that implement the same abstract class or interface. This allows you to treat objects of different classes as if they were of the same type, making your code more flexible and adaptable.

Conclusion Abstraction :

Abstraction is a powerful concept in Java that allows you to create complex systems by breaking them down into smaller, more manageable pieces. By hiding implementation details and focusing on the essential features of an object or system, abstraction promotes simplicity, reusability, flexibility, encapsulation, and polymorphism. Abstraction in Java helps in achieving modularity, reusability, and flexibility in code by hiding unnecessary details and focusing on essential features. It allows for easier maintenance and understanding of complex systems by providing a clear separation between interface and implementation.

Sample programs on Abstraction available on git