Integer类无需显式创建实例的原因及自定义类似类的方法

Great question! Let's break this down into two clear parts to answer what's going on here.

Part 1: The magic behind Integer name = 1245; #

This isn't "direct assignment" in the traditional sense—it's a Java syntax sugar called autoboxing introduced in Java 5 to simplify code.

When you write Integer name = 1245;, the Java compiler automatically translates this line to:

Integer name = Integer.valueOf(1245);

This avoids manual new Integer(1245) calls for two key reasons:

• Simplicity: It makes code cleaner and more readable, especially when working with collections (like List<Integer>) that require object types instead of primitives.
• Performance: The Integer.valueOf() method uses a built-in cache pool for integers between -128 and 127 (configurable for higher values in some environments). This reuses existing objects instead of creating new ones every time, reducing memory overhead.

Note that new Integer(1245) always creates a fresh object, while Integer.valueOf() may return a cached instance—another reason autoboxing is preferred over manual instantiation.

Part 2: Can we do this for a custom class like AsDigits digits = 1245;? #

Short answer: Java doesn't support user-defined autoboxing rules, so you can't get the exact syntax AsDigits digits = 1245; out of the box. But you can use simple tricks to achieve a similar clean, concise experience.

Option 1: Use a static factory method #

This is the most common and flexible approach. Create a private constructor (to force users to use your factory method) and add a static method (like of() or valueOf()) to create instances:

public class AsDigits {
    private final int numericValue;

    // Private constructor: prevents direct instantiation with `new`
    private AsDigits(int value) {
        this.numericValue = value;
    }

    // Static factory method to create instances
    public static AsDigits of(int value) {
        // Optional: Add your own caching logic here, like Integer's pool
        return new AsDigits(value);
    }

    // Add any methods you need for your class
    public int getNumericValue() {
        return numericValue;
    }
}

To use it:

AsDigits digits = AsDigits.of(1245);

This is almost as clean as the Integer example, and you get full control over how instances are created (like adding caching for frequently used values).

Option 2: Simplify further with static imports #

If you want to shorten the syntax even more, use a static import for the factory method:

import static com.yourpackage.AsDigits.of;

// Now you can write:
AsDigits digits = of(1245);

This cuts down on boilerplate and makes the code feel even closer to your desired syntax.

Option 3: Use Java 16+ Records (for simple data holders) #

If your AsDigits class is just a simple container for data (no complex business logic), Java 16's record type can simplify your code even more. Records automatically generate constructors, equals(), hashCode(), and toString() methods:

public record AsDigits(int numericValue) {
    // Add the static factory method
    public static AsDigits of(int value) {
        return new AsDigits(value);
    }
}

The usage stays the same as above, but you write far less boilerplate code.

Why can't we get the exact AsDigits digits = 1245; syntax? #

Java's autoboxing is a hardcoded language feature limited to the 8 primitive types and their corresponding wrapper classes (e.g., int ↔ Integer, boolean ↔ Boolean). There's no way to extend this behavior to custom classes—this is intentional, as it prevents the complexity and unexpected behavior that could come from user-defined implicit type conversions.

内容的提问来源于stack exchange，提问作者Mike Sraj