Purpose of Abstract Class in Java

Abstract classes in Java play a key role in object-oriented programming (OOP). They serve as blueprints for other classes, defining the structure their subclasses must follow. It enhances code organization, promotes code reusability, and enforces consistency. In this blog, we will explore the concept of abstract classes, their purpose, implementation, and benefits. You’ll also gain insights into when to use them and explore key distinctions between abstract classes and interfaces. 

Understanding the importance of abstract classes is fundamental for any Java programmer, as they form the backbone of robust, extensible code in OOPs.

Learn Java programming through our Java Programming Course:

What is an Abstract Class in Java?

An abstract class definition in Java can be described as a class that cannot be instantiated directly. It means that one cannot create an object of an abstract class.

To explain with an abstract class example in Java: Imagine an abstract class named “Vehicle”. This class might have an abstract method called “move”. While the concept of moving is common to all vehicles, the way a car moves differs from how a boat or an airplane does. Thus, subclasses like “Car,” “Boat,” and “Airplane” would provide their unique implementations of the “move” method. In this analogy, the “Vehicle” class provides a general idea. However, it doesn’t specify the exact movement, leaving that to its subclasses.

More on abstract class in Java:

• Instead, it serves as a foundation upon which other classes can be built. 
• The primary purpose of an abstract class in Java is to provide a common structure for its subclasses, ensuring that they implement certain essential methods.
• Abstract methods are defined using the ‘abstract’ keyword.
• An abstract class can contain both abstract (without a body) and concrete (with a body) methods. 
• The abstract methods act as placeholders, compelling the derived classes to provide concrete implementations for them. 
• Abstract classes in Java ensure a level of consistency and uniformity in the behavior of the subclasses.
• It encapsulates shared attributes and methods, promoting a structured and consistent approach to object-oriented programming in Java.
• The ‘abstract’ keyword allows us to create abstract methods in Java, which lack method bodies.
• When a class contains abstract methods, it must also be declared as ‘abstract’ using the ‘abstract’ keyword, or it won’t compile.
• It’s not obligatory for an abstract class to include abstract methods. It can be marked as ‘abstract’ even if it doesn’t declare any.
• If an abstract class lacks method implementations entirely, it’s advisable to consider using an interface. Java doesn’t support multiple-class inheritance.
• Subclasses of an abstract class in Java must implement all the abstract methods unless the subclass is also abstract.
• In interfaces, all methods are inherently abstract, except for static or default methods, which were introduced in Java 8.
• Java abstract classes have the flexibility to implement interfaces without necessarily providing interface method implementations.
• Java abstract classes serve two main purposes: offering common method implementations to subclasses or providing default implementations.
• An abstract class in Java can be executed like any other class if it contains a ‘main()’ method.

How to Use an Abstract Class in Java

Abstract classes are indispensable tools that facilitate the implementation of object-oriented programming (OOP) principles. They provide a blueprint for related classes, promoting code organization and reusability while enforcing a consistent structure. 

To harness the power of abstract classes in Java effectively, it’s essential to understand their features, usage, and the flow of control within them.

Using Abstract Classes in Java:

Declaring an Abstract Class: Begin by declaring an abstract class using the ‘abstract’ keyword. An abstract class can contain both abstract (unimplemented) and concrete (implemented) methods.

abstract class Vehicle {
       // Fields and methods go here
   }

Abstract Methods: Abstract methods are declared without an implementation. They act as placeholders that must be overridden by any concrete subclass that extends the abstract class. 

abstract void start();

Concrete Methods: Concrete methods within an abstract class have complete implementations. Subclasses can inherit these methods without modification.

void stop() {
       // Implementation goes here
   }

Abstract Classes: To create a concrete class that extends an abstract class, use the ‘extends’ keyword. Subclasses must provide implementations for all abstract methods defined in the abstract class.

class Car extends Vehicle {
       // Implement abstract methods
       void start() {
           // Implementation for starting a car
       }
   }

Flow of Control in Abstract Classes:

• When using an abstract class in Java, the flow of control typically follows these steps:
• An abstract class is defined as a mix of abstract and concrete methods.
• A concrete subclass extends the abstract class.
• The subclass must provide implementations for all abstract methods.
• The subclass can inherit and use the concrete methods of the abstract class.
• Objects of the subclass can be instantiated and used in the program.

By effectively utilizing abstract classes in Java, developers can design organized, extensible code structures that streamline development and promote adherence to OOP principles. 

Here are a few of the real-life examples where the concept of abstract classes in Java is used:

• Graphics Applications: In graphics applications, an abstract class ‘Shape’ could define common properties like position and color, with abstract methods for calculating area and perimeter. Concrete subclasses like ‘Circle’ and ‘Rectangle’ would provide specific implementations for these methods.
• Banking Systems: In a banking system, an abstract class like ‘Account’ could define generic account operations, while concrete subclasses like ‘SavingsAccount’ and ‘CheckingAccount’ would implement account-specific behaviors.

What is the Purpose of an Abstract Class?

The purpose of an abstract class in Java extends far beyond the very creation of blueprints for subclasses. 

It’s a key design element that empowers developers to

• Enforce structure
• Streamline code
• Ensure adherence to object-oriented programming (OOP) principles

Now, let’s dive into the diverse roles that abstract classes play in the Java ecosystem.

Blueprint for Subclasses:

An abstract class serves as a template, guiding the creation of derived classes. 

• While you cannot instantiate an abstract class directly, it defines a set of common attributes and methods that subclasses must follow. 
• This concept promotes code consistency and prevents arbitrary deviations by ensuring that all derived classes share a predefined structure.

Encapsulation of Common Logic:

Abstract classes enable the encapsulation of common logic. 

• They facilitate code reusability by including both concrete (implemented) and abstract (unimplemented) methods. 
• Concrete methods provide a shared implementation that derived classes can inherit. In contrast, abstract methods mandate each subclass’s implementation of specific functionality. 
• This encapsulation prevents redundant code and promotes a modular codebase.

Polymorphism and Method Signatures:

One of the fundamental principles of OOP is polymorphism, where objects of different classes can be treated as instances of a common superclass. 

• Abstract classes play a key role in achieving this polymorphism by defining method signatures that derived classes must implement. 
• It facilitates generic references to abstract class types, allowing for dynamic method invocation based on the specific subclass.

Flexibility and Extensibility:

Abstract classes strike a delicate balance between structure and flexibility. 

• While they enforce a basic framework, they also provide the freedom for subclasses to implement unique functionalities. 
• This flexibility is essential when you have a set of related classes with shared attributes but distinct behaviors. 
• It allows you to create a hierarchy of classes that maintains a strong family resemblance while accommodating specific variations.

How Do You Code an Abstract Class?

Here’s a step-by-step guide to coding an abstract class in Java:

Pseudo Code for Abstract Class in Java

DECLARE abstract class named 'ClassName'
    DECLARE abstract method 'methodName'
    DECLARE regular method with its implementation
END class

Java Code for Abstract Class Implementation

// Declaring the abstract class
abstract class Animal {
    // Abstract method declaration
    abstract void sound();
    // Regular method with its implementation
    public void breathe() {
        System.out.println("Breathing...");
    }
}
// Subclass extending the abstract class
class Dog extends Animal {
    // Implementing the abstract method
    @Override
    void sound() {
        System.out.println("Dog barks");
    }
}
public class TestAbstractClass {
    public static void main(String[] args) {
        // Creating an instance of the subclass
        Dog myDog = new Dog();
        myDog.sound(); // Calls the implemented method  
myDog.breathe(); // Calls the inherited method
    }
}

Output:
Dog barks
Breathing…

Explanation:

• The ‘Animal’ class is declared abstract, indicating it cannot be instantiated directly.
• Within the ‘Animal’ class, there’s an abstract method called ‘sound(),’ which lacks implementation.
• The ‘Dog’ class, a subclass of ‘Animal’, provides a concrete implementation for the `sound()` method.
• In the ‘TestAbstractClass’, we instantiate the ‘Dog’ class and call both the implemented ‘sound()’ method and the inherited ‘breathe()’ method.

Coding Abstract Class in C#

// Declaring the abstract class
abstract class Shape {
    // Abstract method declaration
    public abstract double Area();
    // Regular method with its implementation
    public void DisplayArea(double area) {
        Console.WriteLine("Area: " + area);
    }
}
// Subclass extending the abstract class
class Circle : Shape {
    private double radius;
    public Circle(double r) {
        radius = r;
    }
    // Implementing the abstract method
    public override double Area() {
        return 3.14 * radius * radius;
   }
}
public class Program {
    public static void Main() {
        // Creating an instance of the subclass
        Circle circle = new Circle(5);
        double area = circle.Area();
        circle.DisplayArea(area); // Calls the inherited method
    }
}

Output:
Area: 78.5

Explanation:

• The ‘Shape’ class is declared abstract, signifying that it cannot be instantiated on its own.
• Within the ‘Shape’ class, there’s an abstract method called ‘Area(),’ which is devoid of implementation.
• The ‘Circle’ class, a subclass of ‘Shape’, provides a concrete implementation for the ‘Area()’ method.
• In the ‘Program’ class, we instantiate the ‘Circle’ class, compute the area, and then display it using the inherited ‘DisplayArea()’ method.

Implementing Abstract Class in PHP

<?php
// Declaring the abstract class
abstract class Fruit {
    // Abstract method declaration
    abstract protected function taste();
    // Regular method with its implementation
    public function color() {
        return "Color is unknown";
    }
}
// Subclass extending the abstract class
class Apple extends Fruit {
    // Implementing the abstract method
    protected function taste() {
        return "Sweet";
    }
}
// Instantiate the subclass
$appleInstance = new Apple();
echo $appleInstance->taste(); // Calls the implemented method
echo "\n";
echo $appleInstance->color(); // Calls the inherited method
?>

Output:
Sweet
Color is unknown

Explanation:

• The ‘Fruit’ class is declared abstract, meaning it can’t be directly instantiated.
• Within the ‘Fruit’ class, there’s an abstract method called ‘taste(),’ which lacks a concrete implementation.
• The ‘Apple’ class, a subclass of ‘Fruit’, provides the specific implementation for the ‘taste()’ method.
• In the main code, we create an instance of the ‘Apple’ class and invoke both the implemented ‘taste()’ method and the inherited ‘color()’ method.

Difference Between Abstract Class and Interface in Java

When diving into Java’s object-oriented programming, a common dilemma arises: ‘abstract class vs. interface‘. Both serve as blueprints for classes, but they have distinct characteristics. Understanding the difference between an abstract class and an interface is crucial for effective coding in Java. 

Here’s a detailed comparison:

What are the Benefits of Abstract Classes?

Abstract classes in Java offer a structured approach to software design, ensuring that certain methods and behaviors are consistently implemented across related classes. Let’s dive into the benefits of abstract classes and understand why they are so widely embraced by developers.

Code Reusability: One of the primary advantages of abstract classes is the promotion of code reusability. Abstract classes allow developers to define methods and behaviors that can be inherited by multiple subclasses, eliminating the need to rewrite the same code multiple times.

abstract class Animal {
    void breathe() {
        System.out.println("Breathing...");
    }
    abstract void sound();
}

Consistency: Abstract classes ensure that all subclasses adhere to a certain blueprint. It means that if you have an abstract method in the parent class, every child class must provide its own implementation, ensuring a consistent approach across different objects.

Flexibility: While abstract classes define certain methods, they don’t dictate how these methods are implemented. It gives developers the flexibility to provide specific implementations in subclasses, catering to their unique requirements.

class Dog extends Animal {
    @Override
    void sound() {
        System.out.println("Bark");
    }
}

Security: By making a class abstract, developers can prevent it from being instantiated on its own. It ensures that only complete, well-defined objects, which are the subclasses, are created, enhancing the robustness of the code.

Encapsulation: Abstract classes can encapsulate common attributes and behaviors, hiding the complexities from the user. This abstraction allows developers to change internal workings without affecting classes that inherit from the abstract class.

Hierarchical Inheritance: Abstract classes lay the foundation for a hierarchical inheritance structure. They can be seen as the top tier in an inheritance hierarchy, with concrete subclasses forming the subsequent layers.

When Not to Use Abstract Classes?

In Java programming, while the abstract class offers numerous advantages, there are scenarios where its usage may not be ideal. Understanding when not to use abstract classes is as crucial as knowing their benefits. 

• Multiple Inheritance: Java doesn’t support multiple inheritance for classes. If a class already extends another class, it cannot extend an abstract class. In such cases, interfaces are more suitable, as Java permits a class to implement multiple interfaces.

• Versioning Issues: If you add a new method to an abstract class and it’s not marked as abstract, all the subclasses inheriting it will need to be recompiled, even if they don’t use the new method. This can lead to versioning challenges.

• Flexibility Constraints: Abstract classes enforce a rigid structure. If subclasses need a different method implementation than what’s provided by the abstract class, it can lead to unnecessary code overriding, making the system less flexible.

• Object Composition: In situations where object composition is favored over class inheritance, using abstract classes might not be the best choice. Object composition allows for greater flexibility by building complex objects from simpler ones without the constraints of a strict inheritance hierarchy.

• Lightweight Design Needs: For lightweight design requirements where only a specific set of methods need to be enforced, interfaces might be a better choice. They provide a contract without imposing the overhead of an inheritance hierarchy.

• Abstract Class Limitations: One of the primary limitations of abstract classes is that they can’t be instantiated directly. This can be restrictive when you need multiple instances of the base behavior without any specialized behavior.

Conclusion

Abstract classes in Java are key concepts in object-oriented programming, serving as blueprints that encapsulate shared functionalities while prohibiting direct instantiation. They promote code reusability, consistency, and a structured coding paradigm. As we’ve explored, these classes contain both abstract and concrete methods, ensuring that subclasses provide specific implementations. 

For budding developers, understanding abstract classes is just the beginning. To deepen your Java proficiency, it’s imperative to delve into interfaces, polymorphism, and design patterns. These concepts, coupled with abstract classes, will equip you with a robust toolkit to craft efficient and modular software solutions. 

Frequently Asked Questions:

Can we create object of abstract class?

You cannot create an object of an abstract class in Java. By abstract definition, an abstract class serves as a blueprint and must be extended by a concrete subclass for instantiation.

What is purpose of abstract class?

The purpose of an abstract class by abstract class definition is to provide a blueprint for subclasses, enforcing structure and method implementation while promoting code organization and reusability.

How many instances of an abstract class can be created?

Zero, an abstract class in Java cannot be instantiated directly. Therefore, no instances of an abstract class in Java can be created. Abstract classes in Java serve as blueprints for subclasses.

Difference between abstract class and abstract method.

Major differences between abstract class in Java and abstract method in Java:

How can we make a class abstract?

To create an abstract class in Java, simply use the “abstract” keyword in the class declaration, indicating its abstract nature. 

For example: abstract class MyAbstractClass {}.