1. Introduction
Abstraction is the OOP principle of hiding complex implementation details and exposing only the essential features of an object. It lets programmers focus on 'what' an object does rather than 'how' it does it. In Java, abstraction is primarily achieved through two mechanisms: abstract classes and interfaces.
Cricket analogy: Abstraction is like a captain only needing to know a bowler can "deliver a wicket-taking ball" (what) without tracking the exact wrist-seam mechanics (how), achieved in Java via abstract Bowler classes and Fieldable interfaces.
An abstract class can provide partial implementation — a mix of fully implemented (concrete) methods and abstract (unimplemented) methods that subclasses must override. An interface, by contrast, traditionally defines a pure contract of method signatures that implementing classes must fulfill (interfaces are covered in depth in the OOP Advanced module).
Cricket analogy: An abstract "Bowler" class might implement runUp() concretely while leaving delivery() abstract, whereas a "Fieldable" interface just demands catch() and throw() signatures without saying how any team executes them.
2. Syntax
// Abstract class
abstract class Shape {
abstract double area(); // abstract method - no body
void describe() { // concrete method - has a body
System.out.println("This is a shape with area: " + area());
}
}
class Circle extends Shape {
double radius;
Circle(double radius) { this.radius = radius; }
@Override
double area() {
return Math.PI * radius * radius;
}
}3. Explanation
An abstract class is declared using the abstract keyword and cannot be instantiated directly with new — attempting new Shape() would cause a compile-time error. It can, however, declare constructors (called via subclass constructors through implicit or explicit super()), instance fields, concrete methods with full implementations, and abstract methods that have no body and must be implemented by any concrete (non-abstract) subclass.
Cricket analogy: Writing new Bowler() directly is like fielding a generic, unnamed bowler in a match scorecard - Java refuses it at compile time, though Bowler can still declare a runUp field and a constructor called via Pacer's super().
If a subclass does not implement all inherited abstract methods, that subclass must itself be declared abstract. Interfaces provide another route to abstraction: a class implements an interface using the implements keyword, promising to provide concrete bodies for all of the interface's abstract methods. Together, abstract classes and interfaces let API designers define 'what' operations must exist without necessarily dictating 'how' every one of them is implemented.
Cricket analogy: If Wicketkeeper extends abstract Fielder but skips catch(), it must itself be declared abstract; meanwhile a class implements the Stumper interface with implements, promising to define stump() so selectors know 'what' every keeper must do without dictating 'how'.
Exam trap: An abstract class CAN have a constructor and concrete (fully implemented) methods — it is not required to have all methods abstract. What makes it abstract is that it cannot be instantiated directly, and it may contain zero or more abstract methods.
Quick contrast: abstract classes can mix abstract and concrete methods and support single inheritance; interfaces traditionally define contracts and support multiple inheritance of type. Full interface rules are covered in the dedicated interfaces-in-java lesson.
4. Example
abstract class Employee {
String name;
Employee(String name) {
this.name = name;
}
abstract double calculateSalary(); // abstract method
void printPayslip() { // concrete method
System.out.println(name + "'s salary: " + calculateSalary());
}
}
class FullTimeEmployee extends Employee {
double monthlySalary;
FullTimeEmployee(String name, double monthlySalary) {
super(name);
this.monthlySalary = monthlySalary;
}
@Override
double calculateSalary() {
return monthlySalary;
}
}
class Demo {
public static void main(String[] args) {
// Employee e = new Employee("X"); // compile error - cannot instantiate abstract class
Employee emp = new FullTimeEmployee("Kiran", 60000);
emp.printPayslip();
}
}5. Output
Kiran's salary: 60000.06. Key Takeaways
- Abstraction hides implementation details and exposes only essential behavior.
- Abstract classes can mix abstract methods (no body) with concrete methods (full implementation).
- An abstract class cannot be instantiated directly, even if it has concrete methods and a constructor.
- A concrete subclass must implement all inherited abstract methods, or it must also be declared abstract.
- Interfaces are another abstraction mechanism in Java, defining a contract of methods to be implemented.
Practice what you learned
1. What is abstraction in OOP?
2. Can an abstract class be instantiated directly?
3. What must a concrete subclass of an abstract class do?
4. Which of these is TRUE about abstract classes in Java?
5. In the Employee example, why can't `new Employee("X")` be used directly?
Was this page helpful?
You May Also Like
Polymorphism in Java
Explore compile-time and runtime polymorphism in Java, including method overloading, overriding, and dynamic dispatch.
Inheritance in Java
Understand Java inheritance using the extends keyword, the super keyword, single inheritance rules, and the Object root class.
Encapsulation in Java
Learn how encapsulation in Java bundles data and behavior together using private fields, access modifiers, and getters/setters.
Related Reading
Related Study Notes in Programming
Browse all study notesApache Spark Study Notes
Programming · 30 topics
ProgrammingApache Flink Study Notes
Programming · 30 topics
ProgrammingHadoop Study Notes
Programming · 30 topics
ProgrammingSnowflake Study Notes
Programming · 30 topics
ProgrammingApache Airflow Study Notes
Programming · 30 topics
Programmingdbt (Data Build Tool) Study Notes
Programming · 30 topics