6

我想对此进行一些讨论，但我无法推断出我的案例的答案。仍然需要帮助。

这是我的代码：

package JustRandomPackage;

public class YetAnotherClass{
    protected int variable = 5;
}

package FirstChapter;

import JustRandomPackage.*;

public class ATypeNameProgram extends YetAnotherClass{
    public static void main(String[] args) {

        YetAnotherClass bill = new YetAnotherClass();
        System.out.println(bill.variable); // error: YetAnotherClass.variable is not visible

    }
}

下面的一些定义，上面的例子似乎令人困惑：

 1. Subclass is a class that extends another class.
 2. Class members declared as protected can be accessed from 
    the classes in the same package as well as classes in other packages 
    that are subclasses of the declaring class.

问题：为什么我不能int variable = 5从子类YetAnotherClass实例（bill对象）访问受保护的成员（）？

4

5 回答 5

4

作为声明类的子类的其他包中的类只能访问它们自己继承的protected成员。

package FirstChapter;

import JustRandomPackage.*;

public class ATypeNameProgram extends YetAnotherClass{
    public ATypeNameProgram() {
        System.out.println(this.variable); // this.variable is visible
    }
}

...但不是其他对象的继承protected成员。

package FirstChapter;

import JustRandomPackage.*;

public class ATypeNameProgram extends YetAnotherClass{
    public ATypeNameProgram() {
        System.out.println(this.variable); // this.variable is visible
    }

    public boolean equals(ATypeNameProgram other) {
        return this.variable == other.variable; // error: YetAnotherClass.variable is not visible
    }
}
于 2013-06-12T05:31:16.273 回答
2

bill 不是子类 YetAnotherClass 的一部分。bill 是一个单独的 YetAnotherClass。

尝试int bill = this.variable;（在构造函数中）访问子类的成员。

于 2013-06-12T05:30:18.367 回答
1

如果您的代码YetAnotherClass与ATypeNameProgram. 正如其他人所写，它在其他情况下不起作用。这是工作示例。

package my.example;

public class MainClass extends MyAnotherClass {
    public static void main(String[] args) {
        MyAnotherClass bill = new MyAnotherClass();
        System.out.println(bill.value); // this will work
    }
}

package my.example;

public class MyAnotherClass {

    protected int value = 5;

}
于 2013-06-12T05:42:38.077 回答
1

只有当且仅当可分配给时，类Foo才能访问类型的受保护实例成员。即，如果我们可以写：BarBarFoo

Foo foo = new Bar();

例如，假设我们有：

package a;

public class Base {
    protected int protectedField;
}

然后我们可以有这个：

package b;

import a.Base;

public class Parent extends Base {
    void foo() {
        int i = this.protectedField;
    }
    void foo(Parent p) {
        int i = p.protectedField;
    }
    void foo(Child c) {
        int i = c.protectedField;
    }
}

class Child extends Parent { }

这将编译，因为所有protectedFields 都是通过Parent. 请注意，因为Parent引用可以是Child实例（即，我们可以编写Parent p = new Child();），所以我们可以访问c.protectedField.

以下将无法编译：

package b;

import a.Base;

public class Parent extends Base {
    void foo(Stepchild sc) {
        int i = sc.protectedField; // ERROR
    }
}

class Stepchild extends Base {}

因为 的 实例Stepchild不是 的Parent实例

有点令人困惑的是，这也不会编译：

package b;

import a.Base;

public class Parent extends Base {}

class Child extends Parent {
    void foo(Parent p) {
        p.protectedField; // ERROR
    }
}

这是因为Parent对象不是 的超类或超接口Child，因此Child无法访问其受保护的成员。

如果您记不住，请考虑是否可以将类型写入类类型的引用。例如，我们可以写：

Parent p = new Child();

但不能写

Child c = new Parent();     // ERROR
Parent p = new Stepchild(); // ERROR

所以Child将无法访问Parent受保护的成员，Parent也无法访问Stepchild受保护的成员。

最后几点：

请记住，protected访问允许包之间的可见性。根据我的经验，人们忘记了这一点。

最后，protected static成员在继承层次结构中始终可见。

于 2015-06-22T03:49:23.140 回答
0

您不是在创建扩展它的类的实例，而是创建父类的实例。检查下面的代码：

public class ATypeNameProgram extends YetAnotherClass{
    public static void main(String[] args) {

        YetAnotherClass bill = new YetAnotherClass();
        System.out.println(bill.variable); // error: YetAnotherClass.variable is not visible

        ATypeNameProgram a = new ATypeNameProgram();
        System.out.println(a.variable); //this will work

    }
}
于 2013-06-12T05:33:41.237 回答