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) 0x0);
} else if (type == short.class) {
return (T) Short.valueOf((short) 0x0);
} else if (type == int.class) {
return (T) Integer.valueOf(0x0);
} else if (type == long.class) {
return (T) Long.valueOf(0x0L);
} 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 well-structured with clear intent, good documentation, and a logical flow. The method is concise and each primitive type maps to a single return statement, keeping action granularity simple. Nesting is shallow, with only a two-level if/else chain inside a single outer check. However, readability suffers from the repetitive if-else chain, which could be replaced by a Map or switch for clarity. The use of constants for float and double defaults is inconsistent with inline values for other primitives, which slightly disrupts reading flow. Overall, it is readable but could be improved with a more uniform approach.
Run 2
The code is well-structured and readable. It has a clear purpose with a concise Javadoc explaining behavior. The method follows a logical flow: validate input, check primitive types, return default values, and fall back to null. Nesting is shallow—only two levels at most. Each action is on its own line, and the if-else chain for primitives is easy to scan. The use of constants for Float and Double avoids repetitive object creation, showing intent. Slight deductions for the repetitive primitive comparisons and unchecked casts, which add noise, and the boolean literal suppression is somewhat awkward. Overall, it is concise, clear, and maintainable, with only minor readability friction from generics and primitive type handling.
Run 3
The code is highly readable. It has a clear, logical structure with a single public method and private constructor. Nesting is shallow (two levels maximum). The intent is unambiguous: return the JLS default value for primitive types or null otherwise. The Javadoc clearly explains this behavior. The method is concise but not overly compressed, using a straightforward if-else chain. Each primitive check is on its own line, maintaining one action per line. The reading flow is natural: null check, primitive check, then ordered type comparison, ending with a null return. Constants for float/double defaults are a minor but sensible optimization. Minor deductions could be made for slight repetition in the if-else chain, but overall this is nearly ideal readable code.
Run 1
Code Structure: A focused utility class with logically grouped constants and a single public method. Nesting: Only two levels, keeping the conditional chain easy to follow. Clarity of intent: Descriptive names and precise documentation clearly explain default values, including null behavior. Generic casts and hexadecimal zero literals add slight cognitive overhead. Code length: Appropriately concise, though the repetitive primitive-type checks make the method somewhat verbose. Action granularity: Each statement performs one clear action, with no compressed multi-action lines. Reading flow: Validation, primitive checks, and the final null fallback form a natural progression. Minor formatting improvements, such as separating the package declaration from imports, could further improve readability.
Run 2
Code Structure: Well-organized utility class with constants and a single focused method. Nesting: Shallow overall, though the primitive check adds an avoidable level around the conditional chain. Clarity of intent: Descriptive names and Javadoc clearly explain defaults, including null for reference types and void; generic casts and hexadecimal zero literals add minor complexity. Code length: Concise, with repetitive branches justified by distinct primitive types. Action granularity: Each check and return occupies its own line, making behavior easy to scan. Reading flow: Validation, primitive dispatch, and the null fallback follow a natural sequence. Minor import-spacing and literal-consistency improvements could further enhance readability.
Run 3
Code Structure: A focused utility class with logically grouped constants and a single public method. Nesting: Only two conditional levels, though the long else-if chain could be flatter. Clarity of intent: Descriptive names and precise documentation clearly explain primitive defaults and null behavior. Code length: Appropriately concise; repetitive branches are straightforward and justified by distinct primitive types. Action granularity: Each statement performs one clear action, with validation separated from value selection. Reading flow: Sequential type checks and consistent formatting make the method easy to follow. Minor readability costs include unchecked generic casts, hexadecimal zero literals, and the unexplained distinction between cached floating-point defaults and inline boxed values.