🌟 Introduction
As you progress in Java and Object-Oriented Programming (OOP), you will often face situations where:
- Some methods should be common for all classes
- Some methods should be implemented differently by each class
- And some classes should not be instantiated directly
This is where Abstract Classes come into play.
Abstract classes help in designing programs where you want to define a base structure, but leave some parts incomplete so that child classes can complete them.
👉 They act as a blueprint for other classes.
🧠 What is an Abstract Class?
An abstract class is:
A class that cannot be instantiated and may contain abstract methods (methods without body).
🔑 Key Idea
👉 Abstract class = incomplete class
👉 Abstract method = method without implementation
🧾 Syntax of Abstract Class
abstract class Animal {
abstract void sound();
}🔎 Explanation
abstract class Animal→ cannot create objectabstract void sound()→ method has no body
💻 Basic Example of Abstract Class
abstract class Animal {
abstract void sound();
}
class Dog extends Animal {
void sound() {
System.out.println("Dog barks");
}
}
public class Main {
public static void main(String[] args) {
Dog d = new Dog();
d.sound();
}
}🔎 Line-by-Line Explanation
abstract class Animal
👉 Parent class is abstract
👉 Cannot create object of Animal
abstract void sound();
👉 Abstract method
👉 No body (no {})
class Dog extends Animal
👉 Dog inherits Animal
void sound()
👉 Dog must implement this method
Dog d = new Dog();
👉 Object created for child class
d.sound();
👉 Calls implemented method
🧾 Output
Dog barks
⚠️ Important Rule
👉 If a class contains an abstract method:
✔ The class must be declared abstract
🚫 Cannot Create Object of Abstract Class
Animal a = new Animal(); // ❌ Error
👉 Abstract classes cannot be instantiated
🧠 Abstract Class Can Have Normal Methods
abstract class Animal {
void eat() {
System.out.println("Animal eats");
}
abstract void sound();
}🔎 Explanation
👉 Abstract class can have:
✔ Abstract methods
✔ Normal methods
💻 Example with Both Methods
abstract class Animal {
void eat() {
System.out.println("Animal eats");
}
abstract void sound();
}
class Dog extends Animal {
void sound() {
System.out.println("Dog barks");
}
}
public class Main {
public static void main(String[] args) {
Dog d = new Dog();
d.eat();
d.sound();
}
}🧾 Output
Animal eats
Dog barks
🔥 Abstract Class with Constructors
Yes, abstract classes can have constructors.
💻 Example
abstract class Animal {
Animal() {
System.out.println("Animal Constructor");
}
}
class Dog extends Animal {
Dog() {
System.out.println("Dog Constructor");
}
}
public class Main {
public static void main(String[] args) {
Dog d = new Dog();
}
}🧾 Output
Animal Constructor
Dog Constructor
🧠 Concept
👉 Constructor is used to initialize parent part
👉 Even abstract class constructor is called
🎯 Real-World Example
abstract class Employee {
abstract void calculateSalary();
}
class Manager extends Employee {
void calculateSalary() {
System.out.println("Manager Salary");
}
}
class Developer extends Employee {
void calculateSalary() {
System.out.println("Developer Salary");
}
}🧠 Concept
👉 Employee defines structure
👉 Manager & Developer define behavior
⚙️ Rules of Abstract Classes
✔ Rule 1: Cannot Create Object
abstract class A { }
A obj = new A(); // ❌
✔ Rule 2: Must Implement Abstract Methods
class Dog extends Animal
👉 Must implement all abstract methods
✔ Rule 3: Can Have Constructors
✔ Used during object creation
✔ Rule 4: Can Have Variables & Methods
✔ Not limited to abstract methods
🔄 Abstract Class vs Normal Class
| Feature | Abstract Class | Normal Class |
|---|---|---|
| Object creation | ❌ Not allowed | ✔ Allowed |
| Methods | Abstract + Normal | Only normal |
| Purpose | Blueprint | Full implementation |
⚠️ Common Mistakes & Confusions
❌ Mistake 1: Trying to Create Object
Animal a = new Animal(); // ❌
❌ Mistake 2: Not Implementing Abstract Method
class Dog extends Animal {
// missing sound() ❌
}
👉 Compile-time error
❌ Mistake 3: Forgetting abstract keyword
class Animal {
abstract void sound(); // ❌ Error
}
❌ Mistake 4: Thinking Abstract Class Cannot Have Methods
❌ Wrong
✔ It can have both types
🧨 Tricky Interview Question
abstract class A {
abstract void show();
}
class B extends A {
void show() {
System.out.println("B");
}
}👉 Valid or not?
✔ Valid
🧠 Key Points to Remember
✔ Abstract class cannot be instantiated
✔ Used as base class
✔ Can contain abstract + normal methods
✔ Child class must implement abstract methods
✔ Supports constructors
🎯 When to Use Abstract Classes?
Use abstract classes when:
✔ You want a common base class
✔ Some methods should be defined later
✔ You want partial abstraction
🏁 Conclusion
Abstract classes are a powerful feature in Java that help developers design flexible and reusable code structures.
They allow you to:
- Define a common structure
- Force child classes to implement important methods
- Combine abstraction with inheritance
In this article, you learned:
- What abstract classes are
- How they work
- Syntax and examples
- Rules and limitations
- Common mistakes
Understanding abstract classes is essential because they are widely used in:
- Frameworks
- APIs
- Large-scale applications
🚀 What’s Next?
The next topic is:
👉 Interfaces in Java
Where you will learn:
- 100% abstraction
- Multiple inheritance
- Real-world design patterns
