I have two classes Child extends Parent . I need to put @Builder annotation on the classes such that I do not need to create the builder my self.

package jerry;// Internal compiler error: java.lang.NullPointerException
import lombok.AllArgsConstructor;
import lombok.Builder;
@AllArgsConstructor(onConstructor=@__(@Builder))
public class Child extends Parent { 
//Multiple markers at this line
//  - Implicit super constructor Parent() is undefined. Must explicitly invoke another constructor
//  - overrides java.lang.Object.toString
   private String a;
   private int b;
   private boolean c;
@Builder
public class Parent {
    private double d;
    private float e;
I need to be able to build child instance such that 
Child child = Child.builder().a("aVal").b(1000).c(true).d(10.1).e(20.0F).build();
But so far I am getting the errors mentioned in side that code comments. Can any one point me to the right direction how to achieve it with lombok or any other similar library ?
Sub-question
Why does @AllArgsConstructor(onConstructor=@__(@Autowired)) compile but @AllArgsConstructor(onConstructor=@__(@Builder)) does not?
                I am trying to evaluate github.com/rzwitserloot/lombok/pull/1337/commits currently.
                    – zur
                Jul 7 '17 at 5:17
                    
See in https://blog.codecentric.de/en/2016/05/reducing-boilerplate-code-project-lombok/ (@Builder and inheritance part)
Adjusted to your classes
@AllArgsConstructor
public class Parent {
  private double d;
  private float e;
public class Child extends Parent {
  private String a;
  private int b;
  private boolean c;
  @Builder
  public Child(String a, int b, boolean c, double d, float e) {
    super(d, e);
    this.a = a;
    this.b = b;
    this.c = c;
With this setup
Child child = Child.builder().a("aVal").b(1000).c(true).d(10.1).e(20.0F).build();
works correctly
        https://stackoverflow.com/questions/44948858/lombok-builder-on-a-class-that-extends-another-class/44949692#44949692
            share
                    improve this answer
                Good point I did try that ... But I can not provide more than 7 params to any function which is a code convention in my team and build fails if I provide more than 7 params. My original code has more than 30 fields in super / parent class
                    – zur
                Jul 7 '17 at 3:50
                I don't know if it can be done without listing all the parent + child fields in the child constructor/@Builder, at least I did not find any such examples. As a workaround, you might consider to suppress this code convention for this particular class (at least I suppose it comes from some static code analyzer tool, like PMD, Findbugs, Sonar and such as can be suppressed)
                    – hammerfest
                Jul 7 '17 at 8:05
                @ShrikantPrabhu in that case, where I am now, I just abort the inheritance and copy the fields; it is lucky that there are just several field in common.
                    – WesternGun
                Jul 25 at 10:11
                    
Since release 1.18.2 lombok includes the new experimental @SuperBuilder. It supports fields from superclasses (also abstract ones). With it, the solution is as simple as this:
@SuperBuilder
public class Child extends Parent {
   private String a;
   private int b;
   private boolean c;
@SuperBuilder
public class Parent {
    private double d;
    private float e;
Child instance = Child.builder().b(7).e(6.3).build();
PS: @AllArgsConstructor(onConstructor=@__(@Builder)) does not work because @Builder is an annotation-processing annotation that lombok translates to code during compilation. Generating and then translating new lombok annotation would require several iterations of annotation processing, and lombok does not support that. @Autowired, in contrast, is a regular Java annotation available at runtime.
        https://stackoverflow.com/questions/44948858/lombok-builder-on-a-class-that-extends-another-class/51767718#51767718
            share
                    improve this answer
                    
I have a similar but slightly different use case. In my case, I have a chain of abstract super classes that build and execute requests. Different requests share some common parameters, but not every request supports all parameters. The builders for concrete requests should only provide methods for setting supported parameters for a given request. 
I started out with the constructor-based builder implementations, but this resulted in too much boilerplate code, especially if you have many fields to be configured. I have now come up with the following solutions, which looks much cleaner to me.
Basically the concrete subclasses define the actual fields that the Builder should support, and the Getter annotation results in the corresponding superclass methods to be overridden. The getters in the abstract superclasses can even be defined as abstract to require concrete implementations to define those fields.
public abstract class AbstractSuperClass1 {
    protected String getParamA() { return "defaultValueA"; }
    public final void doSomething() {
        System.out.println(getParamA());
        doSomeThingElse();
    protected abstract void doSomeThingElse();
public abstract class AbstractSuperClass2 extends AbstractSuperClass1 {
    protected String getParamB() { return "defaultValueB"; }
    protected void doSomeThingElse() {
        System.out.println(getParamB());
@Getter(AccessLevel.PROTECTED) @Builder
public class ConcreteClass1 extends AbstractSuperClass2 {
    private final String paramA;
    // Not supported by this implementation: private final String paramB;
    public static void main(String[] args) {
        ConcreteClass1.builder()
           .paramA("NonDefaultValueA")
           .build().doSomething();
@Getter(AccessLevel.PROTECTED) @Builder
public class ConcreteClass2 extends AbstractSuperClass2 {
    private final String paramA;
    private final String paramB;
    public static void main(String[] args) {
        ConcreteClass2.builder()
            .paramA("NonDefaultValueA").paramB("NonDefaultValueB")
            .build().doSomething();
        https://stackoverflow.com/questions/44948858/lombok-builder-on-a-class-that-extends-another-class/47597065#47597065
            share
                    improve this answer