Abstract Class in Java

Introduction

Java is a programming language that is high level, based on class and object-oriented which is made in such a way that very few dependencies. It is a very general-purpose language and is also WORA, i.e. write once run everywhere. It essentially means that you can run the compiled code on all platforms without further compilation required.

Now in the Java programming language understanding Abstract classes is imperative to create a base for other classes to build upon. In this article, we will read about what is an abstract class, explain abstract class, abstract class in Java, and abstraction in Java with example

abstract class meaning, java abstract class example, abstract class and method in java, what is the purpose of abstract class and php abstract class.

What is Abstract Class?

It is a class that can not be started independently. It is made to be a superclass that gives a common platform for its sub-classes and also potentially contains both abstract and non-abstract methods. The thing about the abstract method is that it can be implemented with the subclasses only and is often declared without implementation. Now that we understand the abstract class, let’s understand the key characteristics of the abstract class.

abstract class Animal {
    abstract void makeSound();
    void breathe() {
        System.out.println("This animal is breathing.");
    }
}

What are the characteristics of Abstract Classes?

There are around 4 major characteristics of abstract classes, these are listed below:

• Can’t be instantiated directly: as we read above they need a subclass to be instantiated. 
• Mix Methods: they contain a mix of methods abstracts and concrete methods. 
• Constructors: when the subclasses are instantiated the constructors are called. 
• Inheritance: abstract classes have the ability to inherit from other classes but a class can only inherit from one abstract class.

Advantages of Using Abstract Class: Abstract classes are used when there are numerous related classes but they have one common structure but are different in some specific behaviours.

Examples of Abstract Class

Example 1: Abstract Shape Class

Assuming you know a few basics let's understand a case where we have a graphical application where some shapes like circles, and rectangles, need to be drawn. Each shape has common properties like colour and areas but is different in the sense of how they are being drawn:

abstract class Shape {
    String color;
    
    Shape(String color) {
        this.color = color;
    }
    
    abstract void draw();
    
    abstract double area();
    
    void displayColor() {
        System.out.println("Color: " + color);
    }
}

class Circle extends Shape {
    double radius;
    
    Circle(String color, double radius) {
        super(color);
        this.radius = radius;
    }
    
    @Override
    void draw() {
        System.out.println("Drawing a Circle.");
    }
    
    @Override
    double area() {
        return Math.PI * radius * radius;
    }
}

class Rectangle extends Shape {
    double length, breadth;
    
    Rectangle(String color, double length, double breadth) {
        super(color);
        this.length = length;
        this.breadth = breadth;
    }
    
    @Override
    void draw() {
        System.out.println("Drawing a Rectangle.");
    }
    
    @Override
    double area() {
        return length * breadth;
    }
}

Example 2: Abstract Animal Class
 

Let's understand the classic animal example in a zoo different animals exhibit different characteristics but have common traits of eating and sleeping. 

abstract class Animal {
    String name;
    
    Animal(String name) {
        this.name = name;
    }
    
    abstract void makeSound();
    
    void eat() {
        System.out.println(name + " is eating.");
    }
    
    void sleep() {
        System.out.println(name + " is sleeping.");
    }
}

class Lion extends Animal {
    Lion(String name) {
        super(name);
    }
    
    @Override
    void makeSound() {
        System.out.println("Roar!");
    }
}

class Elephant extends Animal {
    Elephant(String name) {
        super(name);
    }
    
    @Override
    void makeSound() {
        System.out.println("Trumpet!");
    }
}

Abstract Vs Interface

While both of them are used to achieve abstraction they have different goals, let's understand them below:

Interface:

Cannot have an instance variable (before the advent of Java 8 interfaces could not have default modes. 
Used to define the contract of methods without any implementation. 
One class can facilitate numerous interfaces, which means more flexibility.

Abstract class: 

Can have instance variables and constructors
Chave both abstract and concrete methods
The subclasses have a common base class and hence have shared behavior and state.

Conclusion:

Abstract classes in Java are a potent feature that allows for the creation of a common base for the related classes that have shared functions and method implementation is done through abstract methods. By using this method we can ensure a well-structured and manageable codebase, which makes making complex applications easy. So if you are using a graphical application of managing a zoo abstract classes come in handy and can help in enhancing your Java programming skills.