我更喜欢委托、组合或工厂类(取决于导致这个问题的问题)，以避免将其设置为公共类。

如果是“不同包中的接口/实现类”问题，那么我将使用一个公共工厂类，它将与impl包位于同一个包中，并防止impl类的暴露。

如果这是一个“我讨厌让这个类/方法公开，只是为了在不同的包中为其他类提供这个功能”的问题，那么我会在同一个包中使用一个公共委托类，并且只公开“外部”类所需的部分功能。

其中一些决策是由目标服务器类加载体系结构(OSGi包、WAR/EAR等)、部署和包命名约定驱动的。例如，上面提出的解决方案“朋友访问器”模式对于普通的java应用程序非常聪明。我想知道在OSGi中实现它是否会因为类加载风格的不同而变得棘手。

从Java 9开始，可以使用模块在许多情况下解决这个问题。

如果你想访问受保护的方法，你可以创建一个你想要使用的类的子类，它将你想要使用的方法公开为公共的(或者是更安全的命名空间内部的)，并在你的类中有一个类的实例(将它用作代理)。

就私人方法而言(我认为)你运气不好。

提供的解决方案可能不是最简单的。另一种方法基于与c++相同的思想:除了所有者与自己为友的特定类外，在包/私有作用域之外不能访问私有成员。

需要对成员进行友元访问的类应该创建一个内部公共抽象“友元类”，拥有隐藏属性的类可以通过返回实现访问实现方法的子类导出对该类的访问。友元类的“API”方法可以是私有的，因此在需要友元访问的类外部无法访问它。它的唯一语句是对导出类实现的抽象受保护成员的调用。

代码如下:

首先是验证它是否实际工作的测试:

package application;

import application.entity.Entity;
import application.service.Service;
import junit.framework.TestCase;

public class EntityFriendTest extends TestCase {
    public void testFriendsAreOkay() {
        Entity entity = new Entity();
        Service service = new Service();
        assertNull("entity should not be processed yet", entity.getPublicData());
        service.processEntity(entity);
        assertNotNull("entity should be processed now", entity.getPublicData());
    }
}

然后，需要友方访问Entity的包私有成员的服务:

package application.service;

import application.entity.Entity;

public class Service {

    public void processEntity(Entity entity) {
        String value = entity.getFriend().getEntityPackagePrivateData();
        entity.setPublicData(value);
    }

    /**
     * Class that Entity explicitly can expose private aspects to subclasses of.
     * Public, so the class itself is visible in Entity's package.
     */
    public static abstract class EntityFriend {
        /**
         * Access method: private not visible (a.k.a 'friendly') outside enclosing class.
         */
        private String getEntityPackagePrivateData() {
            return getEntityPackagePrivateDataImpl();
        }

        /** contribute access to private member by implementing this */
        protected abstract String getEntityPackagePrivateDataImpl();
    }
}

最后:Entity类，它仅对类application.service.Service提供对包私有成员的友好访问。

package application.entity;

import application.service.Service;

public class Entity {

    private String publicData;
    private String packagePrivateData = "secret";   

    public String getPublicData() {
        return publicData;
    }

    public void setPublicData(String publicData) {
        this.publicData = publicData;
    }

    String getPackagePrivateData() {
        return packagePrivateData;
    }

    /** provide access to proteced method for Service'e helper class */
    public Service.EntityFriend getFriend() {
        return new Service.EntityFriend() {
            protected String getEntityPackagePrivateDataImpl() {
                return getPackagePrivateData();
            }
        };
    }
}

好吧，我必须承认它比“friend service:: service;”稍微长一点，但是可以在使用注释保留编译时检查的同时缩短它。

我曾经见过一个基于反射的解决方案，它在运行时使用反射进行“好友检查”，并检查调用堆栈，以查看调用该方法的类是否允许这样做。作为运行时检查，它有一个明显的缺点。

据我所知，这是不可能的。

也许，你可以给我们更多关于你的设计的细节。像这样的问题很可能是设计缺陷造成的。

只考虑

如果这些类如此密切相关，为什么它们在不同的包中? A是否访问B的私有成员，或者操作是否应该移动到类B并由A触发? 这是真正的调用还是事件处理更好?