What Is Java Abstract Keyword?

The abstract keyword in Java is used to define abstract classes and abstract methods, and it is a key feature of Object-Oriented Programming (OOP) in Java. It enables you to create abstract classes that cannot be instantiated directly and allows you to define methods that must be implemented by subclasses. The abstract keyword essentially provides a way to enforce certain behaviors in derived classes while leaving other aspects undefined.

Let’s break down the concept and usage of the abstract keyword in Java in detail.

1. Abstract Class in Java

An abstract class is a class that cannot be instantiated directly (i.e., you cannot create an object of an abstract class). It is meant to be inherited by other classes that provide concrete implementations for the methods that the abstract class defines.

Characteristics of an Abstract Class:

• Cannot be instantiated: You cannot create an object of an abstract class using the new keyword. You must subclass it and instantiate the subclass.
• Can contain abstract methods: An abstract class can have methods that are declared but not implemented. These are abstract methods.
• Can contain concrete methods: An abstract class can also contain fully implemented methods (i.e., methods with a body).
• Can have member variables and constructors: Abstract classes can have fields, constructors, and static methods like any other class.
• May or may not be subclassed: If an abstract class has abstract methods, its subclasses must provide concrete implementations for those abstract methods. However, an abstract class can also be extended by another abstract class without requiring the implementation of its abstract methods.

Syntax for an Abstract Class:

abstract class Animal {
    // Abstract method (does not have a body)
    abstract void sound();

    // Regular method (can have a body)
    public void sleep() {
        System.out.println("This animal is sleeping.");
    }
}

In this example, Animal is an abstract class that has one abstract method sound() and one concrete method sleep(). The abstract method sound() does not have an implementation in the Animal class but must be implemented by any concrete subclass.

2. Abstract Method in Java

An abstract method is a method that is declared without an implementation (i.e., it has no body). Abstract methods must be implemented by subclasses of the abstract class. If a subclass fails to provide an implementation for an abstract method, the subclass itself must be declared as abstract.

Characteristics of Abstract Methods:

• No body: Abstract methods do not have a body, and they end with a semicolon (;).
• Must be implemented by subclasses: If a class inherits an abstract class that contains abstract methods, the subclass must implement those methods unless the subclass is also abstract.
• Defined in abstract classes or interfaces: Abstract methods are usually defined in abstract classes, but they can also be declared in interfaces.

Syntax for an Abstract Method:

abstract class Animal {
    // Abstract method
    abstract void sound();
}

class Dog extends Animal {
    // Implementing the abstract method
    public void sound() {
        System.out.println("Bark");
    }
}

public class Test {
    public static void main(String[] args) {
        // Cannot instantiate Animal directly because it's abstract
        // Animal animal = new Animal(); // This will throw an error

        // Creating an object of Dog, which implements the abstract method
        Animal dog = new Dog();
        dog.sound();  // Output: Bark
    }
}

In this example, sound() is an abstract method in the Animal class. The Dog class provides a concrete implementation for sound(), so objects of Dog can be created.

3. Why Use Abstract Classes and Methods?

The use of abstract classes and methods is important for creating more flexible and maintainable code by enforcing a contract that subclasses must follow. Here are some benefits and use cases:

• Encapsulation of common behavior: An abstract class allows you to provide common functionality (methods) to subclasses without forcing them to implement everything themselves.
• Code Reusability: You can define reusable, generic methods in the abstract class that apply to multiple subclasses, while still leaving specific behaviors (via abstract methods) to be defined by the subclasses.
• Design Flexibility: Abstract classes let you define a blueprint for a group of related classes, allowing you to outline the behaviors that all subclasses must have while giving you flexibility in how the subclasses implement those behaviors.

4. Abstract Class vs. Interface in Java

While both abstract classes and interfaces allow you to define abstract methods, they have some important differences:

Example of Using an Interface:

interface Animal {
    void sound(); // Abstract method

    // Default method with implementation
    default void sleep() {
        System.out.println("This animal is sleeping.");
    }
}

class Dog implements Animal {
    // Implementing the abstract method
    public void sound() {
        System.out.println("Bark");
    }
}

public class Test {
    public static void main(String[] args) {
        Animal dog = new Dog();
        dog.sound();  // Output: Bark
        dog.sleep();  // Output: This animal is sleeping.
    }
}

In this example, the Animal interface defines the sound() method (abstract) and a default method sleep() with an implementation. The Dog class implements the sound() method.

5. Important Points to Remember

• Abstract classes cannot be instantiated: You cannot create an object of an abstract class directly using the new keyword.
• Abstract methods must be implemented: Any class that extends an abstract class must implement all abstract methods unless the subclass is also abstract.
• Abstract methods define a contract: They ensure that certain methods are implemented in subclasses, while leaving the actual implementation details to the subclass.
• Concrete methods in abstract classes: Abstract classes can have concrete methods with a body. These methods are inherited as-is by subclasses unless overridden.

6. Abstract Keyword Example with Real-World Analogy

Consider a scenario in a system for managing different types of vehicles.

abstract class Vehicle {
    // Abstract method
    abstract void startEngine();

    // Concrete method
    void stopEngine() {
        System.out.println("The engine is stopped.");
    }
}

class Car extends Vehicle {
    // Providing implementation for the abstract method
    void startEngine() {
        System.out.println("Car engine started.");
    }
}

class Boat extends Vehicle {
    // Providing implementation for the abstract method
    void startEngine() {
        System.out.println("Boat engine started.");
    }
}

public class Test {
    public static void main(String[] args) {
        // You cannot instantiate Vehicle directly
        // Vehicle v = new Vehicle(); // Error

        Vehicle myCar = new Car();
        myCar.startEngine();  // Output: Car engine started.
        myCar.stopEngine();   // Output: The engine is stopped.

        Vehicle myBoat = new Boat();
        myBoat.startEngine();  // Output: Boat engine started.
        myBoat.stopEngine();   // Output: The engine is stopped.
    }
}

Here, the Vehicle class is abstract, and it defines an abstract method startEngine() which must be implemented by all subclasses (Car, Boat). The stopEngine() method is concrete and inherited as-is by all subclasses.

Conclusion

The abstract keyword in Java is a powerful tool for creating abstract classes and methods. It helps you define a base class with common behavior and abstract methods that must be implemented by subclasses. This allows for a clean, reusable, and maintainable design. Abstract classes and methods provide flexibility and control over the inheritance model, ensuring that certain behavior is implemented in derived classes while allowing others to remain flexible.