类特定的方法可见性

Question

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

假设您有一个方法void foo()，并且您希望它在几个类型类中可供程序员使用(可能使用类型变量(指定:T type))。现在，也许有一些方法，不继承带有foo()的类，也不创建接口，来指定哪些类或类型的类可以访问该方法?

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

下面是一个例子:

class A认为foo()是私有的，但只有这个类认为它是私有的。
class B将foo()视为public/protected，但只有该类将其视为public。

方法类型为default。

我想更容易问和回答的是:"是否有特定于类的可见性?"

Answer 1

在c++中有一种你想要的东西，叫做友类。然而，Java不支持这个概念:

& # 39;母亲# 39;等于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中没有这样的东西。

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

在一些情况下，另一个合适的选择是使用嵌套类:

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

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实际上是相同功能的对象，因为它们实际上都是C。然而，当它们被创建时，它们看起来像是A或B，这是两个不同的接口。

不幸的是，我们无法隐藏它们都扩展了C的事实，但是我们可以用Factory来做一点小技巧。

// 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();
    }
}