public class NutritionFactsBuilder {
    private final int servingSize;
    private final int servings;
    private final int calories;
    private final int fat;
    private final int sodium;
    private final int carbohydrate;

    public static class Builder {
        // 필수 매개변수
        private final int servingSize;
        private final int servings;

        // 선택 매개변수 - 기본값으로 초기화.
        private int calories = 0;
        private int fat = 0;
        private int sodium = 0;
        private int carbohydrate = 0;

        public Builder(int servingSize, int servings) {
            this.servingSize = servingSize;
            this.servings = servings;
        }

        public Builder calories(int val) {
            calories = val;
            return this;
        }

        public Builder fat(int val) {
            fat = val;
            return this;
        }

        public Builder sodium(int val) {
            sodium = val;
            return this;
        }

        public Builder carbohydrate(int val) {
            carbohydrate = val;
            return this;
        }

        public NutritionFactsBuilder build() {
            return new NutritionFactsBuilder(this);
        }
    }

    private NutritionFactsBuilder(Builder builder) {
        servingSize = builder.servingSize;
        servings = builder.servings;
        calories = builder.calories;
        fat = builder.fat;
        sodium = builder.sodium;
        carbohydrate = builder.carbohydrate;
    }
}

NutritionFactsBuilder cola = new NutritionFactsBuilder.Builder(240, 8)
                .calories(100)
                .sodium(35)
                .carbohydrate(27)
                .build();8)

public abstract class Pizza {
    public enum Topping {
        HAM, MUSHROOM, ONION, PEPPER, SAUSAGE
    }

    final Set<Topping> toppings;

		// 재귀적인 타입 변수
    abstract static class Builder<T extends Builder<T>> {
        EnumSet<Topping> toppings = EnumSet.noneOf(Topping.class);

        public T addTopping(Topping topping) {
            toppings.add(Objects.requireNonNull(topping));
            return self();
        }

        abstract Pizza build();

        // 하위 클래스는 이 메서드를 재정의(overriding)하여 this를 반환
        protected abstract T self();
    }

    Pizza(Builder<?> builder) {
        toppings = builder.toppings.clone();
    }
} 

NYPizza pizza = new Builder(SMALL)
                .addTopping(SAUSAGE)
                .addTopping(ONION)
                .build();

        CalzonePizza calzone = new CalzonePizza.Builder()
                .addTopping(HAM)
                .sauceInside()
                .build();

public interface Comparable<T> {
	int compareTo(T o);
}

public static <E extends Comparable<E>> E max(Collection<E> c);

// 재귀적 타입 한정 빌더
abstract static class Builder<T extends Builder<T>> {

}

@Getter
@AllArgsConstructor
public class Parent {
    private final String parentName;
    private final int parentAge;
}
 
@Getter
public class Child extends Parent {
    private final String childName;
    private final int childAge;
 
    @Builder
    public Child(String parentName, int parentAge, String childName, int childAge) {
        super(parentName, parentAge);
        this.childName = childName;
        this.childAge = childAge;
    }

@Getter
@AllArgsConstructor
public class Parent {
    private final String parentName;
    private final int parentAge;

	  @Builder
    public Parent(String parentName, int parentAge) {
        this.parentName = parentName;
        this.parentAge = parentAge;
    }
}
 
@Getter
public class Child extends Parent {
    private final String childName;
    private final int childAge;
 
    @Builder
    public Child(String parentName, int parentAge, String childName, int childAge) {
        super(parentName, parentAge);
        this.childName = childName;
        this.childAge = childAge;
    }

@Getter
public class Child extends Parent {
    private final String childName;
    private final int childAge;
    
    @Builder(builderMethodName = "childBuilder")
    public Child(String parentName, int parentAge, String childName, int childAge) {
        super(parentName, parentAge);
        this.childName = childName;
        this.childAge = childAge;
    }
}

// 클라이언트 코드
Child child = Child.childbuilder()
  .parentName("Cloud")
  .parentAge(345)
  .childName("Sunny")
  .childAge(29)
  .build();

@Getter
@SuperBuilder
public class Parent {
    // same as before...
 
@Getter
@SuperBuilder
public class Child extends Parent {
   // same as before...

// 클라이언트 코드
Child child = Child.childbuilder()
  .parentName("Cloud")
  .parentAge(345)
  .childName("Sunny")
  .childAge(29)
  .build(); 

public abstract class PayCard {
    public enum Benefit {
        POINT("포인트"), SALE("할인"), SUPPORT("연회비지원");
        Benefit(String benefit) {

        }
    }

    final Set<Benefit> benefits;

    abstract static class Builder<T extends Builder<T>> {
        EnumSet<Benefit> benefits = EnumSet.noneOf(Benefit.class);

        public T addBenefit(Benefit benefit) {
            this.benefits.add(benefit);
            return self();
        }

        abstract PayCard build();

        protected abstract T self();
    }

    PayCard(Builder<?> builder) {
        benefits = builder.benefits.clone();
    }

}

public class KakaoCard extends PayCard {
    public enum Sale {
        GAME, KAKAO_STORE
    }

    private final Sale sale;

    public static class Builder extends PayCard.Builder<Builder> {
        private final Sale sale;

        public Builder(Sale sale) {
            this.sale = sale;
        }

        @Override
        public KakaoCard build() {
            return new KakaoCard(this);
        }

        @Override
        protected Builder self() {
            return this;
        }
    }

    KakaoCard(Builder builder) {
        super(builder);
        sale = builder.sale;
    }
}

// 클라이언트

KakaoCard kakaoCard = new KakaoCard.Builder(GAME)
                .addBenefit(POINT)
                .build();