Abstraction is a key Object-Oriented Programming concept that focuses on hiding complex implementation details and exposing only the essential features.
It allows developers to create simple interfaces while keeping the internal workings hidden, making code easier to maintain and extend.
Abstraction in Java is achieved mainly using abstract classes and interfaces.
This allows separation of what an object does from how it does it, promoting modularity and flexibility.
// Abstract class example
abstract class Animal {
// Abstract method (does not have a body)
abstract void sound();
// Regular method
void sleep() {
System.out.println("Sleeping...");
}
}
class Dog extends Animal {
void sound() {
System.out.println("Bark");
}
}
public class Main {
public static void main(String[] args) {
Dog dog = new Dog();
dog.sound(); // Output: Bark
dog.sleep(); // Output: Sleeping...
}
}
// Interface example
interface Vehicle {
void move();
}
class Car implements Vehicle {
public void move() {
System.out.println("Car is moving");
}
}
public class Main {
public static void main(String[] args) {
Car car = new Car();
car.move(); // Output: Car is moving
}
}
Abstraction is used to design APIs that hide complex logic and expose simple interfaces.
Helps in dividing programs into independent, interchangeable modules.
Hides sensitive implementation details to protect internal data and logic.
Abstraction is the process of hiding complex implementation details and showing only the essential features of an object.
Abstract classes can have implemented methods and instance variables; interfaces primarily declare abstract methods (though Java 8+ supports default and static methods).
No, you cannot instantiate abstract classes or interfaces directly; you must extend or implement them.