14. Abstract classes and methods

14. Abstract Classes and Methods in Java

In object-oriented programming (OOP), the concept of abstraction is fundamental for creating robust and reusable systems. In Java, this abstraction is achieved through the use of abstract classes and methods. This chapter of our e-book will guide you through understanding and applying abstract classes and methods in Java, from the basics to more advanced concepts.

What are Abstract Classes?

An abstract class in Java is a class that cannot be instantiated directly. This means that you cannot create an object of an abstract class using the new operator. Instead, abstract classes are intended to be subclassed by other classes that implement the abstract methods and provide specific functionality.

The declaration of an abstract class is done using the abstract keyword:

public abstract class Shape {
    // ...
}

Abstract classes are often used as base classes, where they define abstract methods that must be implemented by concrete subclasses. These abstract methods act as a contract that subclasses must fulfill.

What are Abstract Methods?

Abstract methods are methods declared without an implementation. They serve as a template for the methods that should be implemented in subclasses. The method signature is defined, but the method body is replaced with a semicolon:

public abstract class Shape {
    public abstract double calculateArea();
}

When a concrete class extends an abstract class, it must provide implementations for all the abstract methods of the base class, or else the concrete class itself must be declared abstract.

Why Use Abstract Classes and Methods?

Abstract classes and methods are used to define a model of classes that share a common structure but have different implementations. This allows you to write code that is independent of the specific implementation, making it more flexible and reusable.

For example, you can have an abstract class Shape with an abstract method calculateArea(). Subclasses like Circle, Rectangle and Triangle would implement this method according to their own rules for calculating the area.

Practical Example of Abstract Classes and Methods

Let's consider a simple example that demonstrates how abstract classes and methods can be used in Java:

public abstract class Animal {
    public abstract void emitSound();

    public void sleep() {
        System.out.println("Zzz...");
    }
}

public class Dog extends Animal {
    @Override
    public void emitSound() {
        System.out.println("Oof oof!");
    }
}

public class Cat extends Animal {
    @Override
    public void emitSound() {
        System.out.println("Meow!");
    }
}

In the example above, the abstract class Animal defines an abstract method emitSound() and a concrete method sleep(). The Dog and Cat classes extend Animal and provide their own implementations of the emitSound() method.

Important Considerations

• An abstract class can have data members, concrete methods (with body), and abstract methods.
• If a class contains at least one abstract method, it must be declared as abstract.
• It is possible to have an abstract class without abstract methods, which can be useful to prevent the class from being instantiated directly.
• Abstract classes cannot be final, as this would prevent inheritance.
• Abstract methods cannot be private, as they are intended to be implemented by subclasses.
• Abstract methods cannot be static or final, as this would prevent them from being overridden.

Conclusion

Abstract classes and methods are powerful tools in a Java programmer's arsenal. They provide a way to define a contract that must be followed by subclasses, thus ensuring a level of abstraction that promotes code reuse and design flexibility. By understanding and applying these concepts, you will be well on your way to becoming an advanced Java developer.

With this knowledge, you are now better prepared to explore design patterns and software architectures that rely heavily on abstraction and inheritance, such as the Template Method design pattern and the Strategy pattern, among others.

Continue practicing and exploring real-world examples to consolidate your understanding of abstract classes and methods in Java. Practice makes perfect, and experimentation leads to mastery.