Java私有访问内部类：替换Pair为自定义内部类的最佳实现方式

一、创建仅类A内部使用的私有内部类 #

想让自定义类只在A内部可见、外部完全访问不到？直接给内部类加上private修饰符就行——这样外部代码根本看不到这个类，只能在A的方法里用它存数据。

修改后的完整代码：

public class A {
    // 把Map的泛型改成Integer和私有内部类NamePair
    private Map<Integer, NamePair> map = new HashMap<>();
    
    // 私有内部类，只有A能访问
    private class NamePair {
        private String nameEn;
        private String nameEs;

        public NamePair(String nameEn, String nameEs) {
            this.nameEn = nameEn;
            this.nameEs = nameEs;
        }

        // 只给A内部用的getter，不用对外暴露
        public String getNameEn() {
            return nameEn;
        }

        public String getNameEs() {
            return nameEs;
        }
    }

    public class B {
        private String name1;
        private String name2;

        public B(String name1, String name2) {
            this.name1 = name1;
            this.name2 = name2;
        }

        // 对外暴露的getter
        public String getName1() {
            return name1;
        }

        public String getName2() {
            return name2;
        }
    }

    public void start() {
        // 用私有内部类存一对值
        map.put(1, new NamePair("One", "Una"));
    }

    public B stop(int val) {
        if (map.containsKey(val)) {
            NamePair pair = map.get(val);
            // 从内部类取数据，构造对外的B实例
            return new B(pair.getNameEn(), pair.getNameEs());
        }
        return null;
    }
}

这里的NamePair被private修饰，只有类A能创建和访问它的实例，完美满足“仅内部处理、不对外暴露”的要求。

二、其他实现建议 #

1. 用Java 16+的私有记录类（更简洁） #

如果你的项目用Java 16及以上，直接用私有记录类会省很多代码——记录类自动生成构造器、getter、equals这些方法，不用手动写：

public class A {
    private Map<Integer, NamePair> map = new HashMap<>();
    
    // 私有记录类，替代手动写的内部类
    private record NamePair(String nameEn, String nameEs) {}

    public class B {
        // 保持原来的结构不变
        private String name1;
        private String name2;

        public B(String name1, String name2) {
            this.name1 = name1;
            this.name2 = name2;
        }

        public String getName1() { return name1; }
        public String getName2() { return name2; }
    }

    public void start() {
        map.put(1, new NamePair("One", "Una"));
    }

    public B stop(int val) {
        NamePair pair = map.get(val);
        return pair != null ? new B(pair.nameEn(), pair.nameEs()) : null;
    }
}

2. 静态私有内部类（更高效） #

如果你的内部类不需要访问A的实例变量或方法，把它改成private static的——这样它不持有外部类A的引用，内存使用更高效，还能避免潜在的内存泄漏：

// 静态私有内部类
private static class NamePair {
    private String nameEn;
    private String nameEs;

    public NamePair(String nameEn, String nameEs) {
        this.nameEn = nameEn;
        this.nameEs = nameEs;
    }

    public String getNameEn() { return nameEn; }
    public String getNameEs() { return nameEs; }
}

3. 直接复用对外的B类（如果逻辑允许） #

如果B类的结构和你要存的内部数据完全一样，也可以直接用B类当Map的存储类型，省掉额外的内部类：

public class A {
    private Map<Integer, B> map = new HashMap<>();
    
    public class B {
        private String name1;
        private String name2;

        public B(String name1, String name2) {
            this.name1 = name1;
            this.name2 = name2;
        }

        public String getName1() { return name1; }
        public String getName2() { return name2; }
    }

    public void start() {
        map.put(1, new B("One", "Una"));
    }

    public B stop(int val) {
        return map.get(val);
    }
}

不过这种方式要注意：外部代码可以直接实例化B类，如果需要严格区分“内部存储对象”和“对外返回对象”，还是用私有内部类更稳妥。

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