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, logical structure: a private constructor, constants, and a single public method. The method's Javadoc clearly explains the intent and edge cases. Nesting is shallow (only two levels), and action granularity is one action per line within the if-else chain. The chain of primitive type checks is explicit and follows a natural order, though it is somewhat verbose; a switch statement or map could reduce length, but the current form prioritizes clarity. The only minor drawbacks are the unchecked casts and the suppressions, which slightly obscure the type-safety rationale. Overall, the code is straightforward, self-documenting, and easy to follow.
Run 2
The code is highly readable. The structure is logical and well-organized, with a clear class purpose documented in Javadoc. The method is concise and purpose-built. Nesting is shallow, with a single if-else chain inside an outer if that handles primitive types. Intent is immediately clear: return the JLS default for a given type. Action granularity is consistent, with one meaningful operation per line (cast and return). The reading flow is natural, checking non-null first, then handling primitives, and finally returning null for objects. The if-else chain is straightforward and avoids unnecessary complexity. Minor deductions: using both primitive wrappers and constants (FLOAT_DEFAULT, DOUBLE_DEFAULT) without explanation slightly breaks consistency, and repeated 'return (T)' casts add some visual noise. Overall, excellent readability in a utility method.
Run 3
The code is highly readable. Structure is logical: a final utility class with a private constructor, clear constant declarations, and a single-purpose method. Nesting is shallow—a two-level if/else chain is manageable given the unavoidable enumeration of primitives. Intent is clearly documented via Javadoc and method naming. Code length is appropriate; it handles all eight primitive types without redundancy. Each return statement is on its own line, maintaining action granularity. Reading flow is natural: null check, primitive verification, type-by-type dispatch, then fallback null return. The only minor blemish is the repetitive if/else chain, but a switch would not materially improve clarity for Class objects. Overall, this is a model of straightforward utility code.
Run 1
Code Structure: A well-organized utility class with a single focused method, clearly separated constants, and useful documentation. Nesting: Limited to two conditional levels; the primitive-type guard adds minor indentation. Clarity of intent: Descriptive names and Javadoc make the purpose and special cases explicit, though generic casts introduce slight complexity. Code length: Appropriately concise; the repetitive conditional chain is justified by distinct primitive types. Action granularity: Each statement performs one clear action, with no crowded lines. Reading flow: Validation, primitive checks, type-specific returns, and the null fallback follow a natural sequence. Minor drawbacks are the long else-if chain and lack of spacing between package and import sections.
Run 2
Code Structure: A focused utility class with clearly organized constants and a single public method. Nesting: Only two levels, though the outer primitive check adds some indentation. Clarity of intent: Descriptive names and precise documentation make the default-value behavior explicit; generic casts introduce minor complexity. Code length: Appropriately concise, with repetitive branches justified by distinct primitive types. Action granularity: Each statement performs one clear action, and each branch returns a single value. Reading flow: Validation, primitive dispatch, and the null fallback follow a natural sequence. Minor drawbacks are the lengthy else-if chain and cramped spacing around the package and imports.
Run 3
Code Structure: A focused utility class with logically organized constants and a single public method. Nesting: Only two conditional levels, though the outer primitive check adds slight indentation. Clarity of intent: Descriptive names and precise documentation clearly explain the default-value behavior, including null for void and reference types. Code length: Appropriately concise; the repetitive type checks are straightforward and justified. Action granularity: Each check and return performs one clear action, with no crowded statements. Reading flow: Validation, primitive handling, and the final null fallback follow a natural sequence. Minor drawbacks are the lengthy else-if chain and unchecked generic casts, which require some Java type-system knowledge.