Introduction

An abstract class in Java is a special type of class that cannot be instantiated and is designed to be extended by subclasses. It serves as a blueprint for other classes, providing a common definition of a base class that multiple derived classes can share. Abstract classes may contain abstract methods (methods without implementation) as well as concrete methods (with full implementation). They are a key mechanism for achieving abstraction and code reuse in Java’s object-oriented design, sitting between fully concrete classes and fully abstract interfaces.

---

1. What Is an Abstract Class?

• Declared with the abstract keyword.
• Cannot be instantiated directly (new AbstractClass() → compilation error).
• May contain:
• Abstract methods: No body, must be overridden by non-abstract subclasses.
• Concrete methods: Fully implemented, inherited by subclasses.
• Fields, constructors, static members, and even main() method.

Purpose: Define a common interface and partial implementation for a group of related classes.

---

2. Syntax and Declaration

abstract class ClassName {
// Abstract method (no body)
abstract returnType methodName(parameters);
// Concrete method (with body)
void concreteMethod() {
// Implementation
}
}

Example: Abstract Shape Class

abstract class Shape {
protected String color;
// Constructor (yes, abstract classes can have constructors!)
public Shape(String color) {
this.color = color;
}
// Abstract method: must be implemented by subclasses
abstract double area();
// Concrete method: shared by all subclasses
public void displayColor() {
System.out.println("Color: " + color);
}
}

---

3. Rules for Abstract Classes

Rule	Description
Cannot be instantiated	new Shape() → ❌ Compile error
Can have constructors	Called when subclass object is created
May contain abstract and concrete methods	Flexible mix allowed
Subclass must implement all abstract methods	Unless the subclass is also abstract
Can extend only one class	Java supports single inheritance
Can implement multiple interfaces	Yes

---

4. Creating and Using Subclasses

A concrete subclass must implement all abstract methods from its parent abstract class.

Example: Concrete Subclasses

class Circle extends Shape {
private double radius;
public Circle(String color, double radius) {
super(color); // Call abstract class constructor
this.radius = radius;
}
@Override
double area() {
return Math.PI * radius * radius;
}
}
class Rectangle extends Shape {
private double width, height;
public Rectangle(String color, double w, double h) {
super(color);
this.width = w;
this.height = h;
}
@Override
double area() {
return width * height;
}
}

Usage

public class Main {
public static void main(String[] args) {
// Shape s = new Shape("red"); // ❌ Not allowed
Shape circle = new Circle("blue", 5.0);
Shape rect = new Rectangle("green", 4.0, 6.0);
circle.displayColor(); // Inherited concrete method
System.out.println("Circle area: " + circle.area());
rect.displayColor();
System.out.println("Rectangle area: " + rect.area());
}
}

Output:
Color: blue
Circle area: 78.53981633974483
Color: green
Rectangle area: 24.0

---

5. Abstract Classes vs. Interfaces

Feature	Abstract Class	Interface
Instantiation	Cannot be instantiated	Cannot be instantiated
Methods	Can have abstract + concrete methods	Before Java 8: only abstract Java 8+: default, static methods allowed
Fields	Can have instance fields (private, protected, etc.)	Only public static final constants
Constructors	Yes	No
Inheritance	Single inheritance (extends one class)	Multiple inheritance (implements many interfaces)
Access Modifiers	Methods can be private, protected, public	Methods are public by default
Use Case	"Is-a" relationship with shared code	"Can-do" capability, API contracts

When to Use Abstract Class:

• You want to share code among related classes.
• You need to declare non-public members.
• You want to provide a common base with partial implementation.

---

6. Key Features and Capabilities

A. Constructors in Abstract Classes

Even though you can’t instantiate an abstract class, it can have constructors to initialize shared state.

abstract class Animal {
protected String name;
public Animal(String name) {
this.name = name;
}
}

Called via super() in subclass constructors.

B. Concrete Methods

Provide default behavior that subclasses can inherit or override.

abstract class Vehicle {
public void startEngine() {
System.out.println("Engine started.");
}
}

C. Final Methods

Abstract classes can declare final methods to prevent overriding.

abstract class Base {
public final void log() {
System.out.println("Logging...");
}
}

---

7. Best Practices

• Use abstract classes for closely related classes that share common behavior and state.
• Prefer interfaces for unrelated classes that need to support a common capability.
• Keep abstract classes focused—avoid making them too large or complex.
• Document abstract methods clearly so subclasses know how to implement them.
• Avoid deep inheritance hierarchies—favor composition when possible.

---

8. Common Mistakes

• Trying to instantiate an abstract class:

  Shape s = new Shape(); // ❌ Compilation error

• Forgetting to implement abstract methods in a concrete subclass:

  class Triangle extends Shape { } // ❌ Must implement area()

• Declaring abstract methods as private or static:
• private abstract void method(); → ❌ Invalid
• static abstract void method(); → ❌ Invalid (static methods belong to class, not instances)

---

9. Real-World Example: Template Method Pattern

Abstract classes enable design patterns like Template Method, where the skeleton of an algorithm is defined in the abstract class, and subclasses implement specific steps.

abstract class DataProcessor {
// Template method (final to prevent overriding)
public final void process() {
loadData();
processData();
saveData();
}
abstract void loadData();
abstract void processData();
void saveData() {
System.out.println("Data saved.");
}
}
class CSVProcessor extends DataProcessor {
void loadData() { System.out.println("Loading CSV..."); }
void processData() { System.out.println("Processing CSV data..."); }
}

Ensures all processors follow the same workflow while customizing key steps.

---

Conclusion

Abstract classes are a powerful tool in Java for defining shared structure and behavior across a family of related classes. By combining abstract methods (to enforce contracts) with concrete methods (to provide reusable code), they strike a balance between flexibility and control. When used appropriately—especially in scenarios involving code reuse, partial implementation, and inheritance hierarchies—abstract classes lead to cleaner, more maintainable, and logically organized code. However, they should be chosen over interfaces only when the relationship is truly "is-a" and shared state or implementation is needed. Mastering abstract classes is essential for effective object-oriented design in Java.