Java类访问级别问题：子包类需访问上层包类但限制其他类访问

这个问题确实戳中了Java权限模型的一个小痛点——Java原生的访问权限体系里，并没有直接支持「仅允许子包类访问上层包特定类」的细粒度控制。不过我们有几种可行的方案来实现你的需求，按推荐程度排序如下：

1. 重构包结构（最推荐，符合Java设计理念） #

如果可以调整代码结构，最简单且安全的方式是把目标类和需要访问它的子包类移到同一个包下。这样你可以把目标类的访问权限设置为包私有（默认权限，不写任何修饰符），只有同包内的类能访问它，完美实现你的限制需求。

比如原来的结构：

com.example.parent
├─ TargetClass.java（public）
└─ child
   └─ AccessorClass.java

重构后：

com.example.parent.access
├─ TargetClass.java（包私有）
└─ AccessorClass.java

这种方式完全利用Java原生的权限控制，没有任何额外开销，也最符合封装原则。

2. 接口封装+运行时访问校验（无需改结构，安全可控） #

如果不能调整包结构，可以通过「接口暴露必要能力+工厂类校验调用者」的方式实现：

• 把目标类设为包私有，避免被任意类直接访问；
• 在目标类所在的上层包中定义一个public接口，让目标类实现该接口；
• 写一个public的工厂类，在提供实例前校验调用者是否是你指定的子包类，只有通过校验才返回实例。

示例代码：

// 上层包 com.example.parent
package com.example.parent;

import com.example.parent.child.AccessorClass;

// 暴露给外部的接口
public interface TargetService {
    void doBusiness();
}

// 包私有目标类，实现接口
class TargetClass implements TargetService {
    @Override
    public void doBusiness() {
        // 你的业务逻辑
    }
}

// 工厂类，控制访问权限
public class TargetFactory {
    public static TargetService getTargetInstance() {
        // 通过栈轨迹检查调用者是否是指定的子包类
        for (StackTraceElement stackElement : Thread.currentThread().getStackTrace()) {
            if (AccessorClass.class.getName().equals(stackElement.getClassName())) {
                return new TargetClass();
            }
        }
        throw new SecurityException("Access denied: Only AccessorClass can access TargetClass");
    }
}

子包类的调用方式：

// 子包 com.example.parent.child
package com.example.parent.child;

import com.example.parent.TargetFactory;
import com.example.parent.TargetService;

public class AccessorClass {
    public void useTarget() {
        TargetService target = TargetFactory.getTargetInstance();
        target.doBusiness();
    }
}

这种方式是运行时校验，虽然不能在编译阶段阻止非法访问，但能有效限制实际运行时的访问范围，且不会破坏封装。

3. Java模块系统（Java 9+，适合模块化项目） #

如果你的项目是基于Java 9及以上的模块化项目，可以通过模块声明来精确控制包的访问权限：

1. 确保上层包和子包属于同一个模块（或拆分到不同模块）；
2. 在module-info.java中，将目标类所在的包仅开放给指定的子包所在模块（如果是同一模块，可通过opens配合反射，但更推荐拆分模块）。

示例module-info.java（假设拆分模块）：

// 上层包所在模块：parent.module
module parent.module {
    // 仅将com.example.parent包开放给child.module
    exports com.example.parent to child.module;
}

// 子包所在模块：child.module
module child.module {
    requires parent.module;
}

这种方式是编译时+运行时的双重限制，非常严谨，但需要项目支持模块化，且可能需要调整模块结构。

4. 反射（不推荐，仅作为最后手段） #

如果以上方案都不可行，可以用反射来访问上层包的包私有类，但这种方式会破坏Java的封装性，且存在安全风险（比如安全管理器可能阻止反射操作）。

示例代码：

// 子包类 com.example.parent.child.AccessorClass
package com.example.parent.child;

import com.example.parent.TargetClass;
import java.lang.reflect.Constructor;

public class AccessorClass {
    public void useTarget() {
        try {
            // 通过反射获取目标类的构造方法
            Constructor<TargetClass> constructor = TargetClass.class.getDeclaredConstructor();
            // 取消访问检查
            constructor.setAccessible(true);
            TargetClass target = constructor.newInstance();
            // 调用目标类的方法
            target.doBusiness();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

注意：如果项目启用了Java模块系统，还需要在module-info.java中用opens com.example.parent to child.module来允许子包模块反射访问上层包。

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