Abstract class in Java

An abstract class is a special type of class in Java that cannot be instantiated. It is used to provide a common interface for a set of related classes, allowing them to share certain methods and fields.

One of the main benefits of using abstract classes is that they allow us to create a set of methods that must be implemented by any concrete (i.e., non-abstract) subclass. This is useful when we want to ensure that all subclasses have certain behavior or contain certain information.

For example, consider a shape class hierarchy. We might have an abstract Shape class that contains fields for the color and position of a shape, as well as an abstract method called draw() that must be implemented by any concrete subclass. We could then have concrete subclasses like Circle, Rectangle, and Triangle, each of which would implement the draw() method in their own way.

To create an abstract class in Java, we simply need to use the abstract keyword before the class definition. For example:

public abstract class Shape {
    protected Color color;
    protected Point position;
    public abstract void draw();

Note that abstract methods do not have a method body. Instead, they simply declare the method signature (i.e., the return type, name, and parameters) and end with a semicolon. Concrete subclasses of the abstract class must then implement this method, providing a concrete implementation.

It’s important to note that an abstract class can contain both abstract methods and concrete methods. Concrete methods are methods that have a method body and can be called directly on an instance of the class. Abstract classes can also contain fields and constructors just like any other class.

Here’s an example of a concrete subclass of the Shape class that we defined above:

public class Circle extends Shape {
    private double radius;
    public Circle(Color color, Point position, double radius) {
        super(color, position);
        this.radius = radius;
    public void draw() {
        // code to draw a circle on the screen

In this example, the Circle class extends the Shape class and implements the abstract draw() method. It also has its own field (radius) and a constructor to initialize this field and the fields inherited from the superclass.

In conclusion, abstract classes are an important tool in Java for creating a common interface for a set of related classes and enforcing certain behavior in those classes. They allow us to create a skeleton of a class hierarchy that can be filled in by concrete subclasses.