特定于类的方法可见性

Question

有没有一些面向对象的东西，你可以从某些类中调用一些方法，但不是全部？有没有类似protected的东西？

假设您有一个方法void foo()，并且您希望程序员可以在几个类型 类中使用它（可能类似于使用类型变量（指定：T type）。现在，也许有什么方法可以在不继承带有foo() 的类或创建接口的情况下指定哪些类或类的类型可以访问该方法？

我猜这可能类似于多重继承和多态性？但是我仍然希望只有类和某些类可以访问该方法而不改变该方法的可见性。我希望可见性是特定于类的。

这是一个例子：

class A 将 foo() 视为私有，但只有该类将其视为私有。
class B 将 foo() 视为公共/受保护，但只有该类将其视为公共。

方法类型为default。

我想更容易问和回答的是：“是否存在特定于类的可见性？”

Answer 1

在 C++ 中有类似您要求的东西，它被称为 friend classes。然而，Java 不支持该概念：

'Friends' equivalent for Java?

第二种选择是使用代码反射来访问类私有成员，但这不是一个干净的解决方案，仅适用于protected 元素：

public class C1 {

    public C1()
    {
        x = "Hello Word!";
    }

    protected String x;
}

在不同类的方法上：

String val = (String)obj.getClass().getDeclaredField("x").get(obj);
System.out.println("val: " + val);

编辑：经过一些研究，我发现甚至可以访问私人成员：

Field field = obj.getClass().getDeclaredField("x");
field.setAccessible(true);
String val = (String)field.get(obj);
field.setAccessible(false);

Answer 2

不，Java 中没有类似的东西。

您最接近的是将类放在同一个包中，此时它们可以访问任何未指定 any 访问修饰符的成员。但是你不能指定特定的类。

另一个适合一些情况的选择是使用嵌套类：

class Outer {
    private static class Inner {
    }
}

这里Outer 和Inner 可以访问彼此的私人成员。

Answer 3

访问级别

Modifier    Class   Package Subclass  World
public       Y        Y       Y        Y
protected    Y        Y       Y        N
no modifier  Y        Y       N        N
private      Y        N       N        N

thats your lot, there are not any other access modifiers.

Answer 4

只要花点功夫，你就可以让一个班级看起来像是两个不同的班级：

// An interface.
interface A {
    public void a ();
}

// Another interface.
interface B {
    public void b ();
}

// Deliberately NOT stating we implement either A or B but actually we implement both.
class C {
    public void a () {

    }
    public void b () {

    }
}

// Pick either implementation from C and tell the world about it.
class D extends C implements A {
    // Do nothing - already done by C.
}

class E extends C implements B {
    // Do nothing - already done by C.
}

public void test() {
    A d = new D();
    B e = new E();
}

这里的D 和E 实际上是功能相同的对象，因为它们实际上都是Cs。但是，在创建它们时，它们看起来像是 A 或 B，它们是两个不同的接口。

不幸的是，我们无法隐藏这样一个事实，即它们都扩展了 C，但更进一步的花招，我们也可以使用工厂来做到这一点。

// Hide the guts of it all in a factory.
static class Factory {
    // Make sure you MUST use the factory methods.
    private Factory () {

    }

    // Construct an A.
    public static A newA () {
        return new D();
    }

    // Construct a B.
    public static B newB () {
        return new E();
    }
}