Abstraction in Java is a fundamental concept of object-oriented programming (OOPs) that focuses on hiding the implementation details of a class while exposing a simplified interface to the users.
It allows us to represent complex real-world entities in a simplified manner, emphasizing what an object does rather than how it does it.
Code Reusability: Abstraction facilitates code reuse by defining reusable components and building blocks that can be applied in different contexts. It encourages the creation of libraries, frameworks, and design patterns that promote reuse and extensibility.
Encapsulation and Information Hiding: Abstraction is closely related to encapsulation, as it encapsulates an object's internal state, and behaviour, and hides implementation details. It promotes information hiding by exposing only the necessary interfaces and hiding the underlying complexities.
Modularity: Abstraction promotes modularity by breaking down complex systems into smaller, more manageable components. It encourages the separation of concerns, allowing developers to focus on individual modules independently of each other.
Here are some key points about abstraction in Java:
An abstract class is a class that cannot be instantiated on its own and is typically used as a base class for other classes.
It may contain abstract methods (methods without a body) as well as concrete methods (methods with a body).
Abstract classes can also have fields and constructors.
abstract class Mobile {
abstract void companyName(); // Abstract method
void isHasButton() {
System.out.println("Yes");
}
}
An abstract method is a method without a body, and it is declared using the abstract keyword.
// Abstract class representing a Animal
abstract class Animal {
// Abstract method to produce sound
abstract void sound();
}
// Concrete class representing a Cat
class Cat extends Animal {
// Implementing abstract method to make sound
@Override
void sound() {
System.out.println("Meow Meow!!");
}
}
// Concrete class representing a Dog
class Dog extends Animal {
// Implementing abstract method to make sound
@Override
void sound() {
System.out.println("Woof Woof!!");
}
}
public class AbstractionExample {
public static void main(String[] args) {
Dog dog = new Dog();
dog.sound();
Cat cat = new Cat();
cat.sound();
}
}abstract class Animal {
abstract void sound(); // Abstract method
}
Abstract methods must be implemented (overridden) by non-abstract subclasses.
Woof Woof!! Meow Meow!!
Abstraction and encapsulation often go hand in hand in Java programming.
Encapsulation involves hiding the internal state of an object and restricting direct access to it, while abstraction focuses on providing a simplified interface to the users, hiding the implementation details.
Together, they help in building robust and modular software systems.
Abstraction allows us to design complex systems by breaking them down into smaller, more manageable pieces, each responsible for a specific aspect of functionality.
It promotes code reusability, maintainability, and flexibility, making your codebase easier to understand and extend.