Java 内部类可见性存在一些问题

我面对的是java内部类，而外部变量的可见性却有一些问题

class A {
    private int x = 5;
    class B extends A{
        public void fun(B b){
            b.x = 10; //here
        }
    }
}

---

如果内部类和外部类之间没有可见性限制，为什么我不能这样做（请参阅“here”标记）？我真的不理解这些规则。

修饰符

私有

不能在子类中访问

class A {
    private int x = 5; // The issue is in `private` in this line
    class B extends A{
        public void fun(B b){
            b.x = 10; //here
        }
    }
}

如果删除修饰符

private

并将其更改为

default

、

public

或

protected

，则可以访问该变量

为了更好地理解，请仔细阅读

更新：

---

Remove扩展了关键字（现在类B将不再是子类，而只是一个内部类），并且变量x只能使用this或super关键字访问。用法在

中详细说明。您需要知道这三个

专用

，

受保护

，

默认

，

公共

访问说明符

---

private

变量只能在自身类中修改。不包括

subclass

默认值

变量可以在同一个包中修改

受保护的

变量可以在子类中修改，也可以在同一个包和自身中修改

public

变量可以在任何地方修改

你可以在这上面看到这个

如果使用此示例，则可以使用

super

说明符修改变量，以访问可访问的

class A {
    private int x = 5;
    class B extends A{
        public void fun(B b){
            b.x = 10; //here error
            super.x=1;//this is ok
        }
    }
}

---

这

b.x=10//这里error

这个问题是b是方法的一个参数，不是成员变量或超类变量。

在您的示例中，成员变量

x

不是类b的属性，因此

b.x=10

不会产生错误，因此错误与可见性规则无关。尝试

x=10

效果很好，这是

a的捷径。这个.x=10

或

super.x=10

这个很特别。内部类可以访问外部类的私有字段。这可以通过

fun（A）

方法显示

class A {
    private int x = 5;
    class B extends A{

        public void fun(A a){
            a.x = 5; //Valid since we are in the same class (inner-class can access private field)
        }
}

现在，如果您有一个

B

参数，这有点不同，因为它将尝试使用继承而不是外部内部链接：

public void fun(B b){
    b.x = 10; //Access using inheritence, not OK for private field
    ((A)b).x = 10; //Casting into A to be able to access the private field (just like fun(A).
}

请注意，这是一个问题，因为在参数中更新引用receive，可以轻松地更新当前内部实例

public void fun(){
    x = 10; //OK : access to A.x from inner class
    super.x = 10; //OK : same

    this.x = 10; // KO : trying to access a private variable from B scope
}

---

private

变量只能在类本身中修改，不能从子类中修改。可能重复：它是一个内部类而不是子类。@StripeColossus两者都是。更新了答案@StripeColossus，但内部类可以访问它们！“成员变量

x

不是类

B

的属性”：尽管如此，我相信问题实际上是关于

a之间的区别和
b.x=10。毕竟，两者都是
B
实例（或者这就是混淆的地方）？您需要更新
B
实例，而不是
this
，您可以通过将实例强制转换为不确定的可见性（因为我们在一个内部类中）<代码>（（A）b）.x=10两行做的事情不一样。第一次更新
b
，第二次更新
this
…是的，但是
x=10
修改变量x，而
super.x=10
修改从A继承的b变量x，对不对，
x=10
与
super.x=10
相同
x
仅存在于
A
中，因此
B
中没有变量
x
。