effective-java | examples with Guava

The reason for the compile error is due to Object.getClass() method. According to the java doc:

Returns the runtime class of this Object. The returned Class object is the object that is locked by static synchronized methods of the represented class.

The actual result type is Class where |X| is the erasure of the static type of the expression on which getClass is called. For example, no cast is required in this code fragment:

Number n = 0;
Class c = n.getClass();

When calling return Result.builder(resource.getClass()).build();

1. resource.getClass() will return Class as Resource is the erasure of T
2. Result.builder(resource.getClass()) method will return Builder.
3. Result.builder(resource.getClass()).build() will return Result.

The type information for T is lost in step 1. Hence compile error is shown as return type is incompatible. The following changes can be made to solve the error.

1. Change the builder method to accept T instance instead of Class as state in your comment.
2. Change the caller to pass Class instead of Class to builder method.

Code snippet for the changes:

If you want to keep the import/export of es6 you should define module:"es2015", by default, it converts those to cjs style that is used within node.

Modern browsers are no supports node's cjs style but es2015 style, so you need to specify that module type, and specify on your script tag an attribute of type="module", something like that:

Your guess is probably right. The ^= operator and the if statement at the end are both to prevent compiler/runtime optimisations.

Initially b is false, b ^= true assigns true to b, then b ^= true assigns false to b, and the cycle continues.

By making b cycle through true and false, it makes it harder for the compiler to optimise this because it doesn't see a constant value.

Another property of ^ is that both operands must be evaluated in order to evaluate the result, unlike || or &&. The runtime can't take shortcuts.

The if statement at the end is telling the compiler and the runtime: "don't ignore b! It is of important use later!".

The last two lines force the compiler to run the whole loop, to find the value of x. Otherwise it might detect that x is not being used at all and ignore the loop, given that inside of it no "real" work is being made. Even though sum() is called repeatedly, the result of accumulating its returned value would be discarded in the end if we do nothing with x.

Of course, this assumes that the println() statement inside the loop can be safely ignored, I'm unsure if the compiler can make such a decision. That would be one aggressive compiler!

It is best practice to handle, and provide meaningful message to client side. REST frameworks usually provides way to configure exception handlers, and mappers. Check this for Spring. You can find similar mechanism for your REST framework.

The answer to your question described in detail at https://softwareengineering.stackexchange.com/questions/362265/builder-with-constructor-or-factory-method. I see that your question is more specific to Project Lombok's design so you might want to join the community. But in general I agree with the accepted answer and the way Lombok implemented the builder pattern using a factory method.