Subclassing a Java Builder Class

java

builder-pattern

generics

inheritance

byAnton Shumikhin·Jan 18, 2025

Soup up your Java Builder subclassing by embracing self-referential generics. Set the Builder<T extends Builder<T>> parameter to ensure the return type from your subclass methods is spot on. Here it is in practice:

public class Parent {
    // Parent fields and methods

    // Base builder with self-referential type parameter
    public static class Builder<T extends Builder<T>> {
        // Chainable builder methods here

        // Returning 'this' as a T, generics in disguise!
        protected T self() {
            return (T) this;
        }

        public T setSomething(...) {
            // Sprinkle set logic here
            return self();  // Generics, the unseen hero
        }

        public Parent build() {
            return new Parent(/* args */);
        }
    }
}

public class Child extends Parent {
    // Child specific fields and methods

    // Child's builder extending Parent's
    public static class ChildBuilder extends Parent.Builder<ChildBuilder> {
        public Child build() {
            return new Child(/* args */);
        }

        // Child specific builder methods here
        public ChildBuilder setAnotherThing(...) {
            // Set logic for child; not over-parenting
            return this; // proper type, no need for the casting couch
        }

        @Override
        protected ChildBuilder self() {
            return this;
        }
    }
    
    // Access Child's builder
    public static ChildBuilder builder() {
        return new ChildBuilder();
    }
}

Implement this builder pattern for a more streamlined subclassing. Keep your interfaces fluid and return types correct when building those subclasses, every builder's dream.

Generics in builders - The Secret Sauce

Generics bring the spice to the builder pattern by introducing type safety and a ton of flexibility. By creatively using generics, you're giving a guarantee that your builder's methods will return the correct subclass builder instance, keeping the fluent interface and the chain of method calls intact.

Overcoming type safety landmines

Using generics lets us safely skip past type-casting and dodge those pesky unchecked cast warnings. Using the self() method, a method so cool it recurrently refers to itself (talk about self love! 🤯), enables method chaining across the correct subclass builder type, dodging any runtime class cast speedbumps.

Catering to Complex Inheritance Parties

Now if your ears prick up at the mention of builder hierarchies, fear not. When dealing with more complex hierarchies, just declare Builder<T extends Builder<T>> in each class of the hierarchy. From getThis() to self(), we ensure a smooth ride across the hierarchy and allow for covariant return types in subclasses.

The Magic of Final Classes

Time for some magic! 🎩💫. When the buck stops at a final class in the hierarchy, we finalize the type for the Builder's generic parameter to halt any future subclassing attempts. This way, we maintain builder integrity.

The Lesser-known Work of Tools like Lombok

If you want to slash the boilerplate code in half while dipping your toes in the builder patterns, say hello to your new friend, Lombok. Use @Builder and @Getter annotations like fairy dust and watch your classes light up!

Real-world Crafts using Builder Pattern

The builder pattern really shows off its muscle when crafting configurations for complex objects that come with an overwhelming list of attributes. In the big, wide world of stream API, builder patterns work tirelessly behind the scenes to create crystal clear syntax and easy-to-maintain structure.

Pit Stops on the Road to Subclass Builders

Copy Constructors: Cloner in Chief!

Incorporating a copy constructor within the builder can be your match-winning stroke. It paves the way for creating an object based on another's state, perfect for immutable objects and initiating objects with a similar configuration.

Subclassing Safety Nets in Place

As a developer, while builder patterns are your golden ticket, it's essential to watch your step when building with inheritance hierarchies. Make sure that the builder methods in the subclass are playing nice and not breaking the contract of the superclass builder's methods.

Builder Abstracts for the Win!

For deeper class hierarchies, bring abstract builder classes into the game. This provides a framework for the builders of concrete classes, ensuring the consistent application of the builder pattern from the ground up through the skyscraper.

explain-codes / Java / Subclassing a Java Builder Class

Linked

How to use Class<T> in Java?



Do I really have a car in my garage?



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



How do you cast a List of supertypes to a List of subtypes?



Java Generics With a Class & Interface - Together

