Source code
package com.google.common.base; import static com.google.common.base.Preconditions.checkNotNull;
import com.google.common.annotations.GwtIncompatible; import com.google.common.annotations.J2ktIncompatible;
import org.jspecify.annotations.Nullable;
/**
* This class provides default values for all Java types, as defined by the JLS.
*
* @author Ben Yu
* @since 1.0
*/
@J2ktIncompatible @GwtIncompatible
public final class Defaults { private Defaults() {}
private static final Double DOUBLE_DEFAULT = 0d; private static final Float FLOAT_DEFAULT = 0f; /**
* Returns the default value of {@code type} as defined by JLS --- {@code 0} for numbers, {@code
* false} for {@code boolean} and {@code '\0'} for {@code char}. For non-primitive types and
* {@code void}, {@code null} is returned.
*/ @SuppressWarnings({
"unchecked",
"BooleanLiteral" // `(T) false` would produce an error
})
public static <T> @Nullable T defaultValue(Class<T> type) { checkNotNull(type);
if (type.isPrimitive()) { if (type == boolean.class) {
return (T) Boolean.FALSE;
} else if (type == char.class) { return (T) Character.valueOf('\0');
} else if (type == byte.class) { return (T) Byte.valueOf((byte) 0);
} else if (type == short.class) {
return (T) Short.valueOf((short) 0); } else if (type == int.class) { return (T) Integer.valueOf(0);
} else if (type == long.class) {
return (T) Long.valueOf(0L);
} else if (type == float.class) {
return (T) FLOAT_DEFAULT; } else if (type == double.class) {
return (T) DOUBLE_DEFAULT;
}
}
return null; }
}
Run 1
The code is functionally simple but formatted extremely poorly, making it hard to read. Imports and field declarations are crammed onto single lines. The Javadoc for defaultValue is placed between the FLOAT_DEFAULT field and the method annotation, disrupting logical grouping. The if-else chain for primitive types is compressed into a single block with inconsistent line breaks, and some closing braces share lines with the next statement. This violates standard Java formatting conventions and reduces clarity of intent. Action granularity suffers because multiple statements or annotations appear on one line. The reading flow is disorganized. While the logic itself is straightforward, the lack of consistent structure, poor spacing, and unnatural line breaks make the code unnecessarily difficult to parse.
Run 2
The code is functionally correct but poorly formatted for readability. Multiple statements are crammed onto single lines, especially the imports, field declarations, and method signature. Deeply nested conditionals make the logic hard to follow, and the action granularity violates the one-action-per-line principle. The intent is clear — returning JLS default values — but the physical layout obscures it. There is also inconsistent brace placement and spacing. Reformatting with proper line breaks, one statement per line, and cleaner indentation would significantly improve readability.
Run 3
The code is functionally correct but poorly formatted, making it difficult to read. The package and import statements are compressed onto single lines, violating conventional structure. The class body contains multiple declarations and method comments crammed together without line breaks, obscuring the logical organization. While the if-else chain for checking primitive types is relatively flat, its spacing and indentation are inconsistent, harming readability. The intent of defaultValue is clear from the Javadoc, but the implementation is visually cluttered. The code length is acceptable, but action granularity suffers due to multiple statements sharing lines, disrupting the natural reading flow. Proper formatting, consistent indentation, and separating declarations would significantly improve readability.
Run 1
Code Structure: The class has a logical organization, with constants and a single lookup method, but compressed formatting obscures boundaries. Nesting: Only two conditional levels are used, though the long if/else chain and inconsistent brace placement make scanning harder. Clarity of intent: Descriptive names, explicit type comparisons, and helpful documentation clearly explain the purpose. Code length: The implementation is reasonably concise for handling primitive types, with little unnecessary code. Action granularity: Imports, declarations, checks, and returns frequently share lines, reducing readability. Reading flow: The underlying logic follows a natural sequence, but crowded annotations, inline comments, and irregular line breaks interrupt that flow.
Run 2
Code Structure: The utility class logically groups constants and a single method, but compressed formatting obscures those boundaries. Nesting: An outer primitive check contains an if/else chain; nesting is modest, though inconsistent brace placement complicates scanning. Clarity of intent: Descriptive names and Javadoc clearly explain default values and null behavior. Code length: The implementation is reasonably concise, with little unnecessary code. Action granularity: Multiple imports, declarations, and statements share lines, reducing readability and violating one-action-per-line presentation. Reading flow: Type checks follow a sensible sequence, but irregular indentation, inline returns, and comments attached to declarations interrupt natural reading.
Run 3
Code Structure: The utility class logically groups constants and a single method, but compressed declarations and inconsistent formatting obscure that organization. Nesting: An outer primitive check wraps a straightforward if/else chain; nesting is moderate rather than deep. Clarity of intent: Descriptive names, explicit type comparisons, and clear Javadoc make the purpose easy to understand. Code length: The implementation is reasonably concise, with little unnecessary code. Action granularity: Multiple imports, declarations, checks, and returns share lines, making individual actions harder to distinguish. Reading flow: The type checks follow a sensible sequence, but irregular indentation, inline braces, and comments attached to declarations interrupt scanning. Overall, the logic is readable, while presentation substantially reduces readability.