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 default2(Class<T> typ) {
checkNotNull(typ);
if (typ.isPrimitive()) {
if (typ == boolean.class) {
return (T) Boolean.FALSE;
} else if (typ == char.class) {
return (T) Character.valueOf('\0');
} else if (typ == byte.class) {
return (T) Byte.valueOf((byte) 0);
} else if (typ == short.class) {
return (T) Short.valueOf((short) 0);
} else if (typ == int.class) {
return (T) Integer.valueOf(0);
} else if (typ == long.class) {
return (T) Long.valueOf(0L);
} else if (typ == float.class) {
return (T) FLOAT_DEFAULT;
} else if (typ == double.class) {
return (T) DOUBLE_DEFAULT;
}
}
return null;
}
}
Run 1
The code is highly readable with clear structure: a private constructor, constants for float/double defaults, and a well-documented single purpose method. The nested if-else chain for primitive types is somewhat deep but logically sequential and unavoidable without a switch or map. The Javadoc explains the behavior clearly, including edge cases for void and non-primitives. Action granularity is good—one operation per line. The method name 'default2' is slightly ambiguous (suggests a version suffix), which detracts from clarity. Suppression annotations are justified with comments. The method is concise, though the if-else chain could be flatter. Overall, intent is clear, flow is natural, and length is appropriate.
Run 2
The code is well-structured and readable. It uses clear constants for float and double defaults, has a single-purpose static method, and follows a logical, flat if-else chain. Naming is mostly clear (e.g., DOUBLE_DEFAULT), and the Javadoc explains intent well. Each return is on its own line, and action granularity is good. Minor issues: the method name 'default2' is ambiguous (likely a typo or leftover), and the long if-else chain, while flat, could be slightly more concise with a switch or map. Overall, the code is easy to follow with only small readability concerns.
Run 3
The code is highly readable with clear structure and organization. It uses a logical if-else chain for type checking, maintaining flat nesting (only two levels deep). Each branch performs a single action, aligning with one-action-per-line granularity. The intent is immediately clear: return default values for primitive types and null otherwise. The method is concise despite handling eight primitive types, avoiding unnecessary verbosity. Javadoc and annotations enhance clarity without cluttering the logic. Minor deductions: the `@SuppressWarnings` annotation is slightly distracting, and the method name `default2` is unusual, but overall the code is exceptionally readable.
Run 1
Code Structure: Logically organized utility class with constants and one focused method. Nesting: Only two levels, though the primitive guard adds modest indentation around the conditional chain. Clarity of intent: Documentation and explicit type comparisons clearly explain the behavior; however, default2 and typ are less descriptive names, and the documentation references type rather than typ. Code length: Compact overall; the repetitive branches are reasonable for explicit primitive handling. Action granularity: Each statement performs one clear action, with no compressed multi-action lines. Reading flow: Validation, primitive checks, and the null fallback follow a natural sequence. Minor naming and import-spacing issues prevent a perfect score.
Run 2
Code Structure: A focused utility class with logically grouped constants and a single straightforward method. Nesting: Only two conditional levels, though the outer primitive check adds slight nesting. Clarity of intent: Documentation and explicit type comparisons clearly explain the behavior; however, default2 and typ are less descriptive names, and the documentation references type instead of typ. Code length: Concise overall; the repetitive conditional chain is justified by distinct primitive types. Action granularity: Each statement performs one clear action, with no compressed multi-action lines. Reading flow: Validation, primitive handling, and the null fallback follow a natural sequence. Minor naming issues and the lengthy if/else chain slightly reduce readability.
Run 3
Code Structure: A focused utility class with logically organized constants and a single method. Nesting: Only two conditional levels, though the long else-if chain adds scanning effort. Clarity of intent: Documentation and explicit primitive comparisons clearly explain behavior; however, default2 and typ are less descriptive names, and the documentation references type rather than typ. Code length: Concise overall, with repetitive branches justified by distinct primitive types. Action granularity: Each statement performs one action, and returns are clearly separated. Reading flow: The sequence from null validation to primitive handling and the final null fallback is natural. Minor formatting issues, such as missing separation between the package and imports, slightly reduce readability.