Abstract Class in Java

What is Abstract Class in Java?

A Class that may contain abstract and non-abstract methods and is declared using the “abstract” keyword is known as Abstract Class. It provides common functionality and attributes that subclasses can extend and override.

Syntax of Abstract Class in Java

Here’s the basic syntax for defining an Abstract Class in Java:

abstract class ClassName {
    // Abstract method (does not have a body)
    abstract void methodName();

    // Concrete method (has a body)
    void anotherMethod() {
        // Method implementation
    }

    // Fields (optional)
    int field;
}

Some crucial points to keep in mind about Abstract Classes are:

• To define an abstract class, you use the abstract keyword in the class declaration. 
   
• They cannot be instantiated, i.e., we cannot create an object of an abstract class.
   
• They may have a constructor and static and final methods.
   
• They can contain abstract methods, which are declared without a method body and end with a semicolon. 
   
• Abstract classes can also have concrete methods (methods with a body) that provide default behavior and can be used by subclasses.
   
• They can provide a partial implementation of an interface or a common functionality shared by multiple subclasses.

Example of Abstract Class

/* abstract class */
abstract class WarGame {
   protected String character_name;
   protected int attack_points;

   public abstract void attack();

   public abstract void save_health();
}

class Dragon extends WarGame {

   public void attack() {
       /* specific implementation for dragon attack */
   }

   public void save_health() {
       /* specific implementation for dragon defence */
   }
}

Here, we have created an Abstract Class ‘WarGame’ that defines common attributes and methods like ‘attack’ and ‘save_health’. The subclass ‘Dragon’ extends the ‘WarGame’ class and provides its specific implementation of the Abstract Methods. This allows us to create different characters in the game and customizing their common behaviors,

To know more about Hashcode Method in Java click here

Why Do We Need an Abstract Class in Java?

• The Abstract Classes encapsulate the related properties and behaviors, promoting data and information hiding.
   
• These are used in various libraries to provide a base class with common functionalities. Subclasses can extend these base classes to customize the methods according to their needs.
   
• By encapsulating the common methods in an Abstract Class, we can reduce the repetition of methods, minimizing the code length.
   
• It can have both abstract and concrete methods. So the concrete method can implement the default behavior, and the abstract method defines the behavior depending on the subclass implementing it. This makes our code flexible.
   
• We can write the same code for the subclasses of an Abstract Class as they share common properties and methods, which makes the code reusable.

Abstract Method in Java

It is a method without implementation or body and is declared in an Abstract Class. If a subclass extends an Abstract Class, it must implement all the Abstract Methods of the Abstract Class. It promotes the concept of polymorphism, abstraction, and code reusability by defining common methods that the different classes can implement.

Syntax of Abstract Method in Java

abstract returnType methodName(parameters);

Example of Abstract Method

abstract class Job {
  
   /* abstract methods */
   public abstract int base_salary();

   public abstract int CTC();
}

class DataScientist extends Job {

   public int base_salary() {
       /* base salary for data scientists  */
   }

   public int CTC() {
       /* CTC for data scientists */
   }
}

Here, we have an Abstract Class ‘Job’ having two Abstract methods, ‘base_salary’ and ‘CTC’. The subclass ‘DataScientist’ extends the class ‘Job’ and has its own implementation for the abstract methods defined in the abstract class. 

Real Scenario of Abstract Class in Java

A real-life scenario where abstract classes are commonly used is in designing and implementing various vehicles. Let's consider a simple scenario where we have different types of vehicles, such as bikes, cars, etc. To represent these vehicles, we can create an abstract class called vehicle:

/* abstract class */
abstract class vehicle {
   protected String company;
   protected int price;


   /* constructor for the abstract class*/
   public vehicle(String company, int price) {
       this.company = company;
       this.price = price;
   }


   /* abstract methods */
   public abstract void ApplyBrakes();
   public abstract void Accelerate();


}

class Bike extends vehicle{
  
   /* constructor for the Bike class */
   public Bike(String company, int price) {
       super(company, price);
   }

   public void ApplyBrakes() {
       /* implementation to apply brakes of a bike*/
   }

   public void Accelerate() {
       /* implementation to accelerate a bike */
   }

}

The code above is for a vehicle simulation system. We have an Abstract Class ‘vehicle’ having common methods and properties that all vehicles should have. The methods ‘ApplyBrakes’ and ‘Accelerate’ are of an abstract type, as their implementation varies from vehicle to vehicle. A subclass ‘Bike’ provides its own implementation to the Abstract Methods of the Abstract Class. There can be many more such subclasses for different vehicles with their own implementations for the Abstract Methods of the Abstract Class.

Real Scenario of Abstract Method

A real-life scenario where abstract methods are commonly used is in resizing the image. Let's consider a simple scenario where we have methods to resize the image, such as height and width. We also have types of images such as jpeg and png. To represent these resizing methods, we can create an abstract class called ImageResizer:

abstract class ImageResizer {
   /* abstract methods*/
   public abstract void changeHeight(int height);
   public abstract void changeWidth(int width);
}

class jpegImageResizer extends ImageResizer {
   public void changeHeight(int height) {
       /* implementation for changing the height of a jpeg image */
   }
   public void changeWidth(int width) {
       /* implementation for changing the width of a jpeg image */
   }
}

class pngImageResizer extends ImageResizer {
   public void changeHeight(int height) {
       /* implementation for changing the height of a png image */
   }
   public void changeWidth(int width) {
       /* implementation for changing the width of a png image */
   }
}

The above code is for the image resizer. We have an Abstract Class, ‘ImageResizer,’  having two Abstract Methods for changing the height and width of an image. The subclass ‘jpegImageResizer’ is for adjusting the height and width of a jpeg image, whereas the subclass ‘pngImageResize’ is for adjusting the height and width of a png image. Both of these classes use the abstract methods ‘changeHeight’ and ‘changeWidth’ and have their own implementation for these methods.

Constructors of Java Abstract Class

An Abstract Class can have any Constructor that any other class may have. It cannot be instantiated on its own, but it is invoked when an object calls the Constructor of its subclass.

Let’s see some implementation details of the Constructors of an Abstract Class.

Code

• Java

Java

/* abstract class */
abstract class parent {
   String value1;
   String value2;

   /* constructor with no parameter */
   public parent() {
       this.value1 = null;
       this.value2 = null;
   }

   /* constructor with one parameter */
   public parent(String value1) {
       this.value1 = value1;
       this.value2 = null;
   }

   /* constructor with two parameters */
   public parent(String value1, String value2) {
       this.value1 = value1;
       this.value2 = value2;
   }
}

class child extends parent {
  
   public child() {
       super();
   }

   public child(String value1) {
       super(value1);
   }

   public child(String value1, String value2) {
       super(value1, value2);
   }
}


class Solution {

   public static void print(child object) {
       System.out.println(object.value1 + " " + object.value2);
   }

   public static void main(String[] args) {
       /* invoking all three constructors */
      child object1 = new child();
      child object2 = new child("first_string");
      child object3 = new child("first_string", "second_string");
      print(object1);
      print(object2);
      print(object3);
   }
}

You can also try this code with Online Java Compiler

Run Code

Output

null null
first_string null
first_string second_string

In this example, an Abstract Class ‘parent’ has three types of constructor, one with no parameter and the other two with one and two parameters. These Constructors are invoked by the subclass ‘child’ using the ‘super()’ keyword. We can’t create the objects of the class ‘parent’, as it is an Abstract Class. So we have created the objects of the class ‘child’, which inherits the constructor from the Abstract Class.  

Properties of Abstract Class

• Abstract Methods: Contains at least one pure virtual function, making it mandatory for derived classes to implement.
• Cannot be Instantiated: Cannot create objects of an abstract class directly.
• Inheritance: Provides a common interface for derived classes to follow.
• Partial Implementation: Can include both implemented and pure virtual methods.
• Destructors: Can have virtual destructors for proper cleanup of derived class resources.

Difference Between Abstract Class and Interface in Java

Frequently Asked Questions

How to declare a class abstract in Java?

To declare a class abstract in Java, use the abstract keyword before the class declaration. For example:

abstract class ClassName {  
   // Class content  
}  

This prevents direct instantiation of the class.

What is the difference between abstraction and abstract class?

Abstraction is a concept of hiding implementation details and showing only functionality, achieved using abstract classes and interfaces. An abstract class is a specific Java construct to implement partial abstraction with both abstract and concrete methods.

Is it possible to create an instance of an abstract class?

No, you cannot create an instance of an abstract class. However, you can create instances of its subclasses that provide implementations for all abstract methods. Abstract classes serve as templates for other classes.

Why is abstract class used in Java?

An abstract class is used in Java to provide a common blueprint for related classes. It allows partial implementation, with some methods having concrete code and others being left abstract. It defines method contracts that subclasses must implement, ensuring consistent behavior across related objects.

Conclusion

In this article, we learned about an abstract class in Java. We learned how to use them and also why they are used. Abstract class and methods are an essential part of the OOPs concept, so questions about them are often asked in interviews. 

Recommended Readings:

• CPP Abstract Class
• What are loops in Java
• Super Keyword In Java
• Access modifiers in Java
• Method overriding in Java
• Fibonacci Series in Java
• Delegation Event Model in Java
• Duck Number in Java