Why an abstract class implementing an interface can miss the declaration/implementation of one of the interface's methods?

java

programming-to-an-interface

design-patterns

inheritance

byAnton Shumikhin·Mar 13, 2025

An abstract class in Java might partially implement an interface, relinquishing certain method implementations. This design enables the subclasses to shape these method behaviors per requirements. Any concrete subclass is obligated to furnish implementations to all abstract methods, thus ensuring abidance by the interface contract.

interface Movable {
    void move();
    void stop();
}

abstract class AbstractVehicle implements Movable {
    public void move() { /* Put the pedal to the...code! */ }
    // 'stop()'   Where's the break? 🙈
}

class Bike extends AbstractVehicle {
    public void stop() { /* E=mc2. Energy converts to mass(stops)!😎 */ }
}

Even though AbstractVehicle does not implement stop(), Bike as a concrete subclass, steps in to supply the specific details. This fills the Movable interface's expectations.

The nuts and bolts of abstract classes and interfaces

Making sense of partial implementation

In Java, the abstract class is a clever construct that allows creation of common behaviors (via implemented methods) and deferring some other method implementations to the concrete subclasses. In essence, they are a mould for creating objects where some assembly is required - a not-so-turnkey solution!

Essential roles of abstract classes

Enabling code reusability by allowing subclasses to inherit common methods and logic.
Providing a flexible structure for varied subclasses through partial-method-resistant interfaces.
Simplifying the interface implementation process by decoupling method specifics from the core logic.

Handling of abstract classes in Java and C#

Java is quite relaxed when it comes to enforcing the implementation of all interface methods in abstract classes. C#, in contrast, throws a fit and demands all missing methods be declared as public abstract.

Dangers that lurk and how to tame them

Failing to ensure all missing methods are implemented in the concrete subclasses leads to compilation errors.
Too many layers of inheritance may leave programmers bamboozled about which class is responsible for implementing which method.

Grasping the advantages of selective method implementation

Selectively implementing methods provides several design advantages:

Flexibility: The spice of good design

Code is more adaptable and can respond better to changing requirements.
Adherence to the programming to an interface principle fosters sensible separation of concerns.

Scalability and maintenance are not nightmares anymore!

Context-specific needs are efficiently handled with overriding in subclasses.
Additional functionalities can be incorporated without altering the existing abstract class.

Clarity isn't an illusion

Roles are clearly defined, making the code easier to understand.
Adopting this design ensures subclasses follow the prescribed manner, improving code stability.

The 'when' of using this strategy

The use of abstract classes is warranted when there is a clear hierarchy and common behavior across subclasses. However, refrain from using them when:

The interface methods are uniform across all classes and no variation is expected.
It's clear that the concrete class should directly implement all the interface methods.

explain-codes / Java / Why an abstract class implementing an interface can miss the declaration/implementation of one of the interface's methods?

Linked

Constructor in an Interface?



Abstract class in Java



Implements vs extends: When to use? What's the difference?



Java Multiple Inheritance



Why can outer Java classes access inner class private members?

