例如，“朋友”概念在Java中很有用，可以将API与其实现分开。实现类通常需要访问API类的内部内容，但这些内容不应该公开给API客户端。这可以使用“朋友访问器”模式来实现，如下所示:

通过API公开的类:

package api;

public final class Exposed {
    static {
        // Declare classes in the implementation package as 'friends'
        Accessor.setInstance(new AccessorImpl());
    }

    // Only accessible by 'friend' classes.
    Exposed() {

    }

    // Only accessible by 'friend' classes.
    void sayHello() {
        System.out.println("Hello");
    }

    static final class AccessorImpl extends Accessor {
        protected Exposed createExposed() {
            return new Exposed();
        }

        protected void sayHello(Exposed exposed) {
            exposed.sayHello();
        }
    }
}

提供'friend'功能的类:

package impl;

public abstract class Accessor {

    private static Accessor instance;

    static Accessor getInstance() {
        Accessor a = instance;
        if (a != null) {
            return a;
        }

        return createInstance();
    }

    private static Accessor createInstance() {
        try {
            Class.forName(Exposed.class.getName(), true, 
                Exposed.class.getClassLoader());
        } catch (ClassNotFoundException e) {
            throw new IllegalStateException(e);
        }

        return instance;
    }

    public static void setInstance(Accessor accessor) {
        if (instance != null) {
            throw new IllegalStateException(
                "Accessor instance already set");
        }

        instance = accessor;
    }

    protected abstract Exposed createExposed();

    protected abstract void sayHello(Exposed exposed);
}

从'friend'实现包中的类的访问示例:

package impl;

public final class FriendlyAccessExample {
    public static void main(String[] args) {
        Accessor accessor = Accessor.getInstance();
        Exposed exposed = accessor.createExposed();
        accessor.sayHello(exposed);
    }
}

没有使用关键字左右。

你可以使用反射等“作弊”，但我不建议“作弊”。

我认为，使用朋友访问器模式的方法太复杂了。我不得不面对同样的问题，我使用Java中来自c++的优秀的旧复制构造函数来解决:

public class ProtectedContainer {
    protected String iwantAccess;

    protected ProtectedContainer() {
        super();
        iwantAccess = "Default string";
    }

    protected ProtectedContainer(ProtectedContainer other) {
        super();
        this.iwantAccess = other.iwantAccess;
    }

    public int calcSquare(int x) {
        iwantAccess = "calculated square";
        return x * x;
    }
}

在你的应用程序中，你可以写以下代码:

public class MyApp {

    private static class ProtectedAccessor extends ProtectedContainer {

        protected ProtectedAccessor() {
            super();
        }

        protected PrivateAccessor(ProtectedContainer prot) {
            super(prot);
        }

        public String exposeProtected() {
            return iwantAccess;
        }
    }
}

这种方法的优点是只有您的应用程序可以访问受保护的数据。它并不完全是friend关键字的替代。但我认为当您编写自定义库并且需要访问受保护的数据时，它非常适合。

当你必须处理ProtectedContainer的实例时，你可以将ProtectedAccessor包裹在它周围，这样你就获得了访问权。

它还适用于受保护的方法。在API中定义它们。稍后在应用程序中编写一个私有包装器类，并将受保护的方法公开为公共方法。就是这样。

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

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

只考虑

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

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

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

这里有一个小技巧，我用JAVA复制c++的朋友机制。

假设我有一个类罗密欧和另一个类朱丽叶。因为仇恨的原因，他们在不同的包裹(家庭)里。

罗密欧想要拥抱朱丽叶，而朱丽叶只想让罗密欧拥抱她。

在c++中，朱丽叶会宣布罗密欧是(恋人)朋友，但在java中没有这样的事情。

下面是这些类和诀窍:

女士优先:

package capulet;

import montague.Romeo;

public class Juliet {

    public static void cuddle(Romeo.Love love) {
        Objects.requireNonNull(love);
        System.out.println("O Romeo, Romeo, wherefore art thou Romeo?");
    }

}

这就是朱丽叶的方法。拥抱是公开的，但你需要一个罗密欧。我喜欢这么称呼它。它用的是罗密欧。Love作为“签名安全”，以确保只有Romeo可以调用此方法并检查爱是否真实，以便运行时在它为空时抛出NullPointerException。

现在，孩子们:

package montague;

import capulet.Juliet;

public class Romeo {
    public static final class Love { private Love() {} }
    private static final Love love = new Love();

    public static void cuddleJuliet() {
        Juliet.cuddle(love);
    }
}

罗密欧班。爱是公开的，但它的创造者却是私人的。因此，任何人都可以看到它，但只有罗密欧才能建造它。我用了一个静态的参考，所以罗密欧。从未使用过的爱只会被构建一次，不会影响优化。

因此，罗密欧可以拥抱朱丽叶，而且只有他可以，因为只有他可以构建和接近一个罗密欧。Love实例，Juliet需要它来拥抱她(否则她会用NullPointerException打你)。