JAVA自定义包装类 MyInteger 实现

简述：

实现一个简单的包装类 MyInteger，模仿 Java 的 Integer 类的基本功能，包括基本类型转换、对象转换和缓存处理。

实现MyInteger类：

package com.SomeClass.A.MyIntegerClass;

/**
 * 自定义整数包装类 {@code MyInteger}，模拟 Java 标准库中 {@code Integer} 的核心功能。
 * 

 * 该类实现了以下核心特性：
 * 

 *   
将基本数据类型 {@code int} 包装为对象
 *   
提供对象与基本类型之间的转换方法
 *   
对常用数值范围 [-128, 127] 实现缓存优化
 * 
 *
 * @author YourName
 * @version 1.0
 * @since 2023-10-20
 */
public final class MyInteger {
    /**
     * 存储包装的整数值，使用 {@code final} 修饰确保不可变性。
     * 

     * 设计要点：
     * 

     *   
包装类应该是不可变类（Immutable Class）
     *   
私有字段防止外部直接访问
     * 
     */
    private final int value;

    /**
     * 缓存下限值（包含），与 {@link Integer#valueOf(int)} 使用的缓存范围一致。
     */
    private static final int LOW = -128;

    /**
     * 缓存上限值（包含），与 {@link Integer#valueOf(int)} 使用的缓存范围一致。
     */
    private static final int HIGH = 127;

    /**
     * 静态缓存数组，存储预先创建的 {@code MyInteger} 对象。
     * 

     * 缓存机制说明：
     * 

     *   
数组长度：{@code HIGH - LOW + 1}（256个元素）
     *   
索引计算：{@code 实际值 - LOW}
     * 
     */
    private static final MyInteger[] cache = new MyInteger[HIGH - LOW + 1];

    /**
     * 静态初始化块，在类加载时初始化缓存数组。
     * 

     * JVM 知识：
     * 

     *   
静态块在类首次加载时执行
     *   
线程安全由 JVM 保证
     * 
     */
    static {
        // 填充缓存数组
        for (int i = 0; i < cache.length; i++) {
            cache[i] = new MyInteger(LOW + i);
        }
    }

    /**
     * 私有构造方法，强制通过 {@code valueOf()} 工厂方法创建对象。
     * 

     * 设计模式：
     * 

     *   
工厂方法模式（Factory Method Pattern）
     *   
防止直接实例化，确保缓存机制有效
     * 
     *
     * @param value 要包装的整数值
     */
    private MyInteger(int value) {
        this.value = value;
    }

    /**
     * 将基本类型 {@code int} 转换为 {@code MyInteger} 对象（推荐实例化方式）。
     * 

     * 缓存机制：
     * 

     *   
值在 [-128, 127] 范围内：返回缓存对象
     *   
其他值：创建新对象
     * 
     *
     * @param value 要包装的整数值
     * @return {@code MyInteger} 对象实例
     * @see #intValue()
     */
    public static MyInteger valueOf(int value) {
        if (value >= LOW && value <= HIGH) {
            return cache[value - LOW]; // 返回缓存对象
        }
        return new MyInteger(value); // 新建对象
    }

    /**
     * 获取包装的基本类型值（拆箱操作）。
     * 

     * 类型转换：
     * 

     *   
实现对象到基本类型的转换
     *   
与 {@code valueOf()} 构成装箱/拆箱对
     * 
     *
     * @return 包装的整数值
     * @see #valueOf(int)
     */
    public int intValue() {
        return value;
    }

    /**
     * 返回该值的字符串表示形式。
     * 

     * 规范：
     * 

     *   
重写 {@code Object.toString()}
     *   
与 {@code Integer.toString()} 行为一致
     * 
     *
     * @return 该整数的十进制字符串表示
     * @see Integer#toString(int)
     */
    @Override
    public String toString() {
        return Integer.toString(value);
    }

    /**
     * 比较两个 {@code MyInteger} 对象的值是否相等。
     * 

     * 注意：
     * 

     *   
遵循相等契约：自反性、对称性、传递性
     *   
缓存对象可以用 {@code ==} 比较，非缓存对象必须用 {@code equals}
     * 
     *
     * @param obj 要比较的对象
     * @return 如果对象相同或值相等返回 {@code true}
     * @see #hashCode()
     */
    @Override
    public boolean equals(Object obj) {
        if (obj instanceof MyInteger) {
            return this.value == ((MyInteger) obj).value;
        }
        return false;
    }

    /**
     * 返回该对象的哈希码值。
     * 

     * 规范：
     * 

     *   
必须与 {@code equals()} 保持一致
     *   
直接返回包装的值作为哈希码
     * 
     *
     * @return 该对象的哈希码值
     * @see #equals(Object)
     */
    @Override
    public int hashCode() {
        return value;
    }
}

测试代码： 

package com.SomeClass.A.MyIntegerClass;

public class Main {
    public static void main(String[] args) {
        // 使用valueOf创建MyInteger对象（推荐）
        MyInteger num1 = MyInteger.valueOf(100);  // 使用缓存
        MyInteger num2 = MyInteger.valueOf(100);  // 使用缓存
        MyInteger num3 = MyInteger.valueOf(200);  // 新建对象

        System.out.println(num1.intValue());  // 输出: 100
        System.out.println(num1.equals(num2));  // 输出: true
        System.out.println(num1 == num2);     // 输出: true (同一缓存对象)
        System.out.println(num1 == MyInteger.valueOf(200)); // 输出: false
    }
}