Need of Abstraction in Java

What is abstraction?

Abstraction is a programming concept used in Java that enables you to build sophisticated systems by keeping implementation details hidden from the user and just exposing the functionality that is required. By developing abstract classes or interfaces that specify the overall behaviour of a group of related classes, it is a method for controlling complexity.

A class that cannot be created and has one or more abstract methods, methods without implementation is referred to as an abstract class. Subclasses of abstract classes are used to implement the abstract methods, and abstract classes are designed to be subclassed. Subclasses might follow the abstract class as a guide to ensure that they have the same methods and properties.

An interface is a set of abstract methods and constants that establishes the terms under which a class must carry out its implementation. Similar to abstract classes, interfaces cannot be instantiated; instead, a class that implements the interface is required to implement the interface's functions. Without describing how those behaviours should be implemented, an interface defines a set of behaviours that a class must possess.

Because it encourages modularity, encapsulation, and information hiding, abstraction is a crucial notion in Java and other object-oriented programming languages. This makes programmes simpler to create, test, and maintain.

For example:

//program to show the sound of animal using abstraction in java
//Abstract class
abstract class Animal {
 // Abstract method
 public abstract void makeSound();
}
//Subclass of the abstract class
class Cow extends Animal {
 public void makeSound() {
 System.out.println("Mooo!");
 }
}
//Another subclass of the abstract class
class Horse extends Animal {
 public void makeSound() {
 System.out.println("Neigh!");
 }
}
class Pig extends Animal {
 public void makeSound() {
 System.out.println("oink oink!");
 }
}
class Dog extends Animal {
 public void makeSound() {
 System.out.println("Woof!");
 }
}
class Cat extends Animal {
 public void makeSound() {
 System.out.println("Meow!");
 }
}
//Main class to demonstrate the usage of the abstract class
public class Main {
 public static void main(String[] args) {
 Animal cow = new Cow();
 cow.makeSound(); // Output: Mooo!
 Animal horse = new Horse();
 horse.makeSound(); // Output: Neigh!
 Animal pig = new Pig();
 pig.makeSound(); //output: oink oink!
 Animal dog = new Dog();
 dog.makeSound(); // Output: Woof!
 Animal cat = new Cat();
 cat.makeSound(); // Output: Meow!
 }
}

Output:

Mooo!
Neigh!
Oink oink!
Woof!
Meow!

Need of abstraction in java

A key idea in Java (as well as other programming languages) is abstraction, which enables you to build sophisticated systems by hiding extraneous implementation details and exposing only the relevant features or behaviours. It offers a method for controlling complexity and creating modular, maintainable code.

Here are several main justifications for why Java needs abstraction:

• Simplifying complexity: By dividing complicated software systems into smaller, easier-to-manage pieces, abstraction aids in the management of complexity. It enables you to disregard minute implementation details and concentrate on broad concepts. The code is now simpler, which makes it simpler to comprehend, maintain, and troubleshoot.
• Implementation encapsulation: Using abstraction, you can hide the actual workings of an object or module and just expose the appropriate interfaces or functions. This facilitates information hiding and lessens dependencies among various codebase components. Encapsulation offers modularity and safeguards an object's internal state, making it simpler to change or replace the implementation without having an adverse impact on other system components.
• Code reuse: You may prevent code duplication and encourage code reuse by abstracting common behaviours or functionalities into reusable components. You can design abstract classes, interfaces, and inheritance hierarchies that can be extended or implemented by various classes thanks to abstraction. This encourages your codebase's modularity, extensibility, and flexibility.
• Flexibility and adaptability: You can design abstract classes or interfaces that operate as a contract for implementing classes thanks to abstraction. This contract outlines the anticipated conduct and establishes a standard API. Programming to interfaces rather than specific implementations allows you to quickly swap between them in accordance with your needs. With this adaptability, you can change and improve your code over time.
• Concentrate on key details: By removing the unnecessary or unimportant elements, abstraction enables you to recognise and concentrate on the key characteristics or actions of an object or system. This enhances the overall design and the conceptual understanding of the code. Additionally, it helps team members communicate better because they can talk about high-level concepts rather than being bogged down in low-level implementation details.