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 highly readable. It has a clear structure with a single-purpose class, a private constructor preventing instantiation, and well-named constants. The defaultValue method is flat, using a straightforward if-else chain for primitive types, which is easy to follow. Intent is explicit via Javadoc and method naming. Granularity is excellent, with one logical action per line. The only slight complexity is the unchecked cast and suppression annotations, but these are necessary due to Java generics and are documented. Overall, it is concise, conventional, and easy for a Java developer to understand.
Run 2
The code is well-structured with clear intent. The class has a single responsibility, and the utility method is logically organized. The primitive type checks form a flat if-else chain rather than deep nesting, aiding readability. Each return statement is concise and clearly expresses one action per line. The Javadoc and annotations provide helpful context, and the constants for DOUBLE_DEFAULT and FLOAT_DEFAULT avoid repetition. However, the long if-else chain could be slightly improved by grouping types or using a lookup map, and the unchecked cast pattern, while documented, requires careful reading. Overall, the code is highly readable with minor room for structural optimization.
Run 3
The code is well-structured with clear purpose and excellent documentation. The class and method names are self-explanatory (Defaults, defaultValue), and the Javadoc clearly explains what the method does. The logic is straightforward: check for primitive types and return appropriate default values. While there is a chain of else-if statements for type checking, this is a common pattern for type-based dispatch and remains readable since each branch handles a single type. The constants for DOUBLE_DEFAULT and FLOAT_DEFAULT are appropriately used to avoid magic numbers. The nesting level is shallow (two levels maximum). Each action is on its own line, making the flow easy to follow. The private constructor properly prevents instantiation of this utility class. The suppression annotations are documented with a comment explaining why BooleanLiteral warning is suppressed. Overall, this demonstrates clean, maintainable code that follows good practices for utility classes.
Run 1
Code Structure: A focused utility class with logically grouped constants and a single clearly defined method. Nesting: Shallow overall, though the primitive check adds a nesting level around the conditional chain. Clarity of intent: Descriptive names and precise documentation explain default values, including null for reference types and void; generic casts add minor complexity. Code length: Appropriately concise, with some repetitive but understandable type checks. Action granularity: Each statement performs one clear action, making validation and returns easy to follow. Reading flow: The method progresses naturally from null validation to primitive-type handling and a final null fallback. Minor drawbacks are the lengthy else-if chain and limited visual separation between the package and imports.
Run 2
Code Structure: A focused utility class with a single public method, clearly separated constants, and a private constructor. Nesting: Only two levels deep; the primitive guard adds modest nesting, while the else-if chain remains easy to follow. Clarity of intent: Descriptive names and precise Javadoc explain default values, including null for reference types and void. Generic casts and suppression annotations introduce minor complexity. Code length: Appropriately concise, though primitive cases repeat a similar pattern. Action granularity: Each statement performs one clear action, with validation and returns on separate lines. Reading flow: Validation, primitive checks, and the null fallback form a natural sequence. Minor formatting limitations, such as missing separation between the package and imports, slightly reduce polish.
Run 3
Code Structure: A focused utility class with logically organized constants and a single public method. Nesting: Only two conditional levels, though an early return for non-primitive types could flatten the method. Clarity of intent: Descriptive names and precise documentation clearly explain default values, including null for reference types and void. Code length: Appropriately concise; the repetitive conditional chain is justified by explicit handling of each primitive type. Action granularity: Each statement performs one clear action, with checks and returns separated. Reading flow: Validation, primitive-type dispatch, and the null fallback follow a natural sequence. Minor readability costs come from repeated generic casts, the long else-if chain, and tightly spaced package/import declarations.